937 lines
38 KiB
JavaScript
937 lines
38 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 {
|
|
CHAT_FOLLOW_THRESHOLD_PX,
|
|
ChatTurn,
|
|
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,
|
|
chatBottomDistancePx,
|
|
chatFirstScroll,
|
|
chatFollowsAt,
|
|
chatHeaderMeta,
|
|
chatNoMatchMessage,
|
|
chatOpensAtNewest,
|
|
chatShowJumpToLatest,
|
|
chatStreamState,
|
|
closeChatConfirmation,
|
|
deltaPartId,
|
|
directoryLabel,
|
|
filterSessions,
|
|
formatToolDuration,
|
|
groupSessionsByDirectory,
|
|
historyResync,
|
|
lineDiff,
|
|
mergeHistoryPage,
|
|
mergeToolPart,
|
|
newChatThread,
|
|
partRendering,
|
|
prettyToolInput,
|
|
reasoningLabel,
|
|
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",
|
|
});
|
|
});
|
|
|
|
// --- 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), {});
|
|
});
|