Files
pipelines/web/test/chat.test.mjs
T
alan 8e5ce8494b web: background-tasks bar — running shells, capped list, bounded output (C11)
Add the background-tasks bar to an open conversation: heading
"Background tasks" plus "{n} running", shown only while at least one
shell is running. Rows are capped at 3 (BACKGROUND_TASK_VISIBLE_ROWS)
and the list scrolls beyond; each row is a play glyph, "Running", a
one-line shellCommandSummary and "Details" while selected. Tapping a
row toggles its detail pane ("Command"/"Task identity"/"Status:
running" plus the bounded output: spinner, error + "Retry",
"Output unavailable for this task.", "No output yet.", or the
monospace output and "Output is bounded to 64 KiB." with "Refresh").

Fold shell frames without ever marking the turn running, merge a blank
command from the previous frame, list only running shells (an exited
shell is never a task) and drop/relearn shells on reconnect via
chat_shells. Refresh always rereads the bounded 64 KiB page from cursor
0. Update PARITY.md C11 with its captures and the replayed-vs-real note.

Checks: node --check on every touched file; cd web && node --test test/
(456 pass).
2026-10-19 08:22:16 +01:00

1354 lines
56 KiB
JavaScript

// 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 {
BACKGROUND_TASKS_TITLE,
BACKGROUND_TASK_VISIBLE_ROWS,
CHAT_COMMANDS,
CHAT_COMMAND_GLYPH,
CHAT_FOLLOW_THRESHOLD_PX,
CHAT_QUEUED_NOTICE,
COMPOSER_SEND,
COMPOSER_STOP,
ChatTurn,
MAX_ATTACHMENT_BYTES,
MAX_RENDERED_DIFF_LINES,
OBSERVED_SHELL_LIMIT,
SHELL_DETAILS_LABEL,
SHELL_EXITED,
SHELL_OUTPUT_EMPTY,
SHELL_OUTPUT_ERROR,
SHELL_OUTPUT_LABELS,
SHELL_OUTPUT_LOADING,
SHELL_OUTPUT_READY,
SHELL_OUTPUT_UNAVAILABLE,
SHELL_ROW_LABEL,
SHELL_RUNNING,
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,
backgroundTasksRunningLabel,
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,
mergeShellFrame,
mergeToolPart,
newChatThread,
parseChatInput,
partRendering,
prettyToolInput,
queuedAfterFrame,
reasoningLabel,
resumedThread,
runningAfterFrame,
runningBackgroundShells,
runningToolElapsedMillis,
runningToolStamps,
sessionActivity,
sessionActivityBadge,
sessionChipLabel,
sessionMatchesQuery,
sessionMeta,
sessionStatusLabel,
sessionTitle,
sessionWorkLabel,
settledThread,
shellCommandSummary,
shellOutputState,
shellsLoaded,
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 <title>", "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), {});
});
// --- C11: background tasks (shells) -----------------------------------------
// The pure model the background-tasks bar is built on: running-only filtering,
// the visible-row cap, the one-line command summary, shell-frame folding and the
// detail pane's state selection and wording. Mirror of
// ChatFormat.runningBackgroundShells/shellCommandSummary, ChatStore.applyShell/
// shellsLoaded and ChatTranscript.BackgroundProcessBar/-Detail.
const shell = (overrides = {}) => ({ id: "sh1", status: "running", command: "go test ./...", ...overrides });
test("runningBackgroundShells lists only non-blank running shells, in order", () => {
const shells = [
shell({ id: "a", command: "one" }),
shell({ id: "b", status: SHELL_EXITED, command: "two" }),
shell({ id: "", command: "three" }),
shell({ id: "d", status: "running", command: "four" }),
shell({ id: "e", status: undefined }),
];
assert.deepEqual(
runningBackgroundShells(shells).map((s) => s.id),
["a", "d"],
);
assert.deepEqual(runningBackgroundShells([]), []);
assert.deepEqual(runningBackgroundShells(undefined), []);
});
test("the visible-row cap is three and never truncates the model", () => {
assert.equal(BACKGROUND_TASK_VISIBLE_ROWS, 3);
const running = Array.from({ length: 5 }, (_, i) => shell({ id: `s${i}` }));
// The cap is a view/CSS concern; every running shell stays in the model.
assert.equal(runningBackgroundShells(running).length, 5);
});
test("shellCommandSummary collapses whitespace, names a blank command and elides past 72", () => {
assert.equal(SHELL_ROW_LABEL, "Running");
assert.equal(shellCommandSummary(""), "background process");
assert.equal(shellCommandSummary(" "), "background process");
assert.equal(shellCommandSummary(null), "background process");
assert.equal(shellCommandSummary(" go test\n./...\t-x "), "go test ./... -x");
// Exactly 72 characters is not elided.
const seventyTwo = "a".repeat(TOOL_DETAIL_MAX_LENGTH);
assert.equal(shellCommandSummary(seventyTwo), seventyTwo);
// Longer: 71 kept characters, trailing whitespace trimmed, then one ellipsis.
const long = `${"b".repeat(TOOL_DETAIL_MAX_LENGTH)} tail`;
const elided = shellCommandSummary(long);
assert.equal(elided, `${"b".repeat(TOOL_DETAIL_MAX_LENGTH - 1)}…`);
assert.equal(elided.length, TOOL_DETAIL_MAX_LENGTH);
assert.ok(elided.endsWith("…"));
// A 71-char word followed by a space then more trims the trailing space first.
const word = `${"c".repeat(TOOL_DETAIL_MAX_LENGTH - 1)} rest`;
assert.equal(shellCommandSummary(word), `${"c".repeat(TOOL_DETAIL_MAX_LENGTH - 1)}…`);
});
test("mergeShellFrame keeps a blank command from the previous frame and caps the list", () => {
const first = mergeShellFrame([], shell({ id: "a", command: "go build" }));
assert.deepEqual(first, [shell({ id: "a", command: "go build" })]);
// A later frame that omits the command never blanks the retained one.
const merged = mergeShellFrame(first, shell({ id: "a", command: "" }));
assert.equal(merged.length, 1);
assert.equal(merged[0].command, "go build");
// A frame that carries a command replaces it; the position is preserved.
const renamed = mergeShellFrame(merged, shell({ id: "a", command: "go vet" }));
assert.equal(renamed[0].command, "go vet");
// A blank id (or null shell) is ignored outright.
assert.equal(mergeShellFrame(renamed, shell({ id: "" })).length, 1);
assert.deepEqual(mergeShellFrame(renamed, null), renamed);
// The retained list is capped at OBSERVED_SHELL_LIMIT, keeping the newest.
let many = [];
for (let i = 0; i < OBSERVED_SHELL_LIMIT + 4; i += 1) {
many = mergeShellFrame(many, shell({ id: `s${i}`, command: `c${i}` }));
}
assert.equal(many.length, OBSERVED_SHELL_LIMIT);
assert.equal(many.at(-1).id, `s${OBSERVED_SHELL_LIMIT + 3}`);
assert.equal(many[0].id, "s4");
});
test("shellsLoaded replaces the live set but retains exits this client observed", () => {
const existing = [
shell({ id: "r1", status: SHELL_RUNNING, command: "old run" }),
shell({ id: "e1", status: SHELL_EXITED, command: "finished" }),
];
const loaded = shellsLoaded(existing, [shell({ id: "r2", status: SHELL_RUNNING, command: "new run" })]);
assert.deepEqual(loaded.map((s) => s.id), ["e1", "r2"]);
// r1 is neither in the snapshot nor a locally observed exit, so it drops out.
assert.ok(!loaded.some((s) => s.id === "r1"));
// An exit the client never saw exit is not invented.
assert.ok(!loaded.some((s) => s.id === "r1"));
});
test("shellOutputState picks the detail pane's branch in the app's order", () => {
assert.equal(shellOutputState(null), null);
assert.equal(shellOutputState(undefined), null);
assert.equal(shellOutputState({}), null);
assert.equal(shellOutputState({ loading: true }), SHELL_OUTPUT_LOADING);
assert.equal(shellOutputState({ error: "boom" }), SHELL_OUTPUT_ERROR);
// Error outranks a page if both were set.
assert.equal(shellOutputState({ error: "boom", page: { output: "x" } }), SHELL_OUTPUT_ERROR);
assert.equal(shellOutputState({ page: { unavailable: true } }), SHELL_OUTPUT_UNAVAILABLE);
assert.equal(shellOutputState({ page: { output: "" } }), SHELL_OUTPUT_EMPTY);
assert.equal(shellOutputState({ page: { output: "line\n" } }), SHELL_OUTPUT_READY);
assert.equal(shellOutputState({ page: { output: "x", truncated: true } }), SHELL_OUTPUT_READY);
});
test("the detail pane's wording is the app's verbatim copy", () => {
assert.equal(BACKGROUND_TASKS_TITLE, "Background tasks");
assert.equal(backgroundTasksRunningLabel(3), "3 running");
assert.equal(SHELL_DETAILS_LABEL, "Details");
assert.deepEqual(SHELL_OUTPUT_LABELS, {
COMMAND: "Command",
UNAVAILABLE: "Unavailable",
TASK_IDENTITY: "Task identity",
STATUS_RUNNING: "Status: running",
OUTPUT_UNAVAILABLE: "Output unavailable for this task.",
NO_OUTPUT: "No output yet.",
OUTPUT: "Output",
OUTPUT_BOUNDED: "Output is bounded to 64 KiB.",
RETRY: "Retry",
REFRESH: "Refresh",
});
});
test("a shell frame folds into the thread and never marks the turn running", () => {
const folded = applyChatEvent(
newChatThread("s1"),
evt("shell", { shell: { id: "sh1", status: "running", command: "sleep 5" } }),
1000,
);
assert.equal(folded.running, false);
assert.equal(folded.runningSince, 0);
assert.deepEqual(folded.shells, [{ id: "sh1", status: "running", command: "sleep 5" }]);
// A shell frame that ends the shell removes it from the running set at once.
const exited = applyChatEvent(
folded,
evt("shell", { shell: { id: "sh1", status: "exited", command: "" } }),
1001,
);
assert.equal(exited.shells[0].status, "exited");
assert.equal(exited.shells[0].command, "sleep 5");
assert.equal(runningBackgroundShells(exited.shells).length, 0);
});
test("a step that ends does not clear a background shell that outlives the turn", () => {
let thread = applyChatEvent(
newChatThread("s1"),
evt("shell", { shell: { id: "sh1", status: "running", command: "sleep 5" } }),
1000,
);
thread = applyChatEvent(thread, evt("step", { step: { status: "started" } }), 1000);
thread = applyChatEvent(thread, evt("step", { step: { status: "ended" } }), 2000);
assert.equal(thread.running, false);
assert.equal(runningBackgroundShells(thread.shells).length, 1);
// settledThread alone keeps the shell; only the reconnect repair drops it.
assert.equal(settledThread(thread).shells.length, 1);
const resumed = resumedThread(thread);
assert.deepEqual(resumed.shells, []);
assert.equal(resumed.selectedShellId, null);
assert.equal(resumed.shellOutput, null);
});