// Pure chat logic (C1/C3/C4/C14) and the chat request builders. Every wording // and decision below is the same one the browser view uses, so the view cannot // silently drift from what is asserted here. import { test } from "node:test"; import assert from "node:assert/strict"; import { CHAT_COMMANDS, CHAT_COMMAND_GLYPH, CHAT_FOLLOW_THRESHOLD_PX, CHAT_QUEUED_NOTICE, COMPOSER_SEND, COMPOSER_STOP, ChatTurn, MAX_ATTACHMENT_BYTES, MAX_RENDERED_DIFF_LINES, TOOL_DETAIL_MAX_LENGTH, TOOL_LONG_RUNNING_MILLIS, TURN_PHASE_THINKING, TURN_PHASE_TOOL, TURN_PHASE_WAITING, TURN_THINKING_WINDOW_MILLIS, applyChatEvent, attachmentDisplayName, attachmentError, attachmentFiles, chatBottomDistancePx, chatCommandEffect, chatCommandForEnter, chatCommandHelp, chatCommandSuggestions, chatFirstScroll, chatFollowsAt, chatHeaderMeta, chatNoMatchMessage, chatOpensAtNewest, chatShowJumpToLatest, chatStreamState, closeChatConfirmation, composerAction, composerCanSend, composerSendEnabled, composerSubmit, deltaPartId, directoryLabel, filterSessions, formatToolDuration, groupSessionsByDirectory, historyResync, lineDiff, mergeHistoryPage, mergeToolPart, newChatThread, parseChatInput, partRendering, prettyToolInput, queuedAfterFrame, reasoningLabel, runningAfterFrame, runningToolElapsedMillis, runningToolStamps, sessionActivity, sessionActivityBadge, sessionChipLabel, sessionMatchesQuery, sessionMeta, sessionStatusLabel, sessionTitle, sessionWorkLabel, settledThread, threadElapsedMillis, threadPhase, threadRunningTools, threadToolElapsedMillis, toolCallCount, toolCallRow, toolCallsAnnouncement, toolCallsLabel, toolDetail, toolDurationMillis, toolEditDiff, toolErrorText, toolFailed, toolLongRunning, toolOutputText, toolRunning, toolsRunning, transcriptRows, turnElapsedMillis, turnPhase, turnPhaseLabel, } from "../src/chat.js"; import { ChangeLineKind } from "../src/changes.js"; import { PipelinesClient, ProtocolError } from "../src/client.js"; import { PipelinesRepository } from "../src/repository.js"; import { validateServerUrl } from "../src/serverUrl.js"; const assistant = (id, parts) => ({ id, role: "assistant", parts }); const user = (id, text) => ({ id, role: "user", parts: [{ type: "text", text }] }); // --- Transcript folding ----------------------------------------------------- test("transcriptRows folds consecutive assistant messages into one turn keyed by the first id", () => { const rows = transcriptRows([ user("u1", "hello"), assistant("a1", [{ type: "text", text: "one" }, { type: "tool", id: "t1", name: "read" }]), assistant("a2", [{ type: "reasoning", text: "think" }, { type: "text", text: "two" }]), user("u2", "bye"), ]); assert.deepEqual( rows.map((row) => `${row.kind}:${row.key}`), ["user:u1", "agent:a1", "user:u2"], ); const turn = rows[1].turn; assert.ok(turn instanceof ChatTurn); assert.equal(turn.reasoning, "think"); assert.equal(turn.tools.length, 1); assert.equal(turn.answer, "one\n\ntwo"); }); test("transcriptRows gives each user message its own row and never folds two runs together", () => { const rows = transcriptRows([ user("u1", "a"), assistant("a1", [{ type: "text", text: "x" }]), user("u2", "b"), assistant("a2", [{ type: "text", text: "y" }]), ]); assert.deepEqual( rows.map((row) => row.kind), ["user", "agent", "user", "agent"], ); }); test("transcriptRows drops an assistant run with nothing to draw", () => { const rows = transcriptRows([ user("u1", "hi"), assistant("a1", []), assistant("a2", [{ type: "tool", id: "t1", name: "" }]), ]); assert.deepEqual(rows.map((row) => row.key), ["u1", "a1"]); assert.equal(rows[1].turn.visible, true); assert.equal(new ChatTurn("k", []).visible, false); }); test("partRendering classifies text, reasoning, other text and empty parts", () => { assert.equal(partRendering({ type: "text", text: "hi" }), "markdown"); assert.equal(partRendering({ type: "reasoning", text: "hmm" }), "reasoning"); assert.equal(partRendering({ type: "file", text: "f.txt" }), "plain"); assert.equal(partRendering({ type: "text", text: " " }), "hidden"); assert.equal(partRendering(null), "hidden"); }); test("toolCallsLabel never pluralises a count of one", () => { assert.equal(toolCallsLabel(1), "1 tool called"); assert.equal(toolCallsLabel(4), "4 tools called"); }); test("reasoningLabel is Thinking/Reasoning with the step count and streaming word", () => { assert.equal(reasoningLabel(1, false), "Reasoning"); assert.equal(reasoningLabel(1, true), "Thinking…"); assert.equal(reasoningLabel(3, false), "Reasoning · 3 steps"); assert.equal(reasoningLabel(3, true), "Thinking · 3 steps"); assert.equal(reasoningLabel(1), "Reasoning"); assert.equal(reasoningLabel(3), "Reasoning · 3 steps"); }); // --- Tool-call lifecycle, detail and the edit diff (C6) --------------------- test("toolRunning treats streaming and running as in flight, completed/error as settled", () => { assert.equal(toolRunning({ type: "tool", state: { status: "streaming" } }), true); assert.equal(toolRunning({ type: "tool", state: { status: "running" } }), true); assert.equal(toolRunning({ type: "tool", state: { status: "completed" } }), false); assert.equal(toolRunning({ type: "tool", state: { status: "error" } }), false); assert.equal(toolRunning({ type: "tool" }), false); assert.equal(toolRunning({ type: "text", state: { status: "running" } }), false); }); test("toolsRunning and toolFailed summarise the lifecycle", () => { const call = (status) => ({ type: "tool", state: { status } }); assert.equal(toolsRunning([call("completed"), call("running")]), true); assert.equal(toolsRunning([call("completed"), call("error")]), false); assert.equal(toolsRunning([]), false); assert.equal(toolFailed({ status: "error" }), true); assert.equal(toolFailed({ status: "completed" }), false); assert.equal(toolFailed(undefined), false); }); test("toolCallCount counts only tool parts and toolCallsAnnouncement matches the plural", () => { const parts = [{ type: "tool" }, { type: "text" }, { type: "reasoning" }, { type: "tool" }]; assert.equal(toolCallCount(parts), 2); assert.equal(toolCallCount([]), 0); assert.equal(toolCallsAnnouncement(1), "1 tool call, expand for details"); assert.equal(toolCallsAnnouncement(3), "3 tool calls, expand for details"); }); test("toolDetail takes the first present detail key, collapsed and trimmed to 72", () => { const part = (input) => ({ type: "tool", state: { input } }); assert.equal(toolDetail(part({ command: "ls -la" })), "ls -la"); assert.equal(toolDetail(part({ description: "do a thing", command: "x" })), "do a thing"); assert.equal(toolDetail(part({ filePath: "/a/b.ts" })), "/a/b.ts"); assert.equal(toolDetail(part({ path: "p", command: "c" })), "c"); assert.equal(toolDetail(part({ command: " a b\tc\n d " })), "a b c d"); const detail = toolDetail(part({ command: "x".repeat(100) })); assert.equal(detail.length, TOOL_DETAIL_MAX_LENGTH); assert.ok(detail.endsWith("…")); assert.equal(toolDetail(part({ other: "nope" })), null); assert.equal(toolDetail(part("partial json")), null); assert.equal(toolDetail(part({ command: 42 })), null); assert.equal(toolDetail({ type: "tool" }), null); }); test("formatToolDuration renders ms, one-decimal seconds and minutes", () => { assert.equal(formatToolDuration(340), "340ms"); assert.equal(formatToolDuration(999), "999ms"); assert.equal(formatToolDuration(1000), "1.0s"); assert.equal(formatToolDuration(1200), "1.2s"); assert.equal(formatToolDuration(59600), "59.6s"); assert.equal(formatToolDuration(60000), "1m 0s"); assert.equal(formatToolDuration(123000), "2m 3s"); }); test("toolDurationMillis reads ran-else-created to completed, null when unusable", () => { assert.equal(toolDurationMillis({ time: { created: 10, ran: 20, completed: 120 } }), 100); assert.equal(toolDurationMillis({ time: { created: 10, ran: 0, completed: 110 } }), 100); assert.equal(toolDurationMillis({ time: { created: 10, ran: 20 } }), null); assert.equal(toolDurationMillis({ time: { created: 10, ran: 20, completed: 5 } }), null); assert.equal(toolDurationMillis({}), null); }); test("runningToolElapsedMillis prefers the protocol start and falls back to the local stamp", () => { const part = { type: "tool", time: { created: 100, ran: 500 } }; assert.equal(runningToolElapsedMillis(part, 999, 1500), 1000); assert.equal(runningToolElapsedMillis({ type: "tool" }, 1000, 4000), 3000); assert.equal(runningToolElapsedMillis({ type: "tool" }, 0, 4000), 0); assert.equal(toolLongRunning(TOOL_LONG_RUNNING_MILLIS), true); assert.equal(toolLongRunning(TOOL_LONG_RUNNING_MILLIS - 1), false); }); test("toolOutputText joins text content, (no output) when settled-empty and '' in flight", () => { const state = (status, content) => ({ status, content }); assert.equal( toolOutputText(state("completed", [{ type: "text", text: "a" }, { type: "text", text: "b" }])), "a\nb", ); assert.equal(toolOutputText(state("completed", [{ type: "text", text: " " }])), "(no output)"); assert.equal(toolOutputText(state("running", [])), ""); assert.equal(toolOutputText(state("streaming", [])), ""); assert.equal(toolOutputText(state("error", [])), "(no output)"); assert.equal(toolOutputText(null), ""); }); test("toolErrorText prefers the server's error message over the output", () => { assert.equal( toolErrorText({ status: "error", error: { message: "boom" }, content: [{ type: "text", text: "partial" }] }), "boom", ); assert.equal(toolErrorText({ status: "error", content: [{ type: "text", text: "partial" }] }), "partial"); assert.equal(toolErrorText({ status: "error", error: { message: " " }, content: [] }), "(no output)"); }); test("prettyToolInput pretty-prints objects, keeps a partial string and blanks nothing", () => { assert.equal(prettyToolInput(null), ""); assert.equal(prettyToolInput("{\"a\":"), "{\"a\":"); assert.equal(prettyToolInput({ a: 1 }), '{\n "a": 1\n}'); assert.equal(prettyToolInput([1, 2]), "[\n 1,\n 2\n]"); }); test("lineDiff LCS marks only changed lines and carries ChangeLineKind values", () => { const lines = lineDiff(["one", "two", "three"], ["one", "TWO", "three"]); assert.deepEqual(lines, [ { kind: ChangeLineKind.Context, text: "one" }, { kind: ChangeLineKind.Remove, text: "two" }, { kind: ChangeLineKind.Add, text: "TWO" }, { kind: ChangeLineKind.Context, text: "three" }, ]); }); test("toolEditDiff derives the file, true counts and the LCS line kinds", () => { const diff = toolEditDiff({ filePath: "a.ts", oldString: "one\ntwo\nthree", newString: "one\nTWO\nthree" }); assert.equal(diff.file, "a.ts"); assert.equal(diff.added, 1); assert.equal(diff.removed, 1); assert.equal(diff.omitted, 0); assert.deepEqual(diff.lines, [ { kind: ChangeLineKind.Context, text: "one" }, { kind: ChangeLineKind.Remove, text: "two" }, { kind: ChangeLineKind.Add, text: "TWO" }, { kind: ChangeLineKind.Context, text: "three" }, ]); assert.equal(toolEditDiff({ oldString: "", newString: "" }), null); assert.equal(toolEditDiff({ oldString: "x" }), null); assert.equal(toolEditDiff({ command: "ls" }), null); assert.equal(toolEditDiff("nope"), null); }); test("toolEditDiff caps rendered lines at MAX_RENDERED_DIFF_LINES and counts the rest", () => { const oldLines = Array.from({ length: 300 }, (_, i) => `old-${i}`); const newLines = Array.from({ length: 300 }, (_, i) => `new-${i}`); const diff = toolEditDiff({ oldString: oldLines.join("\n"), newString: newLines.join("\n") }); assert.equal(diff.lines.length, MAX_RENDERED_DIFF_LINES); assert.equal(diff.added, 300); assert.equal(diff.removed, 300); assert.equal(diff.omitted, 600 - MAX_RENDERED_DIFF_LINES); }); test("lineDiff falls back to remove-then-add past the algorithm guard", () => { const lines = lineDiff(Array.from({ length: 401 }, () => "a"), ["b"]); assert.equal(lines.length, 402); assert.equal(lines[0].kind, ChangeLineKind.Remove); assert.equal(lines.at(-1).kind, ChangeLineKind.Add); }); test("toolCallRow composes the name, detail, duration, input, output, error and diff", () => { const part = { type: "tool", id: "t1", name: "edit", state: { status: "completed", input: { filePath: "a.ts", oldString: "one", newString: "two" }, content: [{ type: "text", text: "done" }], }, time: { created: 10, ran: 20, completed: 120 }, }; const row = toolCallRow(part); assert.equal(row.name, "edit"); assert.equal(row.detail, "a.ts"); assert.equal(row.duration, "100ms"); assert.equal(row.input, '{\n "filePath": "a.ts",\n "oldString": "one",\n "newString": "two"\n}'); assert.equal(row.output, "done"); assert.equal(row.error, null); assert.equal(row.diff.file, "a.ts"); assert.equal(row.diff.added, 1); assert.equal(row.diff.removed, 1); }); test("toolCallRow marks a failed call with its error text and no diff", () => { const row = toolCallRow({ type: "tool", id: "t2", name: "shell", state: { status: "error", input: { command: "false" }, error: { message: "exit 1" } }, }); assert.equal(row.name, "shell"); assert.equal(row.detail, "false"); assert.equal(row.duration, null); assert.equal(row.error, "exit 1"); assert.equal(row.diff, null); }); test("turnElapsedMillis spans earliest start to latest completion and is null when unusable", () => { const parts = [ { time: { created: 1000, ran: 1200, completed: 5000 } }, { time: { created: 800, ran: 0, completed: 4000 } }, ]; assert.equal(turnElapsedMillis(parts), 4200); assert.equal(turnElapsedMillis([{ time: { created: 1000, ran: 1200 } }]), null); assert.equal(turnElapsedMillis([{}]), null); assert.equal(turnElapsedMillis([{ time: { created: 1000, ran: 1000, completed: 1000 } }]), null); }); // --- Session identity ------------------------------------------------------- test("sessionTitle falls back from the title to the first 18 characters of the id", () => { assert.equal(sessionTitle({ id: "ses_1", title: "Named chat" }), "Named chat"); assert.equal(sessionTitle({ id: "ses_abcdefghijklmnopqrstuv", title: "" }), "ses_abcdefghijklmn"); assert.equal(sessionTitle({ id: "ses_abcdefghijklmnopqrstuv", title: " " }), "ses_abcdefghijklmn"); assert.equal(sessionTitle({ id: "", title: "" }), "Untitled chat"); assert.equal(sessionTitle(null), "Untitled chat"); }); test("sessionTagLabel maps operator and keeps an unknown tag verbatim", () => { assert.equal(sessionChipLabel({ tag: "operator" }), "Operator"); assert.equal(sessionChipLabel({ tag: "run" }), "run"); assert.equal(sessionChipLabel({ tag: " " }), null); assert.equal(sessionChipLabel({}), null); }); test("sessionWorkLabel names the running tool, the count, busy and idle", () => { assert.equal(sessionWorkLabel(false, null), "Idle"); assert.equal(sessionWorkLabel(true, null), "Busy · read-only"); assert.equal(sessionWorkLabel(true, { running: true, runningTools: [] }), "Running"); assert.equal( sessionWorkLabel(true, { running: true, runningTools: [{ name: "read" }] }), "Running read", ); assert.equal( sessionWorkLabel(true, { running: true, runningTools: [{ name: "" }] }), "Running tool", ); assert.equal( sessionWorkLabel(true, { running: true, runningTools: [{ name: "a" }, { name: "b" }] }), "Running 2 tools", ); }); test("sessionMeta joins only the non-blank work label, directory and model", () => { assert.equal(sessionMeta({ directory: "/repo", model: "m1" }, "Idle"), "Idle · /repo · m1"); assert.equal(sessionMeta({ directory: "", model: "m1" }, "Idle"), "Idle · m1"); assert.equal(sessionMeta({}, ""), ""); }); test("chatHeaderMeta joins model, kind tag and directory, omitting blanks", () => { assert.equal( chatHeaderMeta({ model: "m1", tag: "operator", directory: "/repo" }), "m1 · Operator · /repo", ); assert.equal(chatHeaderMeta({ model: "", tag: "", directory: "/repo" }), "/repo"); assert.equal(chatHeaderMeta({}), ""); }); test("sessionActivity and its badge word follow streaming, unseen then open", () => { assert.equal(sessionActivity(true, true), "streaming"); assert.equal(sessionActivity(false, true), "new"); assert.equal(sessionActivity(false, false), "idle"); assert.equal(sessionActivityBadge("streaming", false), "Streaming"); assert.equal(sessionActivityBadge("new", false), "New"); assert.equal(sessionActivityBadge("idle", true), "Open"); assert.equal(sessionActivityBadge("idle", false), null); }); test("sessionStatusLabel reads Closed first, then Running or Idle", () => { assert.equal(sessionStatusLabel(true, true), "Closed"); assert.equal(sessionStatusLabel(true, false), "Running"); assert.equal(sessionStatusLabel(false, false), "Idle"); }); // --- Narrowing and grouping ------------------------------------------------- test("filterSessions is a case-insensitive substring over title or directory", () => { const sessions = [ { id: "a", title: "Fix the parser", directory: "/repo/one" }, { id: "b", title: "Docs", directory: "/repo/two" }, ]; assert.deepEqual(filterSessions(sessions, "PARSER").map((s) => s.id), ["a"]); assert.deepEqual(filterSessions(sessions, "REPO/TWO").map((s) => s.id), ["b"]); assert.deepEqual(filterSessions(sessions, "zzz"), []); }); test("filterSessions is a no-op for a blank query and never reorders", () => { const sessions = [{ id: "b", title: "b" }, { id: "a", title: "a" }]; assert.equal(filterSessions(sessions, " "), sessions); assert.deepEqual(filterSessions(sessions, ""), sessions); assert.deepEqual(filterSessions(sessions, "b").map((s) => s.id), ["b"]); }); test("sessionMatchesQuery tests the truncated title too", () => { const session = { id: "ses_abcdefghijklmnopqrstuv", title: "" }; assert.equal(sessionMatchesQuery(session, "abcdefghij"), true); assert.equal(sessionMatchesQuery(session, "nope"), false); }); test("groupSessionsByDirectory groups in first-occurrence order and labels a blank directory", () => { const sessions = [ { id: "1", directory: "/a" }, { id: "2", directory: "/b" }, { id: "3", directory: "/a" }, { id: "4", directory: "" }, ]; const groups = groupSessionsByDirectory(sessions); assert.deepEqual(groups.map((g) => g.directory), ["/a", "/b", ""]); assert.deepEqual(groups[0].sessions.map((s) => s.id), ["1", "3"]); assert.deepEqual(groupSessionsByDirectory([]), []); assert.equal(directoryLabel(""), "No directory"); assert.equal(directoryLabel("/a"), "/a"); }); // --- History paging --------------------------------------------------------- test("mergeHistoryPage prepends an older page and dedupes by id", () => { const previous = { messages: [{ id: "m3" }, { id: "m4" }], nextCursor: "c1", hasMore: true }; const page = { messages: [{ id: "m1" }, { id: "m2" }, { id: "m3" }], nextCursor: "c0", hasMore: false }; const merged = mergeHistoryPage(previous, page, { older: true }); assert.deepEqual(merged.messages.map((m) => m.id), ["m1", "m2", "m3", "m4"]); assert.equal(merged.nextCursor, "c0"); assert.equal(merged.hasMore, false); assert.equal(merged.loaded, true); assert.equal(merged.loading, false); }); test("mergeHistoryPage keeps turns already held in front of a newest page", () => { const previous = { messages: [{ id: "m1" }, { id: "m2" }], nextCursor: "c1", hasMore: true }; const page = { messages: [{ id: "m2" }, { id: "m3" }], nextCursor: "", hasMore: false }; const merged = mergeHistoryPage(previous, page, { older: false }); assert.deepEqual(merged.messages.map((m) => m.id), ["m1", "m2", "m3"]); assert.equal(merged.nextCursor, ""); assert.equal(merged.hasMore, false); }); test("mergeHistoryPage replaces the cursor and hasMore even when the page omits them", () => { const merged = mergeHistoryPage({ messages: [] }, { messages: [{ id: "m1" }] }); assert.equal(merged.nextCursor, ""); assert.equal(merged.hasMore, false); assert.deepEqual(merged.messages.map((m) => m.id), ["m1"]); }); // --- Scroll behaviour ------------------------------------------------------- test("chatBottomDistancePx is null until the last item is in view", () => { assert.equal( chatBottomDistancePx({ lastVisibleIndex: 2, lastVisibleEndPx: 900, itemCount: 3, viewportEndPx: 800 }), 100, ); assert.equal( chatBottomDistancePx({ lastVisibleIndex: 1, lastVisibleEndPx: 900, itemCount: 3, viewportEndPx: 800 }), null, ); assert.equal( chatBottomDistancePx({ lastVisibleIndex: 0, lastVisibleEndPx: 0, itemCount: 0, viewportEndPx: 0 }), null, ); assert.equal( chatBottomDistancePx({ lastVisibleIndex: 2, lastVisibleEndPx: 700, itemCount: 3, viewportEndPx: 800 }), 0, ); }); test("chatFollowsAt is at-the-bottom only for a measured distance within the threshold", () => { assert.equal(chatFollowsAt(0, CHAT_FOLLOW_THRESHOLD_PX, 3), true); assert.equal(chatFollowsAt(32, CHAT_FOLLOW_THRESHOLD_PX, 3), true); assert.equal(chatFollowsAt(33, CHAT_FOLLOW_THRESHOLD_PX, 3), false); assert.equal(chatFollowsAt(null, CHAT_FOLLOW_THRESHOLD_PX, 3), false); assert.equal(chatFollowsAt(0, CHAT_FOLLOW_THRESHOLD_PX, 0), false); }); test("chatShowJumpToLatest needs not-following, content and something below the fold", () => { assert.equal(chatShowJumpToLatest(false, 400, CHAT_FOLLOW_THRESHOLD_PX, 5), true); assert.equal(chatShowJumpToLatest(false, null, CHAT_FOLLOW_THRESHOLD_PX, 5), true); assert.equal(chatShowJumpToLatest(true, 400, CHAT_FOLLOW_THRESHOLD_PX, 5), false); assert.equal(chatShowJumpToLatest(false, 0, CHAT_FOLLOW_THRESHOLD_PX, 5), false); assert.equal(chatShowJumpToLatest(false, 400, CHAT_FOLLOW_THRESHOLD_PX, 0), false); }); test("chatOpensAtNewest is true only for an absent saved position", () => { assert.equal(chatOpensAtNewest(null), true); assert.equal(chatOpensAtNewest(undefined), true); assert.equal(chatOpensAtNewest({ index: 0, offset: 0 }), false); assert.equal(chatOpensAtNewest({ index: 4, offset: 80 }), false); }); test("chatFirstScroll opens newest when unsaved and restores a saved top exactly", () => { assert.deepEqual(chatFirstScroll(null, 5), { index: 4, offset: 0 }); assert.deepEqual(chatFirstScroll({ index: 0, offset: 0 }, 5), { index: 0, offset: 0 }); assert.deepEqual(chatFirstScroll({ index: 1, offset: 40 }, 3), { index: 1, offset: 40 }); assert.deepEqual(chatFirstScroll({ index: 9, offset: 40 }, 3), { index: 2, offset: 0 }); assert.deepEqual(chatFirstScroll(null, 0), { index: 0, offset: 0 }); }); // --- Wording ---------------------------------------------------------------- test("closeChatConfirmation is the app's exact sentence", () => { assert.equal( closeChatConfirmation("New chat"), 'Closes "New chat" and marks it closed on every device. A turn that is running is stopped first. ' + "Nothing is deleted — the chat and its history are kept, and you can reopen it from the list.", ); }); test("chatNoMatchMessage names the trimmed query", () => { assert.equal(chatNoMatchMessage(" fix parser "), 'No chats match "fix parser".'); }); // --- Request builders ------------------------------------------------------- /** The same minimal fake the repository tests use (test files are not importable). */ class FakeWebSocket { static instances = []; constructor(url) { this.url = url; this.sent = []; this.onopen = null; this.onmessage = null; this.onclose = null; this.onerror = null; this.reply = null; FakeWebSocket.instances.push(this); } send(data) { const frame = JSON.parse(data); this.sent.push(frame); const response = this.reply?.(frame); if (response !== undefined) this.onmessage?.({ data: JSON.stringify(response) }); } close(code, reason) { this.onclose?.({ code, reason }); } open() { this.onopen?.({}); } } const VALID = validateServerUrl("ws://host:8080/connect"); function connected() { FakeWebSocket.instances = []; const client = new PipelinesClient({ WebSocketImpl: FakeWebSocket }); const repo = new PipelinesRepository(client); client.connect(VALID); const ws = FakeWebSocket.instances.at(-1); ws.open(); return { repo, ws, client }; } function lastFrame(ws) { const { id, ...frame } = ws.sent.at(-1); assert.match(id, /^web-\d+$/); return frame; } test("chatSessions sends exactly {type:'chat_sessions'} and returns the list", async () => { const { repo, ws } = connected(); ws.reply = (frame) => ({ id: frame.id, type: "chat_sessions", chat_sessions: [{ id: "s1" }] }); const sessions = await repo.chatSessions(); assert.deepEqual(lastFrame(ws), { type: "chat_sessions" }); assert.deepEqual(sessions, [{ id: "s1" }]); }); test("chatSessions returns [] when the reply carries none", async () => { const { repo, ws } = connected(); ws.reply = (frame) => ({ id: frame.id, type: "chat_sessions" }); assert.deepEqual(await repo.chatSessions(), []); }); test("chatHistory sends {session_id,limit,cursor} and reads chat_history", async () => { const { repo, ws } = connected(); ws.reply = (frame) => ({ id: frame.id, type: "chat_messages", chat_history: { messages: [{ id: "m1" }], next_cursor: "c1", has_more: true }, }); const page = await repo.chatHistory("s1"); assert.deepEqual(lastFrame(ws), { type: "chat_messages", chat_query: { session_id: "s1", limit: 200, cursor: "" }, }); assert.deepEqual(page, { messages: [{ id: "m1" }], nextCursor: "c1", hasMore: true }); }); test("chatHistory passes the cursor back verbatim", async () => { const { repo, ws } = connected(); ws.reply = (frame) => ({ id: frame.id, type: "chat_messages", chat_history: { messages: [] } }); await repo.chatHistory("s1", { cursor: "opaque/+/=", limit: 200 }); const { chat_query: query } = lastFrame(ws); assert.equal(query.cursor, "opaque/+/="); }); test("chatHistory falls back to chat_messages with no continuation on an older server", async () => { const { repo, ws } = connected(); ws.reply = (frame) => ({ id: frame.id, type: "chat_messages", chat_messages: [{ id: "m1" }] }); const page = await repo.chatHistory("s1"); assert.deepEqual(page, { messages: [{ id: "m1" }], nextCursor: "", hasMore: false }); }); test("closeChat and reopenChat send the session id and read the echoed session and close", async () => { for (const [method, type] of [["closeChat", "chat_close"], ["reopenChat", "chat_reopen"]]) { const { repo, ws } = connected(); ws.reply = (frame) => ({ id: frame.id, type, chat_session: { id: "s1", closed: type === "chat_close" }, chat_close: { session_id: "s1", closed_at: 1, interrupted: false }, }); const result = await repo[method]("s1"); assert.deepEqual(lastFrame(ws), { type, chat_query: { session_id: "s1" } }); assert.deepEqual(result.session, { id: "s1", closed: type === "chat_close" }); assert.equal(result.close.session_id, "s1"); } }); test("chatHistory rejects a blank session id without sending", async () => { const { repo, ws } = connected(); await assert.rejects(() => repo.chatHistory(" "), ProtocolError); assert.equal(ws.sent.length, 0); }); test("a chat command rejects a server error envelope with the server's own text", async () => { const { repo, ws } = connected(); ws.reply = (frame) => ({ id: frame.id, type: "error", error: "unknown command: chat_messages" }); await assert.rejects(() => repo.chatHistory("s1"), { name: "ProtocolError", message: "unknown command: chat_messages", }); }); // --------------------------------------------------------------------------- // The composer and its attachments (C8) // --------------------------------------------------------------------------- const thread = (overrides = {}) => ({ draft: "", attachments: [], running: false, queued: false, directory: "/tmp/work", ...overrides, }); const attachment = (overrides = {}) => ({ id: "a1", uri: "a.txt", name: "a.txt", size: 3, error: null, ...overrides }); test("composerAction is Stop while a turn runs and Send otherwise", () => { assert.equal(composerAction(thread({ running: true })), COMPOSER_STOP); assert.equal(composerAction(thread()), COMPOSER_SEND); assert.equal(composerAction(null), COMPOSER_SEND); }); test("composerCanSend requires a non-blank draft and no flagged attachment", () => { assert.equal(composerCanSend(thread({ draft: "hi" })), true); assert.equal(composerCanSend(thread({ draft: " " })), false); assert.equal(composerCanSend(thread({ draft: "hi", attachments: [attachment({ error: "nope" })] })), false); }); test("composerSendEnabled also allows a slash draft with a failed attachment", () => { assert.equal(composerSendEnabled(thread({ draft: "/help" })), true); assert.equal(composerSendEnabled(thread({ draft: "/help", attachments: [attachment({ error: "nope" })] })), true); assert.equal(composerSendEnabled(thread({ draft: "hi", attachments: [attachment({ error: "nope" })] })), false); assert.equal(composerSendEnabled(thread({ draft: "" })), false); }); test("composerSubmit runs an offer row, a slash draft, a send, and nothing while running", () => { assert.deepEqual(composerSubmit(thread({ draft: "hello" }), 0), { kind: "send" }); assert.deepEqual(composerSubmit(thread({ draft: "/" }), 1), { kind: "command", text: "/close" }); assert.deepEqual(composerSubmit(thread({ draft: "/ren" }), 0), { kind: "command", text: "/rename" }); assert.deepEqual(composerSubmit(thread({ draft: "/stop" }), 0), { kind: "command", text: "/stop" }); // While a turn runs, Enter is inert unless the palette or a slash draft is present. assert.deepEqual(composerSubmit(thread({ draft: "hello", running: true }), 0), { kind: "none" }); assert.deepEqual(composerSubmit(thread({ draft: "/stop extra", running: true }), 0), { kind: "command", text: "/stop extra", }); }); test("queuedAfterFrame clears the queued flag on any incoming frame", () => { // The flag itself is set from the prompt reply's `chat_queued` (see the // repository test); any frame for the session then clears it, and a null frame // (no push) leaves it as it was. assert.equal(queuedAfterFrame(true, { kind: "text", session_id: "s1" }), false); assert.equal(queuedAfterFrame(true, { kind: "step", step: { status: "ended" } }), false); assert.equal(queuedAfterFrame(true, null), true); assert.equal(queuedAfterFrame(false, { kind: "text" }), false); }); test("runningAfterFrame settles the running bit on a step that ended", () => { assert.equal(runningAfterFrame(true, { kind: "step", step: { status: "ended" } }), false); assert.equal(runningAfterFrame(true, { kind: "step", step: { status: "started" } }), true); assert.equal(runningAfterFrame(true, { kind: "text" }), true); assert.equal(runningAfterFrame(false, { kind: "step", step: { status: "ended" } }), false); }); test("attachmentDisplayName prefers the name, then the uri's basename, then file", () => { assert.equal(attachmentDisplayName("Report.pdf", "content://x/y"), "Report.pdf"); assert.equal(attachmentDisplayName("", "content:///tmp/notes.txt"), "notes.txt"); assert.equal(attachmentDisplayName(" ", "notes.txt"), "notes.txt"); assert.equal(attachmentDisplayName("", ""), "file"); }); test("attachmentError reports an unreadable file and the 25 MiB limit by name", () => { assert.equal(attachmentError("a.txt", 3, true), null); assert.equal(attachmentError("a.txt", 3, false), '"a.txt" could not be read.'); assert.equal(attachmentError("", 3, false), '"file" could not be read.'); assert.equal(MAX_ATTACHMENT_BYTES, 25 * 1024 * 1024); assert.equal( attachmentError("big.bin", MAX_ATTACHMENT_BYTES + 1, true), '"big.bin" is too large (25.0 MiB limit).', ); // Exactly at the limit is allowed; the limit reads through the shared humanBytes. assert.equal(attachmentError("big.bin", MAX_ATTACHMENT_BYTES, true), null); }); test("attachmentFiles keeps only the error-free attachments, in order", () => { assert.deepEqual( attachmentFiles([ attachment({ uri: "one.txt" }), attachment({ uri: "bad.txt", error: "nope" }), attachment({ uri: "two.txt" }), ]), ["one.txt", "two.txt"], ); assert.deepEqual(attachmentFiles([]), []); }); test("CHAT_QUEUED_NOTICE is the app's own queued sentence", () => { assert.equal(CHAT_QUEUED_NOTICE, "Queued — it will send when the current turn finishes."); }); test("a command notice carries one terminal glyph for both states", () => { // Android draws Icons.Default.Terminal for a Command and a Command failed // notice and only changes the tint, so the two share this glyph. assert.equal(CHAT_COMMAND_GLYPH, ">_"); }); // --------------------------------------------------------------------------- // Slash commands (C9) // --------------------------------------------------------------------------- test("CHAT_COMMANDS is exactly the five commands with their usage and summary", () => { assert.deepEqual( CHAT_COMMANDS.map((command) => [command.name, command.usage, command.summary]), [ ["new", "/new", "Start a fresh session in this directory"], ["close", "/close", "Finish this session for every client, keeping its history"], ["rename", "/rename ", "Rename this session on this device"], ["stop", "/stop", "Stop the turn that is running"], ["help", "/help", "List every command"], ], ); }); test("chatCommandHelp is one `usage — summary` line per command", () => { assert.equal( chatCommandHelp(), "/new — Start a fresh session in this directory\n" + "/close — Finish this session for every client, keeping its history\n" + "/rename <title> — Rename this session on this device\n" + "/stop — Stop the turn that is running\n" + "/help — List every command", ); }); test("parseChatInput recognises the five commands case-insensitively", () => { for (const name of ["new", "close", "rename", "stop", "help"]) { const parsed = parseChatInput(`/${name.toUpperCase()}`); assert.equal(parsed.kind, "invocation"); assert.equal(parsed.command.name, name); } const withArg = parseChatInput("/rename My title"); assert.equal(withArg.argument, "My title"); assert.equal(parseChatInput("hello").kind, "plain"); }); test("parseChatInput returns Unknown with the token for a slash word that is not a command", () => { const parsed = parseChatInput(" /nope "); assert.equal(parsed.kind, "unknown"); assert.equal(parsed.token, "/nope"); assert.equal(parsed.text, "/nope"); }); test("chatCommandSuggestions offers only a bare slash word, case-insensitively by prefix", () => { assert.deepEqual(chatCommandSuggestions("hello"), []); assert.deepEqual(chatCommandSuggestions(" /rename x"), []); assert.deepEqual( chatCommandSuggestions("/").map((command) => command.name), ["new", "close", "rename", "stop", "help"], ); assert.deepEqual( chatCommandSuggestions("/ST").map((command) => command.name), ["stop"], ); assert.deepEqual(chatCommandSuggestions("/c").map((command) => command.name), ["close"]); }); test("chatCommandForEnter clamps the highlighted row and is null without a list", () => { assert.equal(chatCommandForEnter("/", 0), "/new"); assert.equal(chatCommandForEnter("/", 4), "/help"); assert.equal(chatCommandForEnter("/", 99), "/new"); assert.equal(chatCommandForEnter("/rename x", 0), null); assert.equal(chatCommandForEnter("hello", 0), null); }); test("chatCommandEffect routes each command to its effect", () => { const view = thread({ draft: "/x", directory: "/repo" }); assert.deepEqual(chatCommandEffect(parseChatInput("/new"), view), { kind: "start-session", directory: "/repo", }); assert.deepEqual(chatCommandEffect(parseChatInput("/close"), view), { kind: "finish-session" }); assert.deepEqual(chatCommandEffect(parseChatInput("/rename My chat"), view), { kind: "rename-session", title: "My chat", }); assert.deepEqual(chatCommandEffect(parseChatInput("/stop"), thread({ running: true })), { kind: "stop-turn" }); assert.deepEqual(chatCommandEffect(parseChatInput("/help"), view), { kind: "show-help" }); assert.equal(chatCommandEffect(parseChatInput("hello"), view), null); }); test("chatCommandEffect reports the exact Android error strings", () => { const view = thread({ directory: "/repo" }); assert.deepEqual(chatCommandEffect(parseChatInput("/nope"), view), { kind: "report", text: "“/nope” is not a command, so nothing was sent to the agent. Send it as a message, or cancel.", offer: "/nope", }); assert.deepEqual(chatCommandEffect(parseChatInput("/new extra"), view), { kind: "report", text: "/new does not take an argument.", }); assert.deepEqual(chatCommandEffect(parseChatInput("/rename"), view), { kind: "report", text: "Usage: /rename <title> — renames this session on this device.", }); assert.deepEqual(chatCommandEffect(parseChatInput("/stop"), thread({ running: false })), { kind: "report", text: "No turn is running in this chat.", }); assert.deepEqual(chatCommandEffect(parseChatInput("/new"), thread({ directory: " " })), { kind: "report", text: "Can't start a new session here: the server reported no directory for this chat.", }); }); // --- C5: live stream folding ------------------------------------------------ // Every frame below is the server's `chat_event` shape (internal/protocol/chat.go // ChatEventFrame). The synthetic frames prove the pure fold; the ui-smoke replays // the same shapes against the real page. const evt = (kind, extra = {}) => ({ session_id: "s1", kind, ...extra }); test("a text delta appends to the part the first frame started", () => { let thread = newChatThread("s1"); thread = applyChatEvent(thread, evt("text", { message_id: "a1", part: { id: "a1#text#0" }, delta: "Hel" }), 1000); thread = applyChatEvent(thread, evt("text", { message_id: "a1", part: { id: "a1#text#0" }, delta: "lo" }), 1001); assert.equal(thread.messages.length, 1); assert.equal(thread.messages[0].role, "assistant"); assert.equal(thread.messages[0].parts.length, 1); assert.equal(thread.messages[0].parts[0].text, "Hello"); assert.equal(thread.running, true); assert.equal(thread.runningSince, 1000); assert.equal(thread.lastDeltaAt, 1001); }); test("a text delta and a reasoning delta sharing a bare id land in separate parts", () => { let thread = newChatThread("s1"); thread = applyChatEvent(thread, evt("text", { message_id: "a1", part: { id: "x" }, delta: "answer" }), 1000); thread = applyChatEvent(thread, evt("reasoning", { message_id: "a1", part: { id: "x" }, delta: "think" }), 1001); const parts = thread.messages[0].parts; assert.equal(parts.length, 2); const text = parts.find((part) => part.type === "text"); const reasoning = parts.find((part) => part.type === "reasoning"); assert.equal(text.id, "x"); assert.equal(text.text, "answer"); assert.equal(reasoning.id, "x#reasoning"); assert.equal(reasoning.text, "think"); // The id derivation is the one the broker uses once the kinds are distinct. assert.equal(deltaPartId(parts, "text", "x"), "x"); assert.equal(deltaPartId(parts, "reasoning", "x"), "x#reasoning"); }); test("tool frames merge field by field without blanking what an earlier frame taught", () => { let thread = newChatThread("s1"); thread = applyChatEvent( thread, evt("tool", { message_id: "a1", part: { type: "tool", id: "t1", name: "read", state: { status: "running", input: { filePath: "a.js" } } }, }), 1000, ); // A later frame carries the result but no name and no input: both are retained. thread = applyChatEvent( thread, evt("tool", { message_id: "a1", part: { type: "tool", id: "t1", state: { status: "completed", content: [{ type: "text", text: "done" }] } }, }), 1001, ); // A final frame carries the error but no content: the content is retained too. thread = applyChatEvent( thread, evt("tool", { message_id: "a1", part: { type: "tool", id: "t1", state: { status: "error", error: { message: "boom" } } }, }), 1002, ); const tool = thread.messages[0].parts.find((part) => part.type === "tool"); assert.equal(tool.name, "read"); assert.deepEqual(tool.state.input, { filePath: "a.js" }); assert.equal(tool.state.content[0].text, "done"); assert.equal(tool.state.error.message, "boom"); assert.equal(tool.state.status, "error"); // And the pure merge keeps a non-empty incoming field while retaining the prior. const merged = mergeToolPart( { type: "tool", id: "t1", name: "read", executed: true, state: { status: "running", input: { a: 1 } } }, { type: "tool", id: "t1", name: "", state: { status: "", input: { b: 2 } } }, ); assert.equal(merged.name, "read"); assert.equal(merged.executed, true); assert.equal(merged.state.status, "running"); assert.deepEqual(merged.state.input, { b: 2 }); }); test("a repeated user message id adds no second turn and keeps a non-blank client", () => { let thread = newChatThread("s1"); const frame = evt("user", { message_id: "u9", part: { text: "hi there" }, client: "Pixel" }); thread = applyChatEvent(thread, frame, 1000); thread = applyChatEvent(thread, frame, 1001); assert.equal(thread.messages.filter((message) => message.role === "user").length, 1); assert.equal(thread.messages[0].client, "Pixel"); assert.equal(thread.messages[0].parts[0].text, "hi there"); // Another id with no text or no id at all is ignored. thread = applyChatEvent(thread, evt("user", { message_id: "u10", part: { text: "" } }), 1002); thread = applyChatEvent(thread, evt("user", { part: { text: "no id" } }), 1003); assert.equal(thread.messages.length, 1); }); test("step started runs the turn and step ended settles it", () => { let thread = newChatThread("s1"); thread = applyChatEvent(thread, evt("step", { step: { status: "started", index: 1 } }), 1000); assert.equal(thread.running, true); assert.equal(thread.runningSince, 1000); // A tool call in flight leaves a stamp; ending the step clears running and the stamp. thread = applyChatEvent( thread, evt("tool", { message_id: "a1", part: { type: "tool", id: "t1", state: { status: "running" } } }), 1001, ); assert.equal(thread.toolStartedAt.t1, 1001); thread = applyChatEvent(thread, evt("step", { step: { status: "ended" } }), 2000); assert.equal(thread.running, false); assert.equal(thread.runningSince, 0); assert.deepEqual(thread.toolStartedAt, {}); assert.equal(thread.lastDeltaAt, 0); }); test("any frame clears the queued flag", () => { for (const frame of [ evt("text", { message_id: "a1", part: { id: "p" }, delta: "x" }), evt("step", { step: { status: "started" } }), evt("usage", { usage: { input_tokens: 1 } }), evt("shell", { shell: { id: "sh1", status: "running" } }), ]) { const queued = { ...newChatThread("s1"), queued: true }; assert.equal(applyChatEvent(queued, frame, 1000).queued, false); } }); test("a shell frame never marks the thread running", () => { const thread = applyChatEvent( newChatThread("s1"), evt("shell", { shell: { id: "sh1", status: "running", command: "go test ./..." } }), 1000, ); assert.equal(thread.running, false); assert.equal(thread.runningSince, 0); }); test("a usage frame changes nothing", () => { const before = newChatThread("s1"); const after = applyChatEvent(before, evt("usage", { usage: { input_tokens: 5, cost: 0.01 } }), 1000); assert.deepEqual(after, before); }); test("settling a thread (a socket drop) clears running, its stamps and queued", () => { let thread = newChatThread("s1"); thread = applyChatEvent(thread, evt("text", { message_id: "a1", part: { id: "p" }, delta: "x" }), 1000); thread = applyChatEvent( thread, evt("tool", { message_id: "a1", part: { type: "tool", id: "t1", state: { status: "running" } } }), 1001, ); assert.equal(thread.running, true); assert.equal(thread.toolStartedAt.t1, 1001); const settled = settledThread(thread); assert.equal(settled.running, false); assert.equal(settled.runningSince, 0); assert.deepEqual(settled.toolStartedAt, {}); assert.equal(settled.lastDeltaAt, 0); assert.equal(settled.queued, false); // The conversation itself is untouched by settling. assert.equal(settled.messages.length, 1); }); test("historyResync replaces the turn wholesale and settles it", () => { const held = { ...newChatThread("s1"), messages: [assistant("a1", [{ type: "text", text: "stale" }])], nextCursor: "old", hasMore: true, loaded: true, running: true, runningSince: 555, toolStartedAt: { t1: 555 }, lastDeltaAt: 600, }; const page = { messages: [user("u1", "hi"), assistant("a2", [{ type: "text", text: "fresh" }])], nextCursor: "", hasMore: false, }; const resynced = historyResync(held, page); assert.deepEqual(resynced.messages, page.messages); assert.ok(!resynced.messages.some((message) => message.id === "a1")); assert.equal(resynced.nextCursor, ""); assert.equal(resynced.hasMore, false); assert.equal(resynced.loaded, true); assert.equal(resynced.running, false); assert.equal(resynced.runningSince, 0); assert.deepEqual(resynced.toolStartedAt, {}); assert.equal(resynced.lastDeltaAt, 0); }); test("the chat stream badge uses the live / reconnecting / not live words", () => { assert.deepEqual(chatStreamState("connected", true), { tone: "live", label: "live" }); assert.equal(chatStreamState("connected", false).label, "not live"); assert.equal(chatStreamState("connecting", true).label, "reconnecting"); assert.equal(chatStreamState("disconnected", true).label, "reconnecting"); assert.equal(chatStreamState("idle", false).label, "not live"); }); test("the turn phase names what is happening", () => { assert.equal(turnPhase([], 1000), TURN_PHASE_THINKING); assert.equal(turnPhaseLabel(TURN_PHASE_THINKING), "Thinking…"); assert.equal(turnPhase([{ type: "tool", id: "t", state: { status: "running" } }], 100000), TURN_PHASE_TOOL); assert.equal(turnPhaseLabel(TURN_PHASE_TOOL), "Running a tool…"); assert.equal(turnPhase([], null), TURN_PHASE_WAITING); assert.equal(turnPhase([], TURN_THINKING_WINDOW_MILLIS), TURN_PHASE_WAITING); assert.equal(turnPhaseLabel(TURN_PHASE_WAITING), "Waiting…"); }); test("only a call at or past 60s reads as long", () => { assert.equal(toolLongRunning(TOOL_LONG_RUNNING_MILLIS - 1), false); assert.equal(toolLongRunning(TOOL_LONG_RUNNING_MILLIS), true); assert.equal(TOOL_LONG_RUNNING_MILLIS, 60000); }); test("a live turn interleaving reasoning, text and tool frames folds to one agent row", () => { let thread = newChatThread("live"); const frames = [ evt("reasoning", { message_id: "a1", part: { id: "r0" }, delta: "think" }), evt("text", { message_id: "a1", part: { id: "t0" }, delta: "Hel" }), evt("tool", { message_id: "a1", part: { type: "tool", id: "tool1", name: "read", state: { status: "running" } } }), evt("tool", { message_id: "a1", part: { type: "tool", id: "tool1", state: { status: "completed", content: [{ type: "text", text: "ok" }] } }, }), evt("reasoning", { message_id: "a2", part: { id: "r0" }, delta: "more" }), evt("text", { message_id: "a2", part: { id: "t0" }, delta: "lo" }), ]; for (const frame of frames) thread = applyChatEvent(thread, frame, 1000); const rows = transcriptRows(thread.messages); const agentRows = rows.filter((row) => row.kind === "agent"); assert.equal(agentRows.length, 1); assert.equal(agentRows[0].key, "a1"); assert.deepEqual(agentRows[0].turn.reasoningSteps, ["think", "more"]); assert.equal(agentRows[0].turn.tools.length, 1); assert.equal(agentRows[0].turn.answer, "Hel\n\nlo"); assert.equal(threadRunningTools(thread.messages).length, 0); }); test("the running indicator's elapsed and per-tool timing use the thread's own stamps", () => { let thread = newChatThread("s1"); thread = applyChatEvent(thread, evt("step", { step: { status: "started" } }), 1000); thread = applyChatEvent( thread, evt("tool", { message_id: "a1", part: { type: "tool", id: "t1", name: "shell", state: { status: "running", input: { command: "go build" } } }, }), 1500, ); assert.equal(threadElapsedMillis(thread, 3000), 2000); assert.equal(formatToolDuration(threadToolElapsedMillis(thread, thread.messages[0].parts[0], 3000)), "1.5s"); assert.equal(threadPhase(thread, 3000), TURN_PHASE_TOOL); // runningToolStamps keeps a stamp it already had and drops one that settled. assert.deepEqual(runningToolStamps({ t1: 42 }, thread.messages, 9999), { t1: 42 }); assert.deepEqual(runningToolStamps({ t1: 42 }, [], 9999), {}); });