Files
luxe/crates/luxe-remote/app/transcript.js
Evan Whittaker a0666d6c81 luxe 0.1.4: remembered models, wheel-driven lists, and a steadier phone app
- luxe starts on the model you last chose in this project, then the last one anywhere. Signing in
  opens the model picker instead of choosing for you.
- Every list in a modal takes the mouse wheel and a draggable scrollbar.
- The phone app shows reasoning in full, stays put while you read back through a long session, and
  shows a question's answer on its card.
- On Windows, luxe update replaces the running luxe, and a signed-in install no longer sees setup
  again.
- The file tree no longer shows "engine busy" in a large project, loop output is easier to follow,
  and the name is written lowercase.

The CHANGELOG has the full list.
2026-10-20 13:51:34 -05:00

280 lines
11 KiB
JavaScript

// The transcript as the phone shows it, folded from a session's frames.
//
// Each item carries its own signals, so a reply streaming in re-renders one text node rather
// than the list. The fold mirrors the TUI's: deltas grow provisional items, `message_committed`
// replaces them with what was saved, tool cards follow `tool_activity_updated` by call id, and
// `session_loaded` starts over from the saved history.
import { batch, signal } from "@preact/signals";
/** @import { Signal } from "@preact/signals" */
/** @import { Frame } from "./connection.js" */
/**
* @typedef {{ type: string, content: any }} Block
* @typedef {{ role: string, content: Block[] }} Message
* @typedef {"user" | "assistant" | "thinking" | "notice" | "error"} TextKind
* @typedef {{
* key: string,
* kind: TextKind,
* text: Signal<string>,
* content?: { type: string, content?: string }[],
* provisional?: boolean,
* }} TextItem
* @typedef {{ key: string, kind: "tool", card: Signal<Card> }} ToolItem
* @typedef {TextItem | ToolItem} Item
* @typedef {{
* items: Signal<Item[]>, busy: Signal<boolean>,
* cards: Map<string, ToolItem>, live: Map<string, TextItem>, serial: number,
* compacting?: TextItem | null,
* }} State
* @typedef {{
* call_id: string, name: string, label: string, state: string, revision: number,
* elapsed_ms?: number | null, summary?: string | null, output_preview?: string | null,
* card_body?: { text: string, total_lines: number, collapsed_lines: number } | null,
* }} Card
*/
/** An empty transcript, and the one function that changes it. */
export function createTranscript() {
/** @type {State} */
const state = { items: signal([]), busy: signal(false), cards: new Map(), live: new Map(), serial: 0 };
/** @param {Frame} frame */
const fold = (frame) => batch(() => apply(state, frame));
return { items: state.items, busy: state.busy, apply: fold };
}
// The engine says a turn started with turn_started; the message that opened it, or anything it
// streams, stands in for that from a session whose luxe predates the event
const TURN_SIGNS = new Set(["turn_started", "token_delta", "thinking_delta", "tool_call_composing"]);
/** @param {State} state @param {Frame} frame */
function apply(state, { kind, content }) {
if (TURN_SIGNS.has(kind) || (kind === "message_committed" && content.message.role === "user")) {
state.busy.value = true;
}
switch (kind) {
case "session_loaded": return load(state, content.messages);
case "token_delta": return grow(state, "assistant", content.block, content.delta);
case "thinking_delta": return grow(state, "thinking", content.block, content.delta);
case "message_committed": return commit(state, content.message);
case "tool_activity_updated": return showCard(state, content);
case "state_changed": state.busy.value = content.streaming; return;
case "turn_ended": return endTurn(state);
case "notice": return push(state, textItem(state, "notice", content));
case "error": push(state, textItem(state, "error", content)); return endTurn(state);
case "action_rejected": return push(state, textItem(state, "error", `Refused: ${content.reason}`));
case "compaction_started": return startCompaction(state, content.tokens_before);
case "compaction_done": return settleCompaction(state, compacted(content));
case "compaction_stopped": return settleCompaction(state, "Compaction stopped.");
}
}
// A summary takes a minute and nothing else streams meanwhile, so it's said as it starts, and the
// same line becomes how it ended
/** @param {State} state @param {number} tokens */
function startCompaction(state, tokens) {
state.compacting = textItem(state, "notice", `Compacting the conversation — ${formatTokens(tokens)} of context…`);
push(state, state.compacting);
}
/** @param {State} state @param {string} text */
function settleCompaction(state, text) {
const line = state.compacting;
state.compacting = null;
if (line && state.items.value.includes(line)) line.text.value = text;
else push(state, textItem(state, "notice", text));
}
/** @param {{ tokens_before: number, tokens_after: number }} content */
function compacted({ tokens_before, tokens_after }) {
return `Compacted the conversation — ${formatTokens(tokens_before)} → ${formatTokens(tokens_after)} of context.`;
}
/** A token count as the TUI writes it: `812`, `579.4k`, `1.2M`. @param {number} count */
export function formatTokens(count) {
if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
return String(count);
}
/** @param {State} state @param {{ message: Message }[]} messages */
function load(state, messages) {
state.items.value = [];
state.cards.clear();
state.live.clear();
for (const { message } of messages) replay(state, message);
for (const item of state.cards.values()) settleUnfinished(item, "interrupted");
}
/** @param {State} state @param {Message} message */
function replay(state, message) {
if (message.role === "assistant") {
for (const item of assistantItems(state, message.content)) push(state, item);
for (const block of message.content) if (block.type === "tool_call") cardFromCall(state, block.content);
return;
}
if (message.role === "tool") return settleResults(state, message.content);
commit(state, message);
}
/** @param {State} state @param {TextKind} kind @param {number} block @param {string} delta */
function grow(state, kind, block, delta) {
const slot = `${kind}:${block}`;
let item = state.live.get(slot);
if (!item) {
item = { ...textItem(state, kind, ""), provisional: true };
state.live.set(slot, item);
push(state, item);
}
item.text.value += delta;
}
/** @param {State} state @param {Message} message */
function commit(state, message) {
if (message.role === "user") {
// a photo sent on its own is still a message, shown by its "attached" line
const words = message.content.find((block) => block.type === "text");
const shown = words || message.content.some((block) => block.type === "image");
if (shown) push(state, { ...textItem(state, "user", words?.content ?? ""), content: wordsOnly(message.content) });
return;
}
if (message.role === "assistant") return commitAssistant(state, message.content);
if (message.role === "tool") return settleResults(state, message.content);
if (message.role === "system") for (const block of message.content) {
if (block.type === "text") push(state, textItem(state, "notice", block.content));
}
}
// Line the saved blocks up with the streamed ones in place; if they don't match, swap them out
/** @param {State} state @param {Block[]} content */
function commitAssistant(state, content) {
const saved = assistantItems(state, content);
const streamed = state.items.value.filter(isProvisional);
state.live.clear();
const linesUp = saved.length === streamed.length
&& saved.every((item, index) => item.kind === streamed[index].kind);
if (linesUp) {
streamed.forEach((item, index) => settleText(item, saved[index].text.value));
return;
}
replaceStreamed(state, streamed, saved);
}
/** @param {Item} item @returns {item is TextItem} */
function isProvisional(item) {
return item.kind !== "tool" && item.provisional === true;
}
/** @param {State} state @param {TextItem[]} streamed @param {TextItem[]} saved */
function replaceStreamed(state, streamed, saved) {
const items = state.items.value;
const at = streamed.length ? items.indexOf(streamed[0]) : items.length;
/** @type {Item[]} */
const kept = items.filter((item) => !isProvisional(item));
kept.splice(Math.min(at, kept.length), 0, ...saved);
state.items.value = kept;
}
/** @param {TextItem} item @param {string} text */
function settleText(item, text) {
item.text.value = text;
item.provisional = false;
}
/** @param {State} state @param {Block[]} content */
function assistantItems(state, content) {
/** @type {TextItem[]} */
const items = [];
for (const block of content) {
// Saved reasoning often ends in blank lines, which would draw as a gap
const thinking = block.type === "thinking" ? block.content.text.trimEnd() : "";
const text = block.type === "text" ? block.content.trimEnd() : "";
if (thinking) items.push(textItem(state, "thinking", thinking));
if (text) items.push(textItem(state, "assistant", text));
}
return items;
}
/** @param {State} state @param {Card} activity */
function showCard(state, activity) {
const known = state.cards.get(activity.call_id);
if (!known) {
/** @type {ToolItem} */
const item = { key: `tool:${activity.call_id}`, kind: "tool", card: signal(activity) };
state.cards.set(activity.call_id, item);
return push(state, item);
}
if (activity.revision >= known.card.value.revision) known.card.value = activity;
}
/** @param {State} state @param {{ id: string, name: string, arguments: any }} call */
function cardFromCall(state, { id, name, arguments: args }) {
const label = describeCall(args);
// A described command shows the command under it, as a live card does
const command = typeof args?.command === "string" && args.command !== label ? args.command : "";
const card_body = command ? { text: command, total_lines: 1, collapsed_lines: 3 } : null;
showCard(state, { call_id: id, name, label, card_body, state: "running", revision: 0 });
}
/** @param {State} state @param {Block[]} content */
function settleResults(state, content) {
for (const block of content) {
if (block.type !== "tool_result") continue;
const { call_id, content: output, is_error } = block.content;
const item = state.cards.get(call_id);
if (!item) continue;
/** @type {Block[]} */
const parts = output;
const text = parts.filter((part) => part.type === "text").map((part) => part.content).join("\n");
const card = item.card.value;
item.card.value = {
...card,
state: is_error ? "failed" : "succeeded",
output_preview: card.output_preview ?? text,
revision: card.revision + 1,
};
}
}
/** @param {State} state */
function endTurn(state) {
state.live.clear();
for (const item of state.items.value) if (item.kind !== "tool") item.provisional = false;
state.busy.value = false;
}
/** @param {ToolItem} item @param {string} final */
function settleUnfinished(item, final) {
const card = item.card.value;
if (card.state === "running" || card.state === "queued" || card.state === "composing") {
item.card.value = { ...card, state: final, revision: card.revision + 1 };
}
}
/** What a call from history was about, from its arguments: the label live cards are sent with. */
/** @param {any} args @returns {string} */
export function describeCall(args) {
for (const field of ["description", "command", "path", "pattern", "query", "url"]) {
if (typeof args?.[field] === "string") return args[field];
}
if (Array.isArray(args?.paths)) return args.paths.join(", ");
return "";
}
// The blocks as the host needs them to say what a message shows: text, and the place of the rest,
// so a photo's bytes aren't sent back to be rendered
/** @param {Block[]} content */
function wordsOnly(content) {
return content.map((block) => (block.type === "text" ? block : { type: block.type }));
}
/** @param {State} state @param {TextKind} kind @param {string} text @returns {TextItem} */
function textItem(state, kind, text) {
return { key: `${kind}:${state.serial++}`, kind, text: signal(text) };
}
/** @param {State} state @param {Item} item */
function push(state, item) {
state.items.value = [...state.items.value, item];
}