Inital commit

tools/ui/tests/unit/abort.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+import { isAbortError } from '$lib/utils/abort';
+
+describe('isAbortError', () => {
+	it('returns false for null, undefined and non-error values', () => {
+		expect(isAbortError(null)).toBe(false);
+		expect(isAbortError(undefined)).toBe(false);
+		expect(isAbortError('string error')).toBe(false);
+		expect(isAbortError({ name: 'AbortError' })).toBe(false);
+		expect(isAbortError(42)).toBe(false);
+	});
+
+	it('returns true for DOMException with AbortError name', () => {
+		const err = new DOMException('Operation was aborted', 'AbortError');
+		expect(isAbortError(err)).toBe(true);
+	});
+
+	it('returns true for plain Error with AbortError name', () => {
+		const err = new Error('aborted');
+		err.name = 'AbortError';
+		expect(isAbortError(err)).toBe(true);
+	});
+
+	it('returns false for unrelated Error instances', () => {
+		expect(isAbortError(new Error('something failed'))).toBe(false);
+		expect(isAbortError(new TypeError('not related'))).toBe(false);
+		expect(isAbortError(new RangeError('out of range'))).toBe(false);
+	});
+
+	it('recognizes Firefox TypeError "Error in input stream" emitted at page unload', () => {
+		expect(isAbortError(new TypeError('Error in input stream'))).toBe(true);
+		expect(isAbortError(new TypeError('TypeError: Error in input stream'))).toBe(true);
+	});
+
+	it('recognizes Safari "The network connection was lost" during transient drop', () => {
+		expect(isAbortError(new TypeError('The network connection was lost.'))).toBe(true);
+	});
+
+	it('recognizes Safari "Load failed" during page navigation', () => {
+		expect(isAbortError(new TypeError('Load failed'))).toBe(true);
+	});
+
+	it('does NOT recognize generic TypeError messages as aborts', () => {
+		// matching too broadly would hide real bugs, the predicate must stay conservative
+		expect(isAbortError(new TypeError('Failed to fetch'))).toBe(false);
+		expect(isAbortError(new TypeError('Cannot read property of undefined'))).toBe(false);
+		expect(isAbortError(new TypeError('NetworkError when attempting to fetch resource'))).toBe(
+			false
+		);
+	});
+
+	it('is case insensitive on the matched substrings', () => {
+		expect(isAbortError(new TypeError('error in INPUT STREAM'))).toBe(true);
+		expect(isAbortError(new TypeError('the network connection WAS LOST'))).toBe(true);
+	});
+});

tools/ui/tests/unit/agentic-hotpath.bench.ts

@@ -0,0 +1,248 @@
+// Microbenchmarks for the functions on the agentic-thread streaming hot path.
+//
+// Every function here is invoked from a `$derived` that is invalidated on each
+// streamed token, for every tool-call section in the message. These numbers give
+// the per-call cost; multiply by (tokens x sections) for the real damage.
+//
+// Run: npx vitest bench --project=unit tests/unit/agentic-hotpath.bench.ts
+
+import { bench, describe } from 'vitest';
+
+import { remark } from 'remark';
+import remarkBreaks from 'remark-breaks';
+import remarkGfm from 'remark-gfm';
+import remarkMath from 'remark-math';
+import remarkRehype from 'remark-rehype';
+import rehypeKatex from 'rehype-katex';
+import rehypeHighlight from 'rehype-highlight';
+import rehypeStringify from 'rehype-stringify';
+import { all as lowlightAll } from 'lowlight';
+
+import { computeLineDiff } from '$lib/utils/compute-line-diff';
+import { extractSearchResults, extractSearchQuery } from '$lib/utils/search-results';
+import { parsePartialJsonArgs } from '$lib/utils/parse-partial-json-args';
+import { highlightCode, detectIncompleteCodeBlock } from '$lib/utils/code';
+import { classifyToolResult, parseToolResultWithImages } from '$lib/utils/agentic';
+import { preprocessLaTeX } from '$lib/utils/latex-protection';
+
+// --- fixtures -------------------------------------------------------------
+
+function lines(n: number, seed: string): string {
+	const out: string[] = [];
+	for (let i = 0; i < n; i++) out.push(`${seed} line ${i} const value_${i} = compute(${i});`);
+	return out.join('\n');
+}
+
+const SHELL_OUTPUT_1KB = lines(12, 'out');
+const SHELL_OUTPUT_200KB = lines(2600, 'out');
+const SHELL_OUTPUT_2MB = lines(26000, 'out');
+
+// Realistic exec_shell_command result: the exit-code marker is the final line,
+// which is what the un-anchored EXIT_CODE regex has to scan the whole blob for.
+const SHELL_2MB_WITH_EXIT = `${SHELL_OUTPUT_2MB}\n[exit code: 0]`;
+
+const EDIT_OLD_400 = lines(400, 'old');
+const EDIT_NEW_400 = lines(400, 'new');
+const EDIT_OLD_50 = lines(50, 'old');
+const EDIT_NEW_50 = lines(50, 'new');
+
+const WRITE_FILE_ARGS = JSON.stringify({
+	path: '/src/lib/thing.ts',
+	content: lines(1500, 'src')
+});
+
+const MARKDOWN_50KB = Array.from(
+	{ length: 400 },
+	(_, i) =>
+		`## Section ${i}\n\nSome **bold** prose with a [link](https://example.com) and \`inline\` code.\n\n- bullet one\n- bullet two\n\n\`\`\`ts\nconst x${i} = ${i};\n\`\`\`\n`
+).join('\n');
+
+const CODE_BLOCK_5KB = lines(60, 'code');
+
+// --- A: computeLineDiff (O(m*n) LCS, allocates a full matrix) --------------
+
+describe('computeLineDiff', () => {
+	bench('50 x 50 lines', () => {
+		computeLineDiff(EDIT_OLD_50, EDIT_NEW_50);
+	});
+
+	bench('400 x 400 lines', () => {
+		computeLineDiff(EDIT_OLD_400, EDIT_NEW_400);
+	});
+});
+
+// --- B: the unified processor, rebuilt per call ---------------------------
+// Mirrors MarkdownContent.svelte:144-176. The local rehype/remark plugins are
+// omitted (they pull in browser-only modules); rehypeHighlight + lowlightAll is
+// the dominant term, so this is a lower bound on the real cost.
+
+function buildProcessor() {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	let proc: any = remark().use(remarkGfm);
+	proc = proc.use(remarkMath).use(remarkBreaks).use(remarkRehype).use(rehypeKatex);
+	return proc.use(rehypeHighlight, { languages: lowlightAll }).use(rehypeStringify, {
+		allowDangerousHtml: true
+	});
+}
+
+describe('markdown processor', () => {
+	bench('build processor (per processMarkdown call, x2)', () => {
+		buildProcessor();
+	});
+
+	const prebuilt = buildProcessor();
+
+	bench('parse 50KB markdown with a prebuilt processor', () => {
+		prebuilt.parse(MARKDOWN_50KB);
+	});
+});
+
+// Isolates the O(n^2) term measured in Tier 1: processMarkdown re-parses the
+// WHOLE accumulated string every frame, while only the last block can have
+// changed. If parse() dominates at these sizes, incremental parsing (re-parsing
+// only the tail after the last stable block) is the fix; if not, the cost is
+// downstream in transform/stringify/DOM.
+describe('markdown parse scaling (whole-string reparse per frame)', () => {
+	const proc = buildProcessor();
+	const prose = (kb: number) =>
+		Array.from(
+			{ length: Math.ceil((kb * 1024) / 64) },
+			(_, i) => `The quick brown fox jumps over the lazy dog. Sentence ${i}.`
+		).join(' ');
+
+	const MD_3KB = prose(3);
+	const MD_11KB = prose(11);
+	const MD_26KB = prose(26);
+
+	bench('parse 3KB', () => {
+		proc.parse(MD_3KB);
+	});
+
+	bench('parse 11KB', () => {
+		proc.parse(MD_11KB);
+	});
+
+	bench('parse 26KB', () => {
+		proc.parse(MD_26KB);
+	});
+
+	bench('parse only a 200-char tail (proposed incremental)', () => {
+		proc.parse(MD_26KB.slice(-200));
+	});
+});
+
+// processMarkdown runs these over the WHOLE accumulated string every frame too,
+// before parse() even starts. Measure them before assuming parse is the target.
+describe('other whole-string passes per frame', () => {
+	const prose = (kb: number) =>
+		Array.from(
+			{ length: Math.ceil((kb * 1024) / 64) },
+			(_, i) => `The quick brown fox jumps over the lazy dog. Sentence ${i}.`
+		).join(' ');
+
+	const MD_3KB = prose(3);
+	const MD_11KB = prose(11);
+	const MD_26KB = prose(26);
+	const MD_26KB_LATEX = `${MD_26KB} and some math $x^2 + y^2 = z^2$ inline.`;
+
+	bench('preprocessLaTeX 3KB (no latex present)', () => {
+		preprocessLaTeX(MD_3KB);
+	});
+
+	bench('preprocessLaTeX 11KB (no latex present)', () => {
+		preprocessLaTeX(MD_11KB);
+	});
+
+	bench('preprocessLaTeX 26KB (no latex present)', () => {
+		preprocessLaTeX(MD_26KB);
+	});
+
+	bench('preprocessLaTeX 26KB (latex present)', () => {
+		preprocessLaTeX(MD_26KB_LATEX);
+	});
+
+	bench('detectIncompleteCodeBlock 26KB', () => {
+		detectIncompleteCodeBlock(MD_26KB);
+	});
+});
+
+// --- C: extractSearchResults, run for EVERY tool of every type ------------
+
+describe('extractSearchResults (only .length > 0 is consumed)', () => {
+	bench('1KB non-search tool result', () => {
+		extractSearchResults(SHELL_OUTPUT_1KB);
+	});
+
+	bench('200KB non-search tool result', () => {
+		extractSearchResults(SHELL_OUTPUT_200KB);
+	});
+
+	bench('2MB non-search tool result', () => {
+		extractSearchResults(SHELL_OUTPUT_2MB);
+	});
+});
+
+describe('extractSearchQuery', () => {
+	bench('write_file args (throws on the JSON.parse path)', () => {
+		extractSearchQuery(WRITE_FILE_ARGS);
+	});
+});
+
+// --- E: the un-anchored exit-code regex -----------------------------------
+// Reproduced inline so the bench is independent of the current call site.
+
+const EXIT_CODE_TAIL = /\[exit code: (-?\d+)\]\s*$/;
+
+describe('exit-code regex', () => {
+	bench('whole 2MB blob (current behaviour)', () => {
+		SHELL_2MB_WITH_EXIT.match(EXIT_CODE_TAIL);
+	});
+
+	bench('last 64 chars only (proposed)', () => {
+		SHELL_2MB_WITH_EXIT.slice(-64).match(EXIT_CODE_TAIL);
+	});
+});
+
+// --- per-line result parsers ----------------------------------------------
+
+describe('parseToolResultWithImages', () => {
+	bench('1KB', () => {
+		parseToolResultWithImages(SHELL_OUTPUT_1KB, []);
+	});
+
+	bench('200KB', () => {
+		parseToolResultWithImages(SHELL_OUTPUT_200KB, []);
+	});
+
+	bench('2MB', () => {
+		parseToolResultWithImages(SHELL_OUTPUT_2MB, []);
+	});
+});
+
+describe('classifyToolResult', () => {
+	bench('200KB plain text (falls through to looksLikeMarkdown)', () => {
+		classifyToolResult(SHELL_OUTPUT_200KB);
+	});
+});
+
+describe('parsePartialJsonArgs', () => {
+	bench('write_file args, ~60KB (char-by-char scan)', () => {
+		parsePartialJsonArgs(WRITE_FILE_ARGS);
+	});
+});
+
+// --- F / I: highlight.js ---------------------------------------------------
+
+describe('highlightCode', () => {
+	bench('short bash command (title row, per token)', () => {
+		highlightCode('grep -rn "foo" src/ | head -50', 'bash');
+	});
+
+	bench('5KB known language', () => {
+		highlightCode(CODE_BLOCK_5KB, 'typescript');
+	});
+
+	bench('5KB unknown language -> highlightAuto', () => {
+		highlightCode(CODE_BLOCK_5KB, 'not-a-language');
+	});
+});

tools/ui/tests/unit/agentic-sections.test.ts

@@ -0,0 +1,280 @@
+import { describe, it, expect } from 'vitest';
+import { deriveAgenticSections, hasAgenticContent } from '$lib/utils/agentic';
+import { AgenticSectionType, MessageRole } from '$lib/enums';
+import type { DatabaseMessage } from '$lib/types/database';
+import type { ApiChatCompletionToolCall } from '$lib/types/api';
+
+function makeAssistant(overrides: Partial<DatabaseMessage> = {}): DatabaseMessage {
+	return {
+		id: overrides.id ?? 'ast-1',
+		convId: 'conv-1',
+		type: 'text',
+		timestamp: Date.now(),
+		role: MessageRole.ASSISTANT,
+		content: overrides.content ?? '',
+		parent: null,
+		children: [],
+		...overrides
+	} as DatabaseMessage;
+}
+
+function makeToolMsg(overrides: Partial<DatabaseMessage> = {}): DatabaseMessage {
+	return {
+		id: overrides.id ?? 'tool-1',
+		convId: 'conv-1',
+		type: 'text',
+		timestamp: Date.now(),
+		role: MessageRole.TOOL,
+		content: overrides.content ?? 'tool result',
+		parent: null,
+		children: [],
+		toolCallId: overrides.toolCallId ?? 'call_1',
+		...overrides
+	} as DatabaseMessage;
+}
+
+describe('deriveAgenticSections', () => {
+	it('returns empty array for assistant with no content', () => {
+		const msg = makeAssistant({ content: '' });
+		const sections = deriveAgenticSections(msg);
+		expect(sections).toEqual([]);
+	});
+
+	it('returns text section for simple assistant message', () => {
+		const msg = makeAssistant({ content: 'Hello world' });
+		const sections = deriveAgenticSections(msg);
+		expect(sections).toHaveLength(1);
+		expect(sections[0].type).toBe(AgenticSectionType.TEXT);
+		expect(sections[0].content).toBe('Hello world');
+	});
+
+	it('returns reasoning + text for message with reasoning', () => {
+		const msg = makeAssistant({
+			content: 'Answer is 4.',
+			reasoningContent: 'Let me think...'
+		});
+		const sections = deriveAgenticSections(msg);
+		expect(sections).toHaveLength(2);
+		expect(sections[0].type).toBe(AgenticSectionType.REASONING);
+		expect(sections[0].content).toBe('Let me think...');
+		expect(sections[1].type).toBe(AgenticSectionType.TEXT);
+	});
+
+	it('single turn: assistant with tool calls and results', () => {
+		const msg = makeAssistant({
+			content: 'Let me check.',
+			toolCalls: JSON.stringify([
+				{
+					id: 'call_1',
+					type: 'function',
+					function: { name: 'search', arguments: '{"q":"test"}' }
+				}
+			])
+		});
+		const toolResult = makeToolMsg({
+			toolCallId: 'call_1',
+			content: 'Found 3 results'
+		});
+		const sections = deriveAgenticSections(msg, [toolResult]);
+		expect(sections).toHaveLength(2);
+		expect(sections[0].type).toBe(AgenticSectionType.TEXT);
+		expect(sections[1].type).toBe(AgenticSectionType.TOOL_CALL);
+		expect(sections[1].toolName).toBe('search');
+		expect(sections[1].toolResult).toBe('Found 3 results');
+	});
+
+	it('single turn: pending tool call without result', () => {
+		const msg = makeAssistant({
+			toolCalls: JSON.stringify([
+				{ id: 'call_1', type: 'function', function: { name: 'bash', arguments: '{}' } }
+			])
+		});
+		const sections = deriveAgenticSections(msg, [], [], true);
+		expect(sections).toHaveLength(1);
+		expect(sections[0].type).toBe(AgenticSectionType.TOOL_CALL_PENDING);
+		expect(sections[0].toolName).toBe('bash');
+	});
+
+	it('chat-streaming write_file surfaces as TOOL_CALL_PENDING with partial toolArgs (not TOOL_CALL_STREAMING)', () => {
+		// Regression: while the LLM is emitting a write_file tool call's
+		// args, `chat.svelte.ts` JSON-encodes the partial tool-call array on
+		// every chunk, so `parseToolCalls` succeeds and the section is
+		// classified TOOL_CALL_PENDING - not TOOL_CALL_STREAMING (which is
+		// only produced from the `streamingToolCalls` parameter, never set
+		// by current UI callers). Streaming-only UI like auto-scroll in the
+		// code block must still trigger, driven by `isStreaming && (isPending
+		// || isStreamingCall)`, not `isStreamingCall` alone.
+		const partialArgs = '{"path":"/Users/fifa2026.html","content":"<!DOCTYPE h';
+		const msg = makeAssistant({
+			toolCalls: JSON.stringify([
+				{ id: 'call_1', type: 'function', function: { name: 'write_file', arguments: partialArgs } }
+			])
+		});
+		const sections = deriveAgenticSections(msg, [], [], true);
+		expect(sections).toHaveLength(1);
+		expect(sections[0].type).toBe(AgenticSectionType.TOOL_CALL_PENDING);
+		expect(sections[0].type).not.toBe(AgenticSectionType.TOOL_CALL_STREAMING);
+		expect(sections[0].toolName).toBe('write_file');
+		expect(sections[0].toolArgs).toBe(partialArgs);
+	});
+
+	it('multi-turn: two assistant turns grouped as one session', () => {
+		const assistant1 = makeAssistant({
+			id: 'ast-1',
+			content: 'Turn 1 text',
+			toolCalls: JSON.stringify([
+				{
+					id: 'call_1',
+					type: 'function',
+					function: { name: 'search', arguments: '{"q":"foo"}' }
+				}
+			])
+		});
+		const tool1 = makeToolMsg({ id: 'tool-1', toolCallId: 'call_1', content: 'result 1' });
+		const assistant2 = makeAssistant({
+			id: 'ast-2',
+			content: 'Final answer based on results.'
+		});
+
+		// toolMessages contains both tool result and continuation assistant
+		const sections = deriveAgenticSections(assistant1, [tool1, assistant2]);
+		expect(sections).toHaveLength(3);
+		// Turn 1
+		expect(sections[0].type).toBe(AgenticSectionType.TEXT);
+		expect(sections[0].content).toBe('Turn 1 text');
+		expect(sections[1].type).toBe(AgenticSectionType.TOOL_CALL);
+		expect(sections[1].toolName).toBe('search');
+		expect(sections[1].toolResult).toBe('result 1');
+		// Turn 2 (final)
+		expect(sections[2].type).toBe(AgenticSectionType.TEXT);
+		expect(sections[2].content).toBe('Final answer based on results.');
+	});
+
+	it('multi-turn: three turns with tool calls', () => {
+		const assistant1 = makeAssistant({
+			id: 'ast-1',
+			content: '',
+			toolCalls: JSON.stringify([
+				{
+					id: 'call_1',
+					type: 'function',
+					function: { name: 'list_files', arguments: '{}' }
+				}
+			])
+		});
+		const tool1 = makeToolMsg({ id: 'tool-1', toolCallId: 'call_1', content: 'file1 file2' });
+		const assistant2 = makeAssistant({
+			id: 'ast-2',
+			content: 'Reading file1...',
+			toolCalls: JSON.stringify([
+				{
+					id: 'call_2',
+					type: 'function',
+					function: { name: 'read_file', arguments: '{"path":"file1"}' }
+				}
+			])
+		});
+		const tool2 = makeToolMsg({
+			id: 'tool-2',
+			toolCallId: 'call_2',
+			content: 'contents of file1'
+		});
+		const assistant3 = makeAssistant({
+			id: 'ast-3',
+			content: 'Here is the analysis.',
+			reasoningContent: 'The file contains...'
+		});
+
+		const sections = deriveAgenticSections(assistant1, [tool1, assistant2, tool2, assistant3]);
+		// Turn 1: tool_call (no text since content is empty)
+		// Turn 2: text + tool_call
+		// Turn 3: reasoning + text
+		expect(sections).toHaveLength(5);
+		expect(sections[0].type).toBe(AgenticSectionType.TOOL_CALL);
+		expect(sections[0].toolName).toBe('list_files');
+		expect(sections[1].type).toBe(AgenticSectionType.TEXT);
+		expect(sections[1].content).toBe('Reading file1...');
+		expect(sections[2].type).toBe(AgenticSectionType.TOOL_CALL);
+		expect(sections[2].toolName).toBe('read_file');
+		expect(sections[3].type).toBe(AgenticSectionType.REASONING);
+		expect(sections[4].type).toBe(AgenticSectionType.TEXT);
+		expect(sections[4].content).toBe('Here is the analysis.');
+	});
+
+	it('returns REASONING_PENDING when streaming with only reasoning content', () => {
+		const msg = makeAssistant({
+			reasoningContent: 'Let me think about this...'
+		});
+		const sections = deriveAgenticSections(msg, [], [], true);
+		expect(sections).toHaveLength(1);
+		expect(sections[0].type).toBe(AgenticSectionType.REASONING_PENDING);
+		expect(sections[0].content).toBe('Let me think about this...');
+	});
+
+	it('returns REASONING (not pending) when streaming but text content has appeared', () => {
+		const msg = makeAssistant({
+			content: 'The answer is',
+			reasoningContent: 'Let me think...'
+		});
+		const sections = deriveAgenticSections(msg, [], [], true);
+		expect(sections).toHaveLength(2);
+		expect(sections[0].type).toBe(AgenticSectionType.REASONING);
+		expect(sections[1].type).toBe(AgenticSectionType.TEXT);
+	});
+
+	it('returns REASONING (not pending) when not streaming', () => {
+		const msg = makeAssistant({
+			reasoningContent: 'Let me think...'
+		});
+		const sections = deriveAgenticSections(msg, [], [], false);
+		expect(sections).toHaveLength(1);
+		expect(sections[0].type).toBe(AgenticSectionType.REASONING);
+	});
+
+	it('multi-turn: streaming tool calls on last turn', () => {
+		const assistant1 = makeAssistant({
+			toolCalls: JSON.stringify([
+				{ id: 'call_1', type: 'function', function: { name: 'search', arguments: '{}' } }
+			])
+		});
+		const tool1 = makeToolMsg({ toolCallId: 'call_1', content: 'result' });
+		const assistant2 = makeAssistant({ id: 'ast-2', content: '' });
+
+		const streamingToolCalls: ApiChatCompletionToolCall[] = [
+			{ id: 'call_2', type: 'function', function: { name: 'write_file', arguments: '{"pa' } }
+		];
+
+		const sections = deriveAgenticSections(assistant1, [tool1, assistant2], streamingToolCalls);
+		// Turn 1: tool_call
+		// Turn 2 (streaming): streaming tool call
+		expect(sections.some((s) => s.type === AgenticSectionType.TOOL_CALL)).toBe(true);
+		expect(sections.some((s) => s.type === AgenticSectionType.TOOL_CALL_STREAMING)).toBe(true);
+	});
+});
+
+describe('hasAgenticContent', () => {
+	it('returns false for plain assistant', () => {
+		const msg = makeAssistant({ content: 'Just text' });
+		expect(hasAgenticContent(msg)).toBe(false);
+	});
+
+	it('returns true when message has toolCalls', () => {
+		const msg = makeAssistant({
+			toolCalls: JSON.stringify([
+				{ id: 'call_1', type: 'function', function: { name: 'test', arguments: '{}' } }
+			])
+		});
+		expect(hasAgenticContent(msg)).toBe(true);
+	});
+
+	it('returns true when toolMessages are provided', () => {
+		const msg = makeAssistant();
+		const tool = makeToolMsg();
+		expect(hasAgenticContent(msg, [tool])).toBe(true);
+	});
+
+	it('returns false for empty toolCalls JSON', () => {
+		const msg = makeAssistant({ toolCalls: '[]' });
+		expect(hasAgenticContent(msg)).toBe(false);
+	});
+});

tools/ui/tests/unit/agentic-strip.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from 'vitest';
+import { LEGACY_AGENTIC_REGEX } from '$lib/constants/agentic';
+
+/**
+ * Tests for legacy marker stripping (used in migration).
+ * The new system does not embed markers in content - these tests verify
+ * the legacy regex patterns still work for the migration code.
+ */
+
+// Mirror the legacy stripping logic used during migration
+function stripLegacyContextMarkers(content: string): string {
+	return content
+		.replace(new RegExp(LEGACY_AGENTIC_REGEX.REASONING_BLOCK.source, 'g'), '')
+		.replace(LEGACY_AGENTIC_REGEX.REASONING_OPEN, '')
+		.replace(new RegExp(LEGACY_AGENTIC_REGEX.AGENTIC_TOOL_CALL_BLOCK.source, 'g'), '')
+		.replace(LEGACY_AGENTIC_REGEX.AGENTIC_TOOL_CALL_OPEN, '');
+}
+
+// A realistic complete tool call block as stored in old message.content
+const COMPLETE_BLOCK =
+	'\n\n<<<AGENTIC_TOOL_CALL_START>>>\n' +
+	'<<<TOOL_NAME:bash_tool>>>\n' +
+	'<<<TOOL_ARGS_START>>>\n' +
+	'{"command":"ls /tmp","description":"list tmp"}\n' +
+	'<<<TOOL_ARGS_END>>>\n' +
+	'file1.txt\nfile2.txt\n' +
+	'<<<AGENTIC_TOOL_CALL_END>>>\n';
+
+// Partial block: streaming was cut before END arrived.
+const OPEN_BLOCK =
+	'\n\n<<<AGENTIC_TOOL_CALL_START>>>\n' +
+	'<<<TOOL_NAME:bash_tool>>>\n' +
+	'<<<TOOL_ARGS_START>>>\n' +
+	'{"command":"ls /tmp","description":"list tmp"}\n' +
+	'<<<TOOL_ARGS_END>>>\n' +
+	'partial output...';
+
+describe('legacy agentic marker stripping (for migration)', () => {
+	it('strips a complete tool call block, leaving surrounding text', () => {
+		const input = 'Before.' + COMPLETE_BLOCK + 'After.';
+		const result = stripLegacyContextMarkers(input);
+		expect(result).not.toContain('<<<');
+		expect(result).toContain('Before.');
+		expect(result).toContain('After.');
+	});
+
+	it('strips multiple complete tool call blocks', () => {
+		const input = 'A' + COMPLETE_BLOCK + 'B' + COMPLETE_BLOCK + 'C';
+		const result = stripLegacyContextMarkers(input);
+		expect(result).not.toContain('<<<');
+		expect(result).toContain('A');
+		expect(result).toContain('B');
+		expect(result).toContain('C');
+	});
+
+	it('strips an open/partial tool call block (no END marker)', () => {
+		const input = 'Lead text.' + OPEN_BLOCK;
+		const result = stripLegacyContextMarkers(input);
+		expect(result).toBe('Lead text.');
+		expect(result).not.toContain('<<<');
+	});
+
+	it('does not alter content with no markers', () => {
+		const input = 'Just a normal assistant response.';
+		expect(stripLegacyContextMarkers(input)).toBe(input);
+	});
+
+	it('strips reasoning block independently', () => {
+		const input = '<<<reasoning_content_start>>>think hard<<<reasoning_content_end>>>Answer.';
+		expect(stripLegacyContextMarkers(input)).toBe('Answer.');
+	});
+
+	it('strips both reasoning and agentic blocks together', () => {
+		const input =
+			'<<<reasoning_content_start>>>plan<<<reasoning_content_end>>>' +
+			'Some text.' +
+			COMPLETE_BLOCK;
+		expect(stripLegacyContextMarkers(input)).not.toContain('<<<');
+		expect(stripLegacyContextMarkers(input)).toContain('Some text.');
+	});
+
+	it('empty string survives', () => {
+		expect(stripLegacyContextMarkers('')).toBe('');
+	});
+
+	it('detects legacy markers', () => {
+		expect(LEGACY_AGENTIC_REGEX.HAS_LEGACY_MARKERS.test('normal text')).toBe(false);
+		expect(
+			LEGACY_AGENTIC_REGEX.HAS_LEGACY_MARKERS.test('text<<<AGENTIC_TOOL_CALL_START>>>more')
+		).toBe(true);
+		expect(LEGACY_AGENTIC_REGEX.HAS_LEGACY_MARKERS.test('<<<reasoning_content_start>>>think')).toBe(
+			true
+		);
+	});
+});

tools/ui/tests/unit/assistant-raw-output.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest';
+import { AgenticSectionType } from '$lib/enums';
+import { REASONING_TAGS } from '$lib/constants';
+import { buildAssistantRawOutput, type AgenticSection } from '$lib/utils/agentic';
+
+function makeSection(
+	overrides: Partial<AgenticSection> & { type: AgenticSectionType }
+): AgenticSection {
+	return {
+		content: '',
+		...overrides
+	};
+}
+
+describe('buildAssistantRawOutput', () => {
+	it('returns empty string for empty sections', () => {
+		expect(buildAssistantRawOutput([])).toBe('');
+	});
+
+	it('formats a reasoning section with a single newline between tags and content', () => {
+		const sections = [makeSection({ type: AgenticSectionType.REASONING, content: 'thinking...' })];
+		expect(buildAssistantRawOutput(sections)).toBe(
+			`${REASONING_TAGS.START}\nthinking...${REASONING_TAGS.END}`
+		);
+	});
+
+	it('formats a text section as-is', () => {
+		const sections = [makeSection({ type: AgenticSectionType.TEXT, content: 'Hello' })];
+		expect(buildAssistantRawOutput(sections)).toBe('Hello');
+	});
+
+	it('formats a tool call with JSON args and no result label', () => {
+		const sections = [
+			makeSection({
+				type: AgenticSectionType.TOOL_CALL,
+				toolName: 'read_file',
+				toolArgs: JSON.stringify({ path: '/tmp/file.txt' }),
+				toolResult: 'file contents'
+			})
+		];
+		expect(buildAssistantRawOutput(sections)).toBe(
+			[
+				'{',
+				'  "name": "read_file",',
+				'  "arguments": {',
+				'    "path": "/tmp/file.txt"',
+				'  }',
+				'}',
+				'',
+				'',
+				'file contents'
+			].join('\n')
+		);
+	});
+
+	it('joins multiple sections with double newlines', () => {
+		const sections = [
+			makeSection({ type: AgenticSectionType.TEXT, content: 'Hello' }),
+			makeSection({ type: AgenticSectionType.TOOL_CALL, toolName: 'noop' })
+		];
+		expect(buildAssistantRawOutput(sections)).toBe('Hello\n\n{\n  "name": "noop"\n}');
+	});
+
+	it('falls back to raw string args when JSON parsing fails', () => {
+		const sections = [
+			makeSection({
+				type: AgenticSectionType.TOOL_CALL,
+				toolName: 'broken',
+				toolArgs: '{not json',
+				toolResult: 'result'
+			})
+		];
+		expect(buildAssistantRawOutput(sections)).toBe(
+			['{', '  "name": "broken",', '  "arguments": "{not json"', '}', '', '', 'result'].join('\n')
+		);
+	});
+});

tools/ui/tests/unit/classify-tool-result.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect } from 'vitest';
+import { classifyToolResult } from '$lib/utils/agentic';
+
+describe('classifyToolResult', () => {
+	describe('text', () => {
+		it('returns text for undefined input', () => {
+			expect(classifyToolResult(undefined)).toBe('text');
+		});
+
+		it('returns text for empty string', () => {
+			expect(classifyToolResult('')).toBe('text');
+		});
+
+		it('returns text for whitespace-only input', () => {
+			expect(classifyToolResult('   \n  ')).toBe('text');
+		});
+
+		it('returns text for plain prose', () => {
+			expect(classifyToolResult('Hello, this is just some text.')).toBe('text');
+		});
+
+		it('returns text for shell-style line listings', () => {
+			expect(classifyToolResult('file1.java\nfile2.java\nfile3.java\n')).toBe('text');
+		});
+
+		it('returns text when a brace-like string is not valid JSON', () => {
+			expect(classifyToolResult('{key: value}')).toBe('text');
+		});
+	});
+
+	describe('json', () => {
+		it('classifies a flat JSON object', () => {
+			expect(classifyToolResult('{"key": "value", "n": 42}')).toBe('json');
+		});
+
+		it('classifies a JSON array', () => {
+			expect(classifyToolResult('["a", "b", "c"]')).toBe('json');
+		});
+
+		it('classifies a pretty-printed JSON object', () => {
+			expect(classifyToolResult('{\n  "key": "value"\n}')).toBe('json');
+		});
+
+		it('classifies a deeply nested JSON payload', () => {
+			const nested = JSON.stringify({ items: [{ id: 1, tags: ['a', 'b'] }] }, null, 2);
+			expect(classifyToolResult(nested)).toBe('json');
+		});
+
+		it('prefers JSON over inner markdown markers when the content starts with a brace', () => {
+			// A JSON object whose inner strings contain link syntax still
+			// reads as JSON because the leading `{` parses cleanly -
+			// `classifyToolResult` only inspects the top-level shape, not
+			// every nested line marker.
+			const jsonWithLink = '{"docs": "see [docs](https://example.com) for more"}';
+			expect(classifyToolResult(jsonWithLink)).toBe('json');
+		});
+	});
+
+	describe('markdown', () => {
+		it('classifies an ATX header line', () => {
+			expect(classifyToolResult('# Title\n\nSome text below.')).toBe('markdown');
+		});
+
+		it('classifies a fenced code block', () => {
+			expect(classifyToolResult('```json\n{"key": "v"}\n```')).toBe('markdown');
+		});
+
+		it('classifies a tilde-fenced code block', () => {
+			expect(classifyToolResult('~~~bash\nls -la\n~~~')).toBe('markdown');
+		});
+
+		it('classifies a markdown link', () => {
+			expect(classifyToolResult('See [docs](https://example.com) for more.')).toBe('markdown');
+		});
+
+		it('classifies bold text', () => {
+			expect(classifyToolResult('This is **very important**.')).toBe('markdown');
+		});
+
+		it('classifies a bulleted list', () => {
+			expect(classifyToolResult('- item one\n- item two\n- item three')).toBe('markdown');
+		});
+
+		it('classifies an ordered list', () => {
+			expect(classifyToolResult('1. first step\n2. second step\n3. third step')).toBe('markdown');
+		});
+
+		it('classifies a blockquote', () => {
+			expect(classifyToolResult('> quoted text\n> second line')).toBe('markdown');
+		});
+
+		it('classifies a markdown table', () => {
+			const table = '| a | b |\n| - | - |\n| 1 | 2 |';
+			expect(classifyToolResult(table)).toBe('markdown');
+		});
+
+		it('classifies a markdown table with alignment markers', () => {
+			const table = '| left | center | right |\n| :--- | :---: | ---: |\n| a | b | c |';
+			expect(classifyToolResult(table)).toBe('markdown');
+		});
+
+		it('classifies nested markdown headings', () => {
+			expect(classifyToolResult('## Section\n\n### Subsection\n')).toBe('markdown');
+		});
+
+		it('classifies combined markdown markers in one document', () => {
+			const md = [
+				'# Heading',
+				'',
+				'A paragraph with a [link](https://example.com) and **bold text**.',
+				'',
+				'- bullet item',
+				'- another bullet',
+				'',
+				'| col1 | col2 |',
+				'| ----- | ----- |',
+				'| a     | b     |'
+			].join('\n');
+			expect(classifyToolResult(md)).toBe('markdown');
+		});
+	});
+
+	describe('precedence', () => {
+		it('prefers JSON over markdown when both signals are present', () => {
+			// Starts with `[`, parses as JSON - markdown check is skipped.
+			const arr = '[1, 2, "# not-a-heading", "**not-bold**"]';
+			expect(classifyToolResult(arr)).toBe('json');
+		});
+	});
+});

tools/ui/tests/unit/clipboard.test.ts

@@ -0,0 +1,423 @@
+import { describe, it, expect } from 'vitest';
+import { AttachmentType } from '$lib/enums';
+import {
+	formatMessageForClipboard,
+	parseClipboardContent,
+	hasClipboardAttachments
+} from '$lib/utils/clipboard';
+
+describe('formatMessageForClipboard', () => {
+	it('returns plain content when no extras', () => {
+		const result = formatMessageForClipboard('Hello world', undefined);
+		expect(result).toBe('Hello world');
+	});
+
+	it('returns plain content when extras is empty array', () => {
+		const result = formatMessageForClipboard('Hello world', []);
+		expect(result).toBe('Hello world');
+	});
+
+	it('handles empty string content', () => {
+		const result = formatMessageForClipboard('', undefined);
+		expect(result).toBe('');
+	});
+
+	it('returns plain content when extras has only non-text attachments', () => {
+		const extras = [
+			{
+				type: AttachmentType.IMAGE as const,
+				name: 'image.png',
+				base64Url: 'data:image/png;base64,...'
+			}
+		];
+		const result = formatMessageForClipboard('Hello world', extras);
+		expect(result).toBe('Hello world');
+	});
+
+	it('filters non-text attachments and keeps only text ones', () => {
+		const extras = [
+			{
+				type: AttachmentType.IMAGE as const,
+				name: 'image.png',
+				base64Url: 'data:image/png;base64,...'
+			},
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'file.txt',
+				content: 'Text content'
+			},
+			{
+				type: AttachmentType.PDF as const,
+				name: 'doc.pdf',
+				base64Data: 'data:application/pdf;base64,...',
+				content: 'PDF content',
+				processedAsImages: false
+			}
+		];
+		const result = formatMessageForClipboard('Hello', extras);
+
+		expect(result).toContain('"file.txt"');
+		expect(result).not.toContain('image.png');
+		expect(result).not.toContain('doc.pdf');
+	});
+
+	it('formats message with text attachments', () => {
+		const extras = [
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'file1.txt',
+				content: 'File 1 content'
+			},
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'file2.txt',
+				content: 'File 2 content'
+			}
+		];
+		const result = formatMessageForClipboard('Hello world', extras);
+
+		expect(result).toContain('"Hello world"');
+		expect(result).toContain('"type": "TEXT"');
+		expect(result).toContain('"name": "file1.txt"');
+		expect(result).toContain('"content": "File 1 content"');
+		expect(result).toContain('"name": "file2.txt"');
+	});
+
+	it('handles content with quotes and special characters', () => {
+		const content = 'Hello "world" with\nnewline';
+		const extras = [
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'test.txt',
+				content: 'Test content'
+			}
+		];
+		const result = formatMessageForClipboard(content, extras);
+
+		// Should be valid JSON
+		expect(result.startsWith('"')).toBe(true);
+		// The content should be properly escaped
+		const parsed = JSON.parse(result.split('\n')[0]);
+		expect(parsed).toBe(content);
+	});
+
+	it('converts legacy context type to TEXT type', () => {
+		const extras = [
+			{
+				type: AttachmentType.LEGACY_CONTEXT as const,
+				name: 'legacy.txt',
+				content: 'Legacy content'
+			}
+		];
+		const result = formatMessageForClipboard('Hello', extras);
+
+		expect(result).toContain('"type": "TEXT"');
+		expect(result).not.toContain('"context"');
+	});
+
+	it('handles attachment content with special characters', () => {
+		const extras = [
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'code.js',
+				content: 'const x = "hello\\nworld";\nconst y = `template ${var}`;'
+			}
+		];
+		const formatted = formatMessageForClipboard('Check this code', extras);
+		const parsed = parseClipboardContent(formatted);
+
+		expect(parsed.textAttachments[0].content).toBe(
+			'const x = "hello\\nworld";\nconst y = `template ${var}`;'
+		);
+	});
+
+	it('handles unicode characters in content and attachments', () => {
+		const extras = [
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'unicode.txt',
+				content: '日本語テスト 🎉 émojis'
+			}
+		];
+		const formatted = formatMessageForClipboard('Привет мир 👋', extras);
+		const parsed = parseClipboardContent(formatted);
+
+		expect(parsed.message).toBe('Привет мир 👋');
+		expect(parsed.textAttachments[0].content).toBe('日本語テスト 🎉 émojis');
+	});
+
+	it('formats as plain text when asPlainText is true', () => {
+		const extras = [
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'file1.txt',
+				content: 'File 1 content'
+			},
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'file2.txt',
+				content: 'File 2 content'
+			}
+		];
+		const result = formatMessageForClipboard('Hello world', extras, true);
+
+		expect(result).toBe('Hello world\n\nFile 1 content\n\nFile 2 content');
+	});
+
+	it('returns plain content when asPlainText is true but no attachments', () => {
+		const result = formatMessageForClipboard('Hello world', [], true);
+		expect(result).toBe('Hello world');
+	});
+
+	it('plain text mode does not use JSON format', () => {
+		const extras = [
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'test.txt',
+				content: 'Test content'
+			}
+		];
+		const result = formatMessageForClipboard('Hello', extras, true);
+
+		expect(result).not.toContain('"type"');
+		expect(result).not.toContain('[');
+		expect(result).toBe('Hello\n\nTest content');
+	});
+});
+
+describe('parseClipboardContent', () => {
+	it('returns plain text as message when not in special format', () => {
+		const result = parseClipboardContent('Hello world');
+
+		expect(result.message).toBe('Hello world');
+		expect(result.textAttachments).toHaveLength(0);
+	});
+
+	it('handles empty string input', () => {
+		const result = parseClipboardContent('');
+
+		expect(result.message).toBe('');
+		expect(result.textAttachments).toHaveLength(0);
+	});
+
+	it('handles whitespace-only input', () => {
+		const result = parseClipboardContent('   \n\t  ');
+
+		expect(result.message).toBe('   \n\t  ');
+		expect(result.textAttachments).toHaveLength(0);
+	});
+
+	it('returns plain text as message when starts with quote but invalid format', () => {
+		const result = parseClipboardContent('"Unclosed quote');
+
+		expect(result.message).toBe('"Unclosed quote');
+		expect(result.textAttachments).toHaveLength(0);
+	});
+
+	it('returns original text when JSON array is malformed', () => {
+		const input = '"Hello"\n[invalid json';
+
+		const result = parseClipboardContent(input);
+
+		expect(result.message).toBe('"Hello"\n[invalid json');
+		expect(result.textAttachments).toHaveLength(0);
+	});
+
+	it('parses message with text attachments', () => {
+		const input = `"Hello world"
+[
+  {"type":"TEXT","name":"file1.txt","content":"File 1 content"},
+  {"type":"TEXT","name":"file2.txt","content":"File 2 content"}
+]`;
+
+		const result = parseClipboardContent(input);
+
+		expect(result.message).toBe('Hello world');
+		expect(result.textAttachments).toHaveLength(2);
+		expect(result.textAttachments[0].name).toBe('file1.txt');
+		expect(result.textAttachments[0].content).toBe('File 1 content');
+		expect(result.textAttachments[1].name).toBe('file2.txt');
+		expect(result.textAttachments[1].content).toBe('File 2 content');
+	});
+
+	it('handles escaped quotes in message', () => {
+		const input = `"Hello \\"world\\" with quotes"
+[
+  {"type":"TEXT","name":"file.txt","content":"test"}
+]`;
+
+		const result = parseClipboardContent(input);
+
+		expect(result.message).toBe('Hello "world" with quotes');
+		expect(result.textAttachments).toHaveLength(1);
+	});
+
+	it('handles newlines in message', () => {
+		const input = `"Hello\\nworld"
+[
+  {"type":"TEXT","name":"file.txt","content":"test"}
+]`;
+
+		const result = parseClipboardContent(input);
+
+		expect(result.message).toBe('Hello\nworld');
+		expect(result.textAttachments).toHaveLength(1);
+	});
+
+	it('returns message only when no array follows', () => {
+		const input = '"Just a quoted string"';
+
+		const result = parseClipboardContent(input);
+
+		expect(result.message).toBe('Just a quoted string');
+		expect(result.textAttachments).toHaveLength(0);
+	});
+
+	it('filters out invalid attachment objects', () => {
+		const input = `"Hello"
+[
+  {"type":"TEXT","name":"valid.txt","content":"valid"},
+  {"type":"INVALID","name":"invalid.txt","content":"invalid"},
+  {"name":"missing-type.txt","content":"missing"},
+  {"type":"TEXT","content":"missing name"}
+]`;
+
+		const result = parseClipboardContent(input);
+
+		expect(result.message).toBe('Hello');
+		expect(result.textAttachments).toHaveLength(1);
+		expect(result.textAttachments[0].name).toBe('valid.txt');
+	});
+
+	it('handles empty attachments array', () => {
+		const input = '"Hello"\n[]';
+
+		const result = parseClipboardContent(input);
+
+		expect(result.message).toBe('Hello');
+		expect(result.textAttachments).toHaveLength(0);
+	});
+
+	it('roundtrips correctly with formatMessageForClipboard', () => {
+		const originalContent = 'Hello "world" with\nspecial characters';
+		const originalExtras = [
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'file1.txt',
+				content: 'Content with\nnewlines and "quotes"'
+			},
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'file2.txt',
+				content: 'Another file'
+			}
+		];
+
+		const formatted = formatMessageForClipboard(originalContent, originalExtras);
+		const parsed = parseClipboardContent(formatted);
+
+		expect(parsed.message).toBe(originalContent);
+		expect(parsed.textAttachments).toHaveLength(2);
+		expect(parsed.textAttachments[0].name).toBe('file1.txt');
+		expect(parsed.textAttachments[0].content).toBe('Content with\nnewlines and "quotes"');
+		expect(parsed.textAttachments[1].name).toBe('file2.txt');
+		expect(parsed.textAttachments[1].content).toBe('Another file');
+	});
+});
+
+describe('hasClipboardAttachments', () => {
+	it('returns false for plain text', () => {
+		expect(hasClipboardAttachments('Hello world')).toBe(false);
+	});
+
+	it('returns false for empty string', () => {
+		expect(hasClipboardAttachments('')).toBe(false);
+	});
+
+	it('returns false for quoted string without attachments', () => {
+		expect(hasClipboardAttachments('"Hello world"')).toBe(false);
+	});
+
+	it('returns true for valid format with attachments', () => {
+		const input = `"Hello"
+[{"type":"TEXT","name":"file.txt","content":"test"}]`;
+
+		expect(hasClipboardAttachments(input)).toBe(true);
+	});
+
+	it('returns false for format with empty attachments array', () => {
+		const input = '"Hello"\n[]';
+
+		expect(hasClipboardAttachments(input)).toBe(false);
+	});
+
+	it('returns false for malformed JSON', () => {
+		expect(hasClipboardAttachments('"Hello"\n[broken')).toBe(false);
+	});
+});
+
+describe('roundtrip edge cases', () => {
+	it('preserves empty message with attachments', () => {
+		const extras = [
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'file.txt',
+				content: 'Content only'
+			}
+		];
+		const formatted = formatMessageForClipboard('', extras);
+		const parsed = parseClipboardContent(formatted);
+
+		expect(parsed.message).toBe('');
+		expect(parsed.textAttachments).toHaveLength(1);
+		expect(parsed.textAttachments[0].content).toBe('Content only');
+	});
+
+	it('preserves attachment with empty content', () => {
+		const extras = [
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'empty.txt',
+				content: ''
+			}
+		];
+		const formatted = formatMessageForClipboard('Message', extras);
+		const parsed = parseClipboardContent(formatted);
+
+		expect(parsed.message).toBe('Message');
+		expect(parsed.textAttachments).toHaveLength(1);
+		expect(parsed.textAttachments[0].content).toBe('');
+	});
+
+	it('preserves multiple backslashes', () => {
+		const content = 'Path: C:\\\\Users\\\\test\\\\file.txt';
+		const extras = [
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'path.txt',
+				content: 'D:\\\\Data\\\\file'
+			}
+		];
+		const formatted = formatMessageForClipboard(content, extras);
+		const parsed = parseClipboardContent(formatted);
+
+		expect(parsed.message).toBe(content);
+		expect(parsed.textAttachments[0].content).toBe('D:\\\\Data\\\\file');
+	});
+
+	it('preserves tabs and various whitespace', () => {
+		const content = 'Line1\t\tTabbed\n  Spaced\r\nCRLF';
+		const extras = [
+			{
+				type: AttachmentType.TEXT as const,
+				name: 'whitespace.txt',
+				content: '\t\t\n\n   '
+			}
+		];
+		const formatted = formatMessageForClipboard(content, extras);
+		const parsed = parseClipboardContent(formatted);
+
+		expect(parsed.message).toBe(content);
+		expect(parsed.textAttachments[0].content).toBe('\t\t\n\n   ');
+	});
+});

tools/ui/tests/unit/code.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest';
+import { highlightCode, trimCodePadding } from '$lib/utils/code';
+
+describe('trimCodePadding', () => {
+	it('removes a single leading newline', () => {
+		expect(trimCodePadding('\nfunction foo() {}')).toBe('function foo() {}');
+	});
+
+	it('removes multiple leading newlines', () => {
+		expect(trimCodePadding('\n\n\nfunction foo() {}')).toBe('function foo() {}');
+	});
+
+	it('removes whitespace-only leading lines', () => {
+		expect(trimCodePadding('\n  \n\t\nfunction foo() {}')).toBe('function foo() {}');
+	});
+
+	it('removes a single trailing newline', () => {
+		expect(trimCodePadding('function foo() {}\n')).toBe('function foo() {}');
+	});
+
+	it('removes multiple trailing newlines', () => {
+		expect(trimCodePadding('function foo() {}\n\n\n')).toBe('function foo() {}');
+	});
+
+	it('removes whitespace-only trailing lines', () => {
+		expect(trimCodePadding('function foo() {}\n  \n\t\n')).toBe('function foo() {}');
+	});
+
+	it('removes newlines on both sides at once', () => {
+		expect(trimCodePadding('\nfunction foo() {}\n')).toBe('function foo() {}');
+	});
+
+	it('preserves internal blank lines', () => {
+		expect(trimCodePadding('\nfunction foo() {\n\n  return 1;\n}\n')).toBe(
+			'function foo() {\n\n  return 1;\n}'
+		);
+	});
+
+	it('drops a leading whitespace-only line but keeps following code intact', () => {
+		expect(trimCodePadding('  \nfunction foo() {}')).toBe('function foo() {}');
+	});
+
+	it('passes through already-trimmed input unchanged', () => {
+		expect(trimCodePadding('function foo() {}')).toBe('function foo() {}');
+		expect(trimCodePadding('function foo() {\n  return 1;\n}')).toBe(
+			'function foo() {\n  return 1;\n}'
+		);
+	});
+
+	it('returns empty string when input is whitespace only', () => {
+		expect(trimCodePadding('\n\n\n')).toBe('');
+		expect(trimCodePadding('\n  \n\t\n')).toBe('');
+	});
+});
+
+describe('highlightCode', () => {
+	it('returns empty string for empty input', () => {
+		expect(highlightCode('', 'javascript')).toBe('');
+	});
+
+	it('does not produce a leading newline in the highlighted html', () => {
+		const html = highlightCode('\nfunction multiply(a, b) {\n  return a * b;\n}\n', 'javascript');
+		expect(html.startsWith('\n')).toBe(false);
+		expect(html.startsWith(' ')).toBe(false);
+	});
+
+	it('does not produce a trailing newline in the highlighted html', () => {
+		const html = highlightCode('\nfunction foo() {}\n', 'javascript');
+		expect(html.endsWith('\n')).toBe(false);
+	});
+
+	it('preserves internal blank lines in highlighted code', () => {
+		const html = highlightCode('\nfunction foo() {\n\n  return 1;\n}\n', 'javascript');
+		expect(html).toContain('\n\n');
+	});
+
+	it('produces the same body for framed and unframed input', () => {
+		const trimmed = highlightCode('function foo() {}', 'javascript');
+		const framed = highlightCode('\nfunction foo() {}\n', 'javascript');
+		expect(framed).toBe(trimmed);
+	});
+
+	it('auto-detects an unknown language by default', () => {
+		const html = highlightCode('const answer = 42;', 'not-a-language');
+		expect(html).toContain('hljs-');
+	});
+
+	it('escapes instead of auto-detecting when autoDetect is false', () => {
+		const html = highlightCode('const answer = 42;', 'not-a-language', false);
+		expect(html).not.toContain('hljs-');
+		expect(html).toBe('const answer = 42;');
+	});
+
+	it('still highlights a known language when autoDetect is false', () => {
+		const html = highlightCode('const answer = 42;', 'javascript', false);
+		expect(html).toContain('hljs-');
+	});
+
+	it('escapes html metacharacters when falling back to plain text', () => {
+		const html = highlightCode('<script>a && b</script>', 'not-a-language', false);
+		expect(html).toBe('&lt;script&gt;a &amp;&amp; b&lt;/script&gt;');
+	});
+});

tools/ui/tests/unit/compute-line-diff.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from 'vitest';
+import { DiffLineKind } from '$lib/enums';
+import { computeLineDiff, renderUnifiedDiff, type DiffLine } from '$lib/utils';
+
+describe('computeLineDiff', () => {
+	it('returns empty for two empty inputs', () => {
+		expect(computeLineDiff('', '')).toEqual([]);
+	});
+
+	it('marks every line as removed for an empty new text', () => {
+		expect(computeLineDiff('a\nb\nc', '')).toEqual([
+			{ kind: 'remove', text: 'a', oldLine: 1 },
+			{ kind: 'remove', text: 'b', oldLine: 2 },
+			{ kind: 'remove', text: 'c', oldLine: 3 }
+		]);
+	});
+
+	it('marks every line as added for an empty old text', () => {
+		expect(computeLineDiff('', 'a\nb')).toEqual([
+			{ kind: 'add', text: 'a', newLine: 1 },
+			{ kind: 'add', text: 'b', newLine: 2 }
+		]);
+	});
+
+	it('detects a single-line replace', () => {
+		expect(computeLineDiff('old', 'new')).toEqual([
+			{ kind: 'add', text: 'new', newLine: 1 },
+			{ kind: 'remove', text: 'old', oldLine: 1 }
+		]);
+	});
+
+	it('preserves interleaved context around additions', () => {
+		const oldText = ['a', 'b', 'c'].join('\n');
+		const newText = ['a', 'b', 'B', 'c'].join('\n');
+		expect(computeLineDiff(oldText, newText)).toEqual([
+			{ kind: 'context', text: 'a', oldLine: 1, newLine: 1 },
+			{ kind: 'context', text: 'b', oldLine: 2, newLine: 2 },
+			{ kind: 'add', text: 'B', newLine: 3 },
+			{ kind: 'context', text: 'c', oldLine: 3, newLine: 4 }
+		]);
+	});
+
+	it('preserves interleaved context around an isolated replace', () => {
+		// Multi-line context around a one-line change -> the diff should
+		// show context flanking the changed line at its natural position.
+		const oldText = ['a', 'b', 'c', 'd'].join('\n');
+		const newText = ['a', 'b', 'X', 'd'].join('\n');
+		expect(computeLineDiff(oldText, newText)).toEqual([
+			{ kind: 'context', text: 'a', oldLine: 1, newLine: 1 },
+			{ kind: 'context', text: 'b', oldLine: 2, newLine: 2 },
+			{ kind: 'add', text: 'X', newLine: 3 },
+			{ kind: 'remove', text: 'c', oldLine: 3 },
+			{ kind: 'context', text: 'd', oldLine: 4, newLine: 4 }
+		]);
+	});
+
+	it('preserves interleaved context around removals', () => {
+		const oldText = ['a', 'b', 'c', 'd'].join('\n');
+		const newText = ['a', 'c', 'd'].join('\n');
+		expect(computeLineDiff(oldText, newText)).toEqual([
+			{ kind: 'context', text: 'a', oldLine: 1, newLine: 1 },
+			{ kind: 'remove', text: 'b', oldLine: 2 },
+			{ kind: 'context', text: 'c', oldLine: 3, newLine: 2 },
+			{ kind: 'context', text: 'd', oldLine: 4, newLine: 3 }
+		]);
+	});
+
+	it('handles purely identical inputs', () => {
+		const text = 'x\ny\nz';
+		const result = computeLineDiff(text, text);
+		expect(result).toEqual([
+			{ kind: 'context', text: 'x', oldLine: 1, newLine: 1 },
+			{ kind: 'context', text: 'y', oldLine: 2, newLine: 2 },
+			{ kind: 'context', text: 'z', oldLine: 3, newLine: 3 }
+		]);
+	});
+
+	it('strips a trailing newline on the old/new inputs', () => {
+		expect(computeLineDiff('a\n', 'a\nb\n')).toEqual([
+			{ kind: 'context', text: 'a', oldLine: 1, newLine: 1 },
+			{ kind: 'add', text: 'b', newLine: 2 }
+		]);
+	});
+
+	it('normalizes trailing CR on each line', () => {
+		expect(computeLineDiff('a\r\nb\r\n', 'a\nb')).toEqual([
+			{ kind: 'context', text: 'a', oldLine: 1, newLine: 1 },
+			{ kind: 'context', text: 'b', oldLine: 2, newLine: 2 }
+		]);
+	});
+
+	it('keeps line numbers monotonic across mixed add/remove/context', () => {
+		const oldText = ['l1', 'l2', 'l3', 'l4', 'l5'].join('\n');
+		const newText = ['l1', 'l2-EDIT', 'l3', 'l4-NEW', 'l5'].join('\n');
+		const diff = computeLineDiff(oldText, newText);
+
+		// Walk the diff: every oldLine must increase strictly, and every
+		// newLine must increase strictly. Lines missing one side (add or
+		// remove) carry no number on that side.
+		let lastOld = 0;
+		let lastNew = 0;
+		for (const line of diff) {
+			if (line.oldLine !== undefined) {
+				expect(line.oldLine).toBeGreaterThan(lastOld);
+				lastOld = line.oldLine;
+			}
+			if (line.newLine !== undefined) {
+				expect(line.newLine).toBeGreaterThan(lastNew);
+				lastNew = line.newLine;
+			}
+		}
+	});
+});
+
+describe('renderUnifiedDiff', () => {
+	it('returns empty string for empty diff', () => {
+		expect(renderUnifiedDiff([])).toBe('');
+	});
+
+	it('prefixes each line with `+`, `-`, or a single space', () => {
+		const lines: DiffLine[] = [
+			{ kind: DiffLineKind.CONTEXT, text: 'ctx' },
+			{ kind: DiffLineKind.ADD, text: 'plus' },
+			{ kind: DiffLineKind.REMOVE, text: 'minus' }
+		];
+		expect(renderUnifiedDiff(lines)).toBe(' ctx\n+plus\n-minus');
+	});
+
+	it('ignores oldLine/newLine metadata when emitting prefixes', () => {
+		const lines: DiffLine[] = [
+			{ kind: DiffLineKind.CONTEXT, text: 'a', oldLine: 1, newLine: 1 },
+			{ kind: DiffLineKind.ADD, text: 'b', newLine: 2 }
+		];
+		expect(renderUnifiedDiff(lines)).toBe(' a\n+b');
+	});
+});

tools/ui/tests/unit/continue-intent.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect } from 'vitest';
+import { classifyContinueIntent } from '$lib/utils/agentic';
+import { ContinueIntentKind, MessageRole, MessageType } from '$lib/enums';
+import type { DatabaseMessage } from '$lib/types/database';
+
+/**
+ * Tests for the Continue button intent classifier.
+ *
+ * The classifier walks the persisted message history to decide which of three
+ * resume paths a Continue click should take:
+ *
+ *   A. append_text  -> plain text assistant turn, resume with
+ *                      continue_final_message.
+ *   B. rerun_turn   -> assistant turn with tool_calls but no tool results yet,
+ *                      the stream was cut mid turn and the tool_calls are
+ *                      unrecoverable as a token level continuation. Drop the
+ *                      target and rerun from the previous history.
+ *   C. next_turn    -> assistant turn with tool_calls that were already
+ *                      resolved by trailing tool results. Hand the history
+ *                      back to the agentic loop so it starts the next turn.
+ */
+
+let nextId = 0;
+function makeMsg(role: MessageRole, opts: Partial<DatabaseMessage> = {}): DatabaseMessage {
+	nextId++;
+	return {
+		id: `msg-${nextId}`,
+		convId: 'conv-1',
+		type: MessageType.TEXT,
+		timestamp: nextId,
+		role,
+		content: '',
+		parent: null,
+		children: [],
+		...opts
+	};
+}
+
+function toolCall(id: string, name: string, args: string = '{}'): string {
+	return JSON.stringify([{ id, type: 'function', function: { name, arguments: args } }]);
+}
+
+describe('classifyContinueIntent', () => {
+	it('returns append_text for a plain text assistant turn at the tail', () => {
+		const messages = [
+			makeMsg(MessageRole.USER, { content: 'hello' }),
+			makeMsg(MessageRole.ASSISTANT, { content: 'hi there' })
+		];
+
+		const intent = classifyContinueIntent(messages, 1);
+
+		expect(intent).toEqual({ kind: ContinueIntentKind.APPEND_TEXT });
+	});
+
+	it('returns append_text for a plain text assistant turn in the middle', () => {
+		const messages = [
+			makeMsg(MessageRole.USER, { content: 'q1' }),
+			makeMsg(MessageRole.ASSISTANT, { content: 'a1' }),
+			makeMsg(MessageRole.USER, { content: 'q2' }),
+			makeMsg(MessageRole.ASSISTANT, { content: 'a2' })
+		];
+
+		expect(classifyContinueIntent(messages, 1)).toEqual({ kind: ContinueIntentKind.APPEND_TEXT });
+	});
+
+	it('returns rerun_turn when the assistant has tool_calls without results', () => {
+		const messages = [
+			makeMsg(MessageRole.USER, { content: 'list files' }),
+			makeMsg(MessageRole.ASSISTANT, {
+				content: '',
+				toolCalls: toolCall('call_1', 'bash_tool', '{"command":"ls"}')
+			})
+		];
+
+		const intent = classifyContinueIntent(messages, 1);
+
+		expect(intent).toEqual({ kind: ContinueIntentKind.RERUN_TURN, truncateAfter: 0 });
+	});
+
+	it('returns next_turn when trailing tool results resolve the tool_calls', () => {
+		const messages = [
+			makeMsg(MessageRole.USER, { content: 'list files' }),
+			makeMsg(MessageRole.ASSISTANT, {
+				content: '',
+				toolCalls: toolCall('call_1', 'bash_tool')
+			}),
+			makeMsg(MessageRole.TOOL, { content: 'file1\nfile2', toolCallId: 'call_1' })
+		];
+
+		const intent = classifyContinueIntent(messages, 1);
+
+		expect(intent).toEqual({ kind: ContinueIntentKind.NEXT_TURN, truncateAfter: 2 });
+	});
+
+	it('next_turn keeps all consecutive trailing tool results, not just one', () => {
+		const messages = [
+			makeMsg(MessageRole.USER, { content: 'do many things' }),
+			makeMsg(MessageRole.ASSISTANT, {
+				content: '',
+				toolCalls: JSON.stringify([
+					{ id: 'call_1', type: 'function', function: { name: 'a', arguments: '{}' } },
+					{ id: 'call_2', type: 'function', function: { name: 'b', arguments: '{}' } }
+				])
+			}),
+			makeMsg(MessageRole.TOOL, { content: 'r1', toolCallId: 'call_1' }),
+			makeMsg(MessageRole.TOOL, { content: 'r2', toolCallId: 'call_2' })
+		];
+
+		const intent = classifyContinueIntent(messages, 1);
+
+		expect(intent).toEqual({ kind: ContinueIntentKind.NEXT_TURN, truncateAfter: 3 });
+	});
+
+	it('next_turn stops at the first non tool message after the target', () => {
+		const messages = [
+			makeMsg(MessageRole.USER, { content: 'go' }),
+			makeMsg(MessageRole.ASSISTANT, {
+				content: '',
+				toolCalls: toolCall('call_1', 'a')
+			}),
+			makeMsg(MessageRole.TOOL, { content: 'r1', toolCallId: 'call_1' }),
+			makeMsg(MessageRole.USER, { content: 'wait' }),
+			makeMsg(MessageRole.TOOL, { content: 'late', toolCallId: 'call_1' })
+		];
+
+		const intent = classifyContinueIntent(messages, 1);
+
+		// truncateAfter must point at the contiguous tool block, not jump over
+		// the user message to grab the dangling late tool.
+		expect(intent).toEqual({ kind: ContinueIntentKind.NEXT_TURN, truncateAfter: 2 });
+	});
+
+	it('returns append_text when toolCalls is set but parses to empty array', () => {
+		const messages = [
+			makeMsg(MessageRole.USER, { content: 'q' }),
+			makeMsg(MessageRole.ASSISTANT, { content: 'a', toolCalls: '[]' })
+		];
+
+		expect(classifyContinueIntent(messages, 1)).toEqual({ kind: ContinueIntentKind.APPEND_TEXT });
+	});
+
+	it('returns append_text when toolCalls is malformed JSON', () => {
+		const messages = [
+			makeMsg(MessageRole.USER, { content: 'q' }),
+			makeMsg(MessageRole.ASSISTANT, { content: 'a', toolCalls: '{not json' })
+		];
+
+		expect(classifyContinueIntent(messages, 1)).toEqual({ kind: ContinueIntentKind.APPEND_TEXT });
+	});
+
+	it('returns append_text defensively when idx points at a non assistant message', () => {
+		const messages = [
+			makeMsg(MessageRole.USER, { content: 'q' }),
+			makeMsg(MessageRole.ASSISTANT, { content: 'a' })
+		];
+
+		expect(classifyContinueIntent(messages, 0)).toEqual({ kind: ContinueIntentKind.APPEND_TEXT });
+	});
+
+	it('returns append_text defensively when idx is out of bounds', () => {
+		const messages = [makeMsg(MessageRole.ASSISTANT, { content: 'a' })];
+
+		expect(classifyContinueIntent(messages, 5)).toEqual({ kind: ContinueIntentKind.APPEND_TEXT });
+		expect(classifyContinueIntent([], 0)).toEqual({ kind: ContinueIntentKind.APPEND_TEXT });
+	});
+});

tools/ui/tests/unit/conversation-import.test.ts

@@ -0,0 +1,112 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { zipSync, strToU8 } from 'fflate';
+import { MessageRole, MessageType } from '$lib/enums';
+import { NEWLINE } from '$lib/constants';
+import type { ExportedConversation } from '$lib/types/database';
+
+let conversationsStore: typeof import('$lib/stores/conversations.svelte').conversationsStore;
+
+// node env unit project has no DOM, install a minimal localStorage backed by a
+// Map before the store module reads it. Transforming the store takes seconds,
+// so import it once for the whole file.
+beforeAll(async () => {
+	const store = new Map<string, string>();
+	const polyfill: Storage = {
+		get length() {
+			return store.size;
+		},
+		clear: () => store.clear(),
+		getItem: (k) => (store.has(k) ? store.get(k)! : null),
+		key: (i) => Array.from(store.keys())[i] ?? null,
+		removeItem: (k) => {
+			store.delete(k);
+		},
+		setItem: (k, v) => {
+			store.set(k, String(v));
+		}
+	};
+	(globalThis as unknown as { localStorage: Storage }).localStorage = polyfill;
+
+	({ conversationsStore } = await import('$lib/stores/conversations.svelte'));
+}, 30000);
+
+function makeSession(id: string): ExportedConversation {
+	return {
+		conv: { id, currNode: `${id}-msg`, lastModified: 0, name: `Chat ${id}` },
+		messages: [
+			{
+				id: `${id}-msg`,
+				convId: id,
+				type: MessageType.TEXT,
+				timestamp: 0,
+				role: MessageRole.USER,
+				content: `hello from ${id}`,
+				parent: null,
+				children: []
+			}
+		]
+	} as unknown as ExportedConversation;
+}
+
+/**
+ * `parseImportFile` detects the format from the file contents. iOS has no UTI
+ * for `.jsonl`, so the picker cannot filter on it and the filename carries no
+ * guarantee: a JSONL export must import under any name.
+ */
+describe('conversationsStore.parseImportFile', () => {
+	it('imports a JSONL export whose name has no meaningful extension', async () => {
+		const jsonl = conversationsStore.serializeSessionToJsonl(makeSession('a'));
+
+		const sessions = await conversationsStore.parseImportFile(new File([jsonl], 'export'));
+
+		expect(sessions).toHaveLength(1);
+		expect(sessions[0].conv.id).toBe('a');
+		expect(sessions[0].messages[0].content).toBe('hello from a');
+	});
+
+	it('imports several sessions from one JSONL file', async () => {
+		const jsonl = [makeSession('a'), makeSession('b')]
+			.map((session) => conversationsStore.serializeSessionToJsonl(session))
+			.join(NEWLINE);
+
+		const sessions = await conversationsStore.parseImportFile(new File([jsonl], 'export.txt'));
+
+		expect(sessions.map((session) => session.conv.id)).toEqual(['a', 'b']);
+	});
+
+	it('imports a ZIP archive whose name has no meaningful extension', async () => {
+		const zipped = zipSync({
+			'a.jsonl': strToU8(conversationsStore.serializeSessionToJsonl(makeSession('a'))),
+			'b.jsonl': strToU8(conversationsStore.serializeSessionToJsonl(makeSession('b'))),
+			'notes.txt': strToU8('ignored')
+		});
+
+		const sessions = await conversationsStore.parseImportFile(new File([zipped], 'archive'));
+
+		expect(sessions.map((session) => session.conv.id).sort()).toEqual(['a', 'b']);
+	});
+
+	it('imports the legacy JSON array format', async () => {
+		const json = JSON.stringify([makeSession('a')], null, 2);
+
+		const sessions = await conversationsStore.parseImportFile(new File([json], 'export.jsonl'));
+
+		expect(sessions).toHaveLength(1);
+		expect(sessions[0].conv.id).toBe('a');
+	});
+
+	it('imports the legacy JSON single object format', async () => {
+		const json = JSON.stringify(makeSession('a'));
+
+		const sessions = await conversationsStore.parseImportFile(new File([json], 'export'));
+
+		expect(sessions).toHaveLength(1);
+		expect(sessions[0].conv.id).toBe('a');
+	});
+
+	it('rejects a file that holds neither format', async () => {
+		await expect(
+			conversationsStore.parseImportFile(new File(['not an export'], 'export.jsonl'))
+		).rejects.toThrow();
+	});
+});

tools/ui/tests/unit/favicon-colorize.test.ts

@@ -0,0 +1,198 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+	colorizeFaviconSvg,
+	padFaviconSvg,
+	writeThemeFavicons
+} from '../../scripts/favicon-colorize';
+
+const SOURCE_SVG = [
+	'<svg xmlns="http://www.w3.org/2000/svg">',
+	'  <path d="M0 0" fill="currentColor"/>',
+	'  <path d="M1 1" fill="#ff00aa"/>',
+	'  <circle fill="currentColor"/>',
+	'</svg>'
+].join('\n');
+
+describe('colorizeFaviconSvg', () => {
+	it('substitutes every currentColor occurrence for the light variant', () => {
+		const { light } = colorizeFaviconSvg(SOURCE_SVG, '#111111', '#fafafa');
+		expect(light.match(/currentColor/g)).toBeNull();
+		expect(light).toContain('fill="#111111"');
+		expect(light).toContain('<circle fill="#111111"/>');
+	});
+
+	it('substitutes every currentColor occurrence for the dark variant', () => {
+		const { dark } = colorizeFaviconSvg(SOURCE_SVG, '#111111', '#fafafa');
+		expect(dark.match(/currentColor/g)).toBeNull();
+		expect(dark).toContain('fill="#fafafa"');
+		expect(dark).toContain('<circle fill="#fafafa"/>');
+	});
+
+	it('leaves non-currentColor colors untouched in both variants', () => {
+		const { light, dark } = colorizeFaviconSvg(SOURCE_SVG, '#111111', '#fafafa');
+		expect(light).toContain('fill="#ff00aa"');
+		expect(dark).toContain('fill="#ff00aa"');
+	});
+
+	it('does not alter any other part of the SVG', () => {
+		const { light, dark } = colorizeFaviconSvg(SOURCE_SVG, '#111111', '#fafafa');
+		const stripColors = (s: string) =>
+			s.replaceAll('#111111', '').replaceAll('#fafafa', '').replaceAll('currentColor', '');
+		const expected = stripColors(SOURCE_SVG);
+		expect(stripColors(light)).toBe(expected);
+		expect(stripColors(dark)).toBe(expected);
+	});
+
+	it('returns the same SVG for light and dark when called with the same color', () => {
+		const result = colorizeFaviconSvg(SOURCE_SVG, '#abcdef', '#abcdef');
+		expect(result.light).toBe(result.dark);
+	});
+
+	it('returns the source unchanged when given a color that does not appear (no currentColor in source)', () => {
+		const plain = '<svg><path fill="#000"/></svg>';
+		const { light, dark } = colorizeFaviconSvg(plain, '#111111', '#fafafa');
+		expect(light).toBe(plain);
+		expect(dark).toBe(plain);
+	});
+});
+
+describe('padFaviconSvg', () => {
+	const SIZED_SVG =
+		'<svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">' +
+		'<path d="M244.95 8L388.923 8Z" fill="currentColor"/>' +
+		'</svg>';
+
+	it('wraps inner content in a translate-then-scale group that matches padding', () => {
+		const padded = padFaviconSvg(SIZED_SVG, 0.05);
+		// scale = 1 - 0.05 = 0.95
+		// translate = (0.05 * 512) / 2 = 12.8 on each axis
+		expect(padded).toContain('transform="translate(12.8 12.8) scale(0.95)"');
+		expect(padded).toContain('<g transform="translate(12.8 12.8) scale(0.95)">');
+		expect(padded).toContain('<path d="M244.95 8L388.923 8Z" fill="currentColor"/>');
+		expect(padded.endsWith('</g></svg>')).toBe(true);
+	});
+
+	it('preserves the outer <svg> tag attributes', () => {
+		const padded = padFaviconSvg(SIZED_SVG, 0.1);
+		expect(padded.startsWith('<svg width="512" height="512" viewBox="0 0 512 512"')).toBe(true);
+	});
+
+	it('returns the input unchanged for zero or negative padding', () => {
+		expect(padFaviconSvg(SIZED_SVG, 0)).toBe(SIZED_SVG);
+		expect(padFaviconSvg(SIZED_SVG, -0.1)).toBe(SIZED_SVG);
+	});
+
+	it('returns the input unchanged when padding would fully collapse the icon (>= 1)', () => {
+		expect(padFaviconSvg(SIZED_SVG, 1)).toBe(SIZED_SVG);
+		expect(padFaviconSvg(SIZED_SVG, 1.5)).toBe(SIZED_SVG);
+	});
+
+	it('returns the input unchanged when no viewBox is present', () => {
+		const noViewBox = '<svg width="32" height="32"><path d="M0 0Z"/></svg>';
+		expect(padFaviconSvg(noViewBox, 0.1)).toBe(noViewBox);
+	});
+
+	it('returns the input unchanged when viewBox values are not finite numbers', () => {
+		const bad = '<svg viewBox="auto auto 0 0"><path/></svg>';
+		expect(padFaviconSvg(bad, 0.1)).toBe(bad);
+	});
+
+	it('tolerates a non-square viewBox', () => {
+		const wide = '<svg viewBox="0 0 100 50"><rect/></svg>';
+		const padded = padFaviconSvg(wide, 0.1);
+		// scale 0.9, translate (5, 2.5)
+		expect(padded).toContain('transform="translate(5 2.5) scale(0.9)"');
+	});
+});
+
+describe('writeThemeFavicons', () => {
+	const LOGO =
+		'<svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">' +
+		'<path d="M244.95 8L388.923 8Z" fill="currentColor"/>' +
+		'</svg>';
+
+	let tmpDir: string;
+
+	beforeEach(() => {
+		tmpDir = mkdtempSync(join(tmpdir(), 'favicon-'));
+	});
+
+	afterEach(() => {
+		rmSync(tmpDir, { recursive: true, force: true });
+	});
+
+	function setupSource() {
+		const sourcePath = join(tmpDir, 'logo.svg');
+		writeFileSync(sourcePath, LOGO);
+		return {
+			sourcePath,
+			lightPath: join(tmpDir, 'favicon.svg'),
+			darkPath: join(tmpDir, 'favicon-dark.svg')
+		};
+	}
+
+	it('writes colorized, un-padded favicons without modifying the source', () => {
+		const { sourcePath, lightPath, darkPath } = setupSource();
+		const before = readFileSync(sourcePath, 'utf-8');
+
+		writeThemeFavicons('#abcdef', '#012345', {
+			sourcePath,
+			lightOutPath: lightPath,
+			darkOutPath: darkPath
+		});
+
+		const lightOut = readFileSync(lightPath, 'utf-8');
+		const darkOut = readFileSync(darkPath, 'utf-8');
+
+		// currentColor swapped to the requested palette in both files
+		expect(lightOut).toContain('fill="#abcdef"');
+		expect(lightOut).not.toContain('currentColor');
+		expect(darkOut).toContain('fill="#012345"');
+		expect(darkOut).not.toContain('currentColor');
+
+		// default padding (0) keeps the wrapper off the output
+		expect(lightOut).not.toContain('<g ');
+		expect(darkOut).not.toContain('<g ');
+
+		// source file is unchanged after the call
+		expect(readFileSync(sourcePath, 'utf-8')).toBe(before);
+	});
+
+	it('writes colorized favicons wrapped in a padding <g transform>...</g>', () => {
+		const { sourcePath, lightPath, darkPath } = setupSource();
+		// mirror the production wiring: PWA_ASSET_GENERATOR.FAVICON_PADDING
+		const padding = 0.04;
+		// scale = 1 - 0.04 = 0.96; translate = (0.04 * 512) / 2 = 10.24
+		const expectedTransform = 'transform="translate(10.24 10.24) scale(0.96)"';
+
+		writeThemeFavicons('#111111', '#fafafa', {
+			sourcePath,
+			lightOutPath: lightPath,
+			darkOutPath: darkPath,
+			padding
+		});
+
+		const lightOut = readFileSync(lightPath, 'utf-8');
+		const darkOut = readFileSync(darkPath, 'utf-8');
+
+		// both files get the same padding wrapper derived from the viewBox
+		expect(lightOut).toContain(`<g ${expectedTransform}>`);
+		expect(lightOut.endsWith('</g></svg>')).toBe(true);
+		expect(darkOut).toContain(`<g ${expectedTransform}>`);
+		expect(darkOut.endsWith('</g></svg>')).toBe(true);
+
+		// colorization still happens inside the wrapped group
+		expect(lightOut).toContain('fill="#111111"');
+		expect(lightOut).not.toContain('currentColor');
+		expect(darkOut).toContain('fill="#fafafa"');
+		expect(darkOut).not.toContain('currentColor');
+		// light palette colour must not leak into dark output
+		expect(darkOut).not.toContain('#111111');
+
+		// source file is not modified by the padding step
+		expect(readFileSync(sourcePath, 'utf-8')).toBe(LOGO);
+	});
+});

tools/ui/tests/unit/headers.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest';
+import { parseHeadersToArray, serializeHeaders } from '$lib/utils/headers';
+
+/**
+ * Tests for the header serialization helpers used by the MCP server form
+ * (custom header rows) and the new Authorization/Bearer-token flow.
+ */
+describe('parseHeadersToArray', () => {
+	it('returns an empty array for empty or whitespace-only input', () => {
+		expect(parseHeadersToArray('')).toEqual([]);
+		expect(parseHeadersToArray('   ')).toEqual([]);
+		expect(parseHeadersToArray(undefined as unknown as string)).toEqual([]);
+	});
+
+	it('returns an empty array for invalid JSON input', () => {
+		expect(parseHeadersToArray('{not-json')).toEqual([]);
+		expect(parseHeadersToArray('[]')).toEqual([]);
+		expect(parseHeadersToArray('"plain-string"')).toEqual([]);
+	});
+
+	it('converts an object into ordered key/value pairs', () => {
+		expect(parseHeadersToArray('{"X-Foo":"bar","Authorization":"Bearer abc"}')).toEqual([
+			{ key: 'X-Foo', value: 'bar' },
+			{ key: 'Authorization', value: 'Bearer abc' }
+		]);
+	});
+
+	it('stringifies non-string values', () => {
+		expect(parseHeadersToArray('{"count":"42","flag":"true"}')).toEqual([
+			{ key: 'count', value: '42' },
+			{ key: 'flag', value: 'true' }
+		]);
+	});
+});
+
+describe('serializeHeaders', () => {
+	it('returns an empty string when there are no valid pairs', () => {
+		expect(serializeHeaders([])).toBe('');
+		expect(serializeHeaders([{ key: '', value: 'value' }])).toBe('');
+		expect(serializeHeaders([{ key: '   ', value: 'value' }])).toBe('');
+	});
+
+	it('returns an empty string when every pair has a blank key', () => {
+		expect(
+			serializeHeaders([
+				{ key: '', value: 'drop-me' },
+				{ key: '   ', value: 'drop-me-too' },
+				{ key: '\t', value: 'tab-key' }
+			])
+		).toBe('');
+	});
+
+	it('drops pairs with empty keys but keeps the rest', () => {
+		expect(
+			serializeHeaders([
+				{ key: '', value: 'drop-me' },
+				{ key: 'X-Keep', value: 'ok' }
+			])
+		).toBe('{"X-Keep":"ok"}');
+	});
+
+	it('trims keys before serializing', () => {
+		expect(serializeHeaders([{ key: '  X-Space  ', value: 'ok' }])).toBe('{"X-Space":"ok"}');
+	});
+
+	it('preserves the input order of surviving pairs', () => {
+		const serialized = serializeHeaders([
+			{ key: 'X-C', value: '3' },
+			{ key: 'X-A', value: '1' },
+			{ key: 'X-B', value: '2' }
+		]);
+
+		// Object key order follows insertion order in modern JS engines, so
+		// the serialized JSON writes keys in our input order.
+		expect(JSON.parse(serialized)).toEqual({ 'X-C': '3', 'X-A': '1', 'X-B': '2' });
+	});
+});
+
+describe('parseHeadersToArray / serializeHeaders roundtrip', () => {
+	it('serializes back to an equal header object after a parse', () => {
+		const original = JSON.stringify({
+			'Content-Type': 'application/json',
+			'X-Trace-Id': 'abc-123'
+		});
+
+		const roundtrip = serializeHeaders(parseHeadersToArray(original));
+
+		expect(JSON.parse(roundtrip)).toEqual(JSON.parse(original));
+	});
+
+	it('drops rows whose keys are blank after trimming during serialization', () => {
+		const pairs = parseHeadersToArray('{"X-Keep":"ok","":"drop-me"}');
+
+		// parseHeadersToArray keeps raw key strings (the consumer is expected to
+		// filter blanks, not the parser); serialization must strip them.
+		expect(pairs).toEqual([
+			{ key: 'X-Keep', value: 'ok' },
+			{ key: '', value: 'drop-me' }
+		]);
+		expect(serializeHeaders(pairs)).toBe('{"X-Keep":"ok"}');
+	});
+
+	it('preserves upstream keys untouched (does not lowercase them)', () => {
+		const upperCased = '{"Authorization":"Bearer xyz"}';
+
+		const parsed = parseHeadersToArray(upperCased);
+
+		expect(parsed).toEqual([{ key: 'Authorization', value: 'Bearer xyz' }]);
+	});
+
+	it('bearer-token write survives a re-parse when paired with regular custom headers', () => {
+		// The McpServerForm bearer UI writes {Authorization: `Bearer <token>`}
+		// into the same headers string as the custom KV section. The round
+		// trip below mirrors the exact shape the form produces so a future
+		// refactor of either code path cannot silently change the on-disk key.
+		const pairs = [
+			{ key: 'X-Trace-Id', value: 'abc-123' },
+			{ key: 'Authorization', value: 'Bearer super-secret' }
+		];
+
+		const serialized = serializeHeaders(pairs);
+
+		expect(serialized).toBe('{"X-Trace-Id":"abc-123","Authorization":"Bearer super-secret"}');
+		expect(parseHeadersToArray(serialized)).toEqual(pairs);
+	});
+});

tools/ui/tests/unit/jpeg-orientation.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest';
+import { getJpegOrientationFromDataURL, isJpegMimeType } from '$lib/utils/jpeg-orientation';
+
+// Builds the TIFF payload of an APP1 segment holding a single IFD0 entry
+function buildTiff(littleEndian: boolean, tag: number, value: number): number[] {
+	const u16 = (v: number) => (littleEndian ? [v & 0xff, v >> 8] : [v >> 8, v & 0xff]);
+	const u32 = (v: number) =>
+		littleEndian
+			? [v & 0xff, (v >> 8) & 0xff, (v >> 16) & 0xff, (v >> 24) & 0xff]
+			: [(v >> 24) & 0xff, (v >> 16) & 0xff, (v >> 8) & 0xff, v & 0xff];
+
+	return [
+		...(littleEndian ? [0x49, 0x49] : [0x4d, 0x4d]),
+		...u16(42),
+		...u32(8),
+		...u16(1),
+		...u16(tag),
+		...u16(3),
+		...u32(1),
+		// SHORT value sits left justified in the 4 byte value field
+		...u16(value),
+		...u16(0),
+		...u32(0)
+	];
+}
+
+// Wraps a TIFF payload into a complete minimal JPEG data URL
+function buildJpegDataURL(tiff: number[] | null, prependApp0 = false): string {
+	const bytes: number[] = [0xff, 0xd8];
+
+	if (prependApp0) {
+		// JFIF APP0 segment, irrelevant content the parser walks over
+		bytes.push(0xff, 0xe0, 0x00, 0x07, 0x4a, 0x46, 0x49, 0x46, 0x00);
+	}
+
+	if (tiff) {
+		const payload = [0x45, 0x78, 0x69, 0x66, 0x00, 0x00, ...tiff];
+		const length = payload.length + 2;
+		bytes.push(0xff, 0xe1, length >> 8, length & 0xff, ...payload);
+	}
+
+	// SOS marker terminates the metadata scan
+	bytes.push(0xff, 0xda, 0x00, 0x02);
+
+	return `data:image/jpeg;base64,${btoa(String.fromCharCode(...bytes))}`;
+}
+
+describe('getJpegOrientationFromDataURL', () => {
+	it('returns the orientation from a little endian EXIF block', () => {
+		expect(getJpegOrientationFromDataURL(buildJpegDataURL(buildTiff(true, 0x0112, 6)))).toBe(6);
+	});
+
+	it('returns the orientation from a big endian EXIF block', () => {
+		expect(getJpegOrientationFromDataURL(buildJpegDataURL(buildTiff(false, 0x0112, 8)))).toBe(8);
+	});
+
+	it('walks over a leading APP0 segment', () => {
+		expect(getJpegOrientationFromDataURL(buildJpegDataURL(buildTiff(true, 0x0112, 3), true))).toBe(
+			3
+		);
+	});
+
+	it('returns 1 when the EXIF block holds no orientation tag', () => {
+		expect(getJpegOrientationFromDataURL(buildJpegDataURL(buildTiff(true, 0x0100, 6)))).toBe(1);
+	});
+
+	it('returns 1 when the orientation value is out of range', () => {
+		expect(getJpegOrientationFromDataURL(buildJpegDataURL(buildTiff(true, 0x0112, 9)))).toBe(1);
+	});
+
+	it('returns 1 when the JPEG has no APP1 segment', () => {
+		expect(getJpegOrientationFromDataURL(buildJpegDataURL(null, true))).toBe(1);
+	});
+
+	it('returns 1 for a payload that is not a JPEG', () => {
+		const png = btoa(String.fromCharCode(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a));
+		expect(getJpegOrientationFromDataURL(`data:image/png;base64,${png}`)).toBe(1);
+	});
+
+	it('returns 1 for a truncated payload', () => {
+		const truncated = btoa(String.fromCharCode(0xff, 0xd8, 0xff));
+		expect(getJpegOrientationFromDataURL(`data:image/jpeg;base64,${truncated}`)).toBe(1);
+	});
+
+	it('returns 1 for a malformed data URL', () => {
+		expect(getJpegOrientationFromDataURL('not a data url')).toBe(1);
+	});
+});
+
+describe('isJpegMimeType', () => {
+	it('matches both JPEG MIME variants', () => {
+		expect(isJpegMimeType('image/jpeg')).toBe(true);
+		expect(isJpegMimeType('image/jpg')).toBe(true);
+	});
+
+	it('rejects other image MIME types', () => {
+		expect(isJpegMimeType('image/png')).toBe(false);
+		expect(isJpegMimeType('image/webp')).toBe(false);
+	});
+});

tools/ui/tests/unit/latex-protection.test.ts

@@ -0,0 +1,414 @@
+/* eslint-disable no-irregular-whitespace */
+import { describe, it, expect, test } from 'vitest';
+import { maskInlineLaTeX, preprocessLaTeX } from '$lib/utils/latex-protection';
+
+describe('maskInlineLaTeX', () => {
+	it('should protect LaTeX $x + y$ but not money $3.99', () => {
+		const latexExpressions: string[] = [];
+		const input = 'I have $10, $3.99 and $x + y$ and $100x$. The amount is $2,000.';
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe('I have $10, $3.99 and <<LATEX_0>> and <<LATEX_1>>. The amount is $2,000.');
+		expect(latexExpressions).toEqual(['$x + y$', '$100x$']);
+	});
+
+	it('should ignore money like $5 and $12.99', () => {
+		const latexExpressions: string[] = [];
+		const input = 'Prices are $12.99 and $5. Tax?';
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe('Prices are $12.99 and $5. Tax?');
+		expect(latexExpressions).toEqual([]);
+	});
+
+	it('should protect inline math $a^2 + b^2$ even after text', () => {
+		const latexExpressions: string[] = [];
+		const input = 'Pythagorean: $a^2 + b^2 = c^2$.';
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe('Pythagorean: <<LATEX_0>>.');
+		expect(latexExpressions).toEqual(['$a^2 + b^2 = c^2$']);
+	});
+
+	it('should not protect math that has letter after closing $ (e.g. units)', () => {
+		const latexExpressions: string[] = [];
+		const input = 'The cost is $99 and change.';
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe('The cost is $99 and change.');
+		expect(latexExpressions).toEqual([]);
+	});
+
+	it('should allow $x$ followed by punctuation', () => {
+		const latexExpressions: string[] = [];
+		const input = 'We know $x$, right?';
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe('We know <<LATEX_0>>, right?');
+		expect(latexExpressions).toEqual(['$x$']);
+	});
+
+	it('should work across multiple lines', () => {
+		const latexExpressions: string[] = [];
+		const input = `Emma buys cupcakes for $3 each.\nHow much is $x + y$?`;
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe(`Emma buys cupcakes for $3 each.\nHow much is <<LATEX_0>>?`);
+		expect(latexExpressions).toEqual(['$x + y$']);
+	});
+
+	it('should not protect $100 but protect $matrix$', () => {
+		const latexExpressions: string[] = [];
+		const input = '$100 and $\\mathrm{GL}_2(\\mathbb{F}_7)$ are different.';
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe('$100 and <<LATEX_0>> are different.');
+		expect(latexExpressions).toEqual(['$\\mathrm{GL}_2(\\mathbb{F}_7)$']);
+	});
+
+	it('should skip if $ is followed by digit and alphanumeric after close (money)', () => {
+		const latexExpressions: string[] = [];
+		const input = 'I paid $5 quickly.';
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe('I paid $5 quickly.');
+		expect(latexExpressions).toEqual([]);
+	});
+
+	it('should protect LaTeX even with special chars inside', () => {
+		const latexExpressions: string[] = [];
+		const input = 'Consider $\\alpha_1 + \\beta_2$ now.';
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe('Consider <<LATEX_0>> now.');
+		expect(latexExpressions).toEqual(['$\\alpha_1 + \\beta_2$']);
+	});
+
+	it('short text', () => {
+		const latexExpressions: string[] = ['$0$'];
+		const input = '$a$\n$a$ and $b$';
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe('<<LATEX_1>>\n<<LATEX_2>> and <<LATEX_3>>');
+		expect(latexExpressions).toEqual(['$0$', '$a$', '$a$', '$b$']);
+	});
+
+	it('empty text', () => {
+		const latexExpressions: string[] = [];
+		const input = '$\n$$\n';
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe('$\n$$\n');
+		expect(latexExpressions).toEqual([]);
+	});
+
+	it('LaTeX-spacer preceded by backslash', () => {
+		const latexExpressions: string[] = [];
+		const input = `\\[
+\\boxed{
+\\begin{aligned}
+N_{\\text{att}}^{\\text{(MHA)}} &=
+h \\bigl[\\, d_{\\text{model}}\\;d_{k} + d_{\\text{model}}\\;d_{v}\\, \\bigr]   && (\\text{Q,K,V の重み})\\\\
+&\\quad+ h(d_{k}+d_{k}+d_{v})                                          && (\\text{バイアス Q,K,V）}\\\\[4pt]
+&\\quad+ (h d_{v})\\, d_{\\text{model}}                                 && (\\text{出力射影 }W^{O})\\\\
+&\\quad+ d_{\\text{model}}                                            && (\\text{バイアス }b^{O})
+\\end{aligned}}
+\\]`;
+		const output = maskInlineLaTeX(input, latexExpressions);
+
+		expect(output).toBe(input);
+		expect(latexExpressions).toEqual([]);
+	});
+});
+
+describe('preprocessLaTeX', () => {
+	test('converts inline \\( ... \\) to $...$', () => {
+		const input =
+			'\\( \\mathrm{GL}_2(\\mathbb{F}_7) \\): Group of invertible matrices with entries in \\(\\mathbb{F}_7\\).';
+		const output = preprocessLaTeX(input);
+		expect(output).toBe(
+			'$ \\mathrm{GL}_2(\\mathbb{F}_7) $: Group of invertible matrices with entries in $\\mathbb{F}_7$.'
+		);
+	});
+
+	test("don't inline \\\\( ... \\) to $...$", () => {
+		const input =
+			'Chapter 20 of The TeXbook, in source "Definitions\\\\(also called Macros)", containst the formula \\((x_1,\\ldots,x_n)\\).';
+		const output = preprocessLaTeX(input);
+		expect(output).toBe(
+			'Chapter 20 of The TeXbook, in source "Definitions\\\\(also called Macros)", containst the formula $(x_1,\\ldots,x_n)$.'
+		);
+	});
+
+	test('preserves display math \\[ ... \\] and protects adjacent text', () => {
+		const input = `Some kernel of \\(\\mathrm{SL}_2(\\mathbb{F}_7)\\):
+  \\[
+  \\left\\{ \\begin{pmatrix} 1 & 0 \\\\ 0 & 1 \\end{pmatrix}, \\begin{pmatrix} -1 & 0 \\\\ 0 & -1 \\end{pmatrix} \\right\\} = \\{\\pm I\\}
+  \\]`;
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe(`Some kernel of $\\mathrm{SL}_2(\\mathbb{F}_7)$:
+  $$
+  \\left\\{ \\begin{pmatrix} 1 & 0 \\\\ 0 & 1 \\end{pmatrix}, \\begin{pmatrix} -1 & 0 \\\\ 0 & -1 \\end{pmatrix} \\right\\} = \\{\\pm I\\}
+  $$`);
+	});
+
+	test('handles standalone display math equation', () => {
+		const input = `Algebra:
+\\[
+x = \\frac{-b \\pm \\sqrt{\\,b^{2}-4ac\\,}}{2a}
+\\]`;
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe(`Algebra:
+$$
+x = \\frac{-b \\pm \\sqrt{\\,b^{2}-4ac\\,}}{2a}
+$$`);
+	});
+
+	test('does not interpret currency values as LaTeX', () => {
+		const input = 'I have $10, $3.99 and $x + y$ and $100x$. The amount is $2,000.';
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe('I have \\$10, \\$3.99 and $x + y$ and $100x$. The amount is \\$2,000.');
+	});
+
+	test('ignores dollar signs followed by digits (money), but keeps valid math $x + y$', () => {
+		const input = 'I have $10, $3.99 and $x + y$ and $100x$. The amount is $2,000.';
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe('I have \\$10, \\$3.99 and $x + y$ and $100x$. The amount is \\$2,000.');
+	});
+
+	test('handles real-world word problems with amounts and no math delimiters', () => {
+		const input =
+			'Emma buys 2 cupcakes for $3 each and 1 cookie for $1.50. How much money does she spend in total?';
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe(
+			'Emma buys 2 cupcakes for \\$3 each and 1 cookie for \\$1.50. How much money does she spend in total?'
+		);
+	});
+
+	test('handles decimal amounts in word problem correctly', () => {
+		const input =
+			'Maria has $20. She buys a notebook for $4.75 and a pack of pencils for $3.25. How much change does she receive?';
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe(
+			'Maria has \\$20. She buys a notebook for \\$4.75 and a pack of pencils for \\$3.25. How much change does she receive?'
+		);
+	});
+
+	test('preserves display math with surrounding non-ASCII text', () => {
+		const input = `1 kg の質量は
+  \\[
+  E = (1\\ \\text{kg}) \\times (3.0 \\times 10^8\\ \\text{m/s})^2 \\approx 9.0 \\times 10^{16}\\ \\text{J}
+  \\]
+  というエネルギーに相当します。これは約 21 百万トンの TNT が爆発したときのエネルギーに匹敵します。`;
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe(
+			`1 kg の質量は
+  $$
+  E = (1\\ \\text{kg}) \\times (3.0 \\times 10^8\\ \\text{m/s})^2 \\approx 9.0 \\times 10^{16}\\ \\text{J}
+  $$
+  というエネルギーに相当します。これは約 21 百万トンの TNT が爆発したときのエネルギーに匹敵します。`
+		);
+	});
+
+	test('LaTeX-spacer preceded by backslash', () => {
+		const input = `\\[
+\\boxed{
+\\begin{aligned}
+N_{\\text{att}}^{\\text{(MHA)}} &=
+h \\bigl[\\, d_{\\text{model}}\\;d_{k} + d_{\\text{model}}\\;d_{v}\\, \\bigr]   && (\\text{Q,K,V の重み})\\\\
+&\\quad+ h(d_{k}+d_{k}+d_{v})                                          && (\\text{バイアス Q,K,V）}\\\\[4pt]
+&\\quad+ (h d_{v})\\, d_{\\text{model}}                                 && (\\text{出力射影 }W^{O})\\\\
+&\\quad+ d_{\\text{model}}                                            && (\\text{バイアス }b^{O})
+\\end{aligned}}
+\\]`;
+		const output = preprocessLaTeX(input);
+		expect(output).toBe(
+			`$$
+\\boxed{
+\\begin{aligned}
+N_{\\text{att}}^{\\text{(MHA)}} &=
+h \\bigl[\\, d_{\\text{model}}\\;d_{k} + d_{\\text{model}}\\;d_{v}\\, \\bigr]   && (\\text{Q,K,V の重み})\\\\
+&\\quad+ h(d_{k}+d_{k}+d_{v})                                          && (\\text{バイアス Q,K,V）}\\\\[4pt]
+&\\quad+ (h d_{v})\\, d_{\\text{model}}                                 && (\\text{出力射影 }W^{O})\\\\
+&\\quad+ d_{\\text{model}}                                            && (\\text{バイアス }b^{O})
+\\end{aligned}}
+$$`
+		);
+	});
+
+	test('converts \\[ ... \\] even when preceded by text without space', () => {
+		const input = 'Some line ...\nAlgebra: \\[x = \\frac{-b \\pm \\sqrt{\\,b^{2}-4ac\\,}}{2a}\\]';
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe(
+			'Some line ...\nAlgebra: \n$$x = \\frac{-b \\pm \\sqrt{\\,b^{2}-4ac\\,}}{2a}$$\n'
+		);
+	});
+
+	test('converts \\[ ... \\] in table-cells', () => {
+		const input = `| ID | Expression |\n| #1 | \\[
+			x = \\frac{-b \\pm \\sqrt{\\,b^{2}-4ac\\,}}{2a}
+\\] |`;
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe(
+			'| ID | Expression |\n| #1 | $x = \\frac{-b \\pm \\sqrt{\\,b^{2}-4ac\\,}}{2a}$ |'
+		);
+	});
+
+	test('escapes isolated $ before digits ($5 → \\$5), but not valid math', () => {
+		const input = 'This costs $5 and this is math $x^2$. $100 is money.';
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe('This costs \\$5 and this is math $x^2$. \\$100 is money.');
+		// Note: Since $x^2$ is detected as valid LaTeX, it's preserved.
+		// $5 becomes \$5 only *after* real math is masked — but here it's correct because the masking logic avoids treating $5 as math.
+	});
+
+	test('display with LaTeX-line-breaks', () => {
+		const input = String.raw`- Algebraic topology, Homotopy Groups of $\mathbb{S}^3$:
+$$\pi_n(\mathbb{S}^3) = \begin{cases}
+\mathbb{Z} & n = 3 \\
+0 & n > 3, n \neq 4 \\
+\mathbb{Z}_2 & n = 4 \\
+\end{cases}$$`;
+		const output = preprocessLaTeX(input);
+		// If the formula contains '\\' the $$-delimiters should be in their own line.
+		expect(output).toBe(`- Algebraic topology, Homotopy Groups of $\\mathbb{S}^3$:
+$$\n\\pi_n(\\mathbb{S}^3) = \\begin{cases}
+\\mathbb{Z} & n = 3 \\\\
+0 & n > 3, n \\neq 4 \\\\
+\\mathbb{Z}_2 & n = 4 \\\\
+\\end{cases}\n$$`);
+	});
+
+	test('handles mhchem notation safely if present', () => {
+		const input = 'Chemical reaction: \\( \\ce{H2O} \\) and $\\ce{CO2}$';
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe('Chemical reaction: $ \\ce{H2O} $ and $\\ce{CO2}$');
+	});
+
+	test('preserves code blocks', () => {
+		const input = 'Inline code: `sum $total` and block:\n```\ndollar $amount\n```\nEnd.';
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe(input); // Code blocks prevent misinterpretation
+	});
+
+	test('preserves backslash parentheses in code blocks (GitHub issue)', () => {
+		const input = '```python\nfoo = "\\(bar\\)"\n```';
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe(input); // Code blocks should not have LaTeX conversion applied
+	});
+
+	test('preserves backslash brackets in code blocks', () => {
+		const input = '```python\nfoo = "\\[bar\\]"\n```';
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe(input); // Code blocks should not have LaTeX conversion applied
+	});
+
+	test('preserves backslash parentheses in inline code', () => {
+		const input = 'Use `foo = "\\(bar\\)"` in your code.';
+		const output = preprocessLaTeX(input);
+
+		expect(output).toBe(input);
+	});
+
+	test('escape backslash in mchem ce', () => {
+		const input = 'mchem ce:\n$\\ce{2H2(g) + O2(g) -> 2H2O(l)}$';
+		const output = preprocessLaTeX(input);
+
+		// mhchem-escape would insert a backslash here.
+		expect(output).toBe('mchem ce:\n$\\ce{2H2(g) + O2(g) -> 2H2O(l)}$');
+	});
+
+	test('escape backslash in mchem pu', () => {
+		const input = 'mchem pu:\n$\\pu{-572 kJ mol^{-1}}$';
+		const output = preprocessLaTeX(input);
+
+		// mhchem-escape would insert a backslash here.
+		expect(output).toBe('mchem pu:\n$\\pu{-572 kJ mol^{-1}}$');
+	});
+
+	test('LaTeX in blockquotes with display math', () => {
+		const input =
+			'> **Definition (limit):**  \n>  \\[\n>  \\lim_{x\\to a} f(x) = L\n>  \\]\n>  means that as \\(x\\) gets close to \\(a\\).';
+		const output = preprocessLaTeX(input);
+
+		// Blockquote markers should be preserved, LaTeX should be converted
+		expect(output).toContain('> **Definition (limit):**');
+		expect(output).toContain('$$');
+		expect(output).toContain('$x$');
+		expect(output).not.toContain('\\[');
+		expect(output).not.toContain('\\]');
+		expect(output).not.toContain('\\(');
+		expect(output).not.toContain('\\)');
+	});
+
+	test('LaTeX in blockquotes with inline math', () => {
+		const input =
+			"> The derivative \\(f'(x)\\) at point \\(x=a\\) measures slope.\n> Formula: \\(f'(a)=\\lim_{h\\to 0}\\frac{f(a+h)-f(a)}{h}\\)";
+		const output = preprocessLaTeX(input);
+
+		// Blockquote markers should be preserved, inline LaTeX converted to $...$
+		expect(output).toContain("> The derivative $f'(x)$ at point $x=a$ measures slope.");
+		expect(output).toContain("> Formula: $f'(a)=\\lim_{h\\to 0}\\frac{f(a+h)-f(a)}{h}$");
+	});
+
+	test('Mixed content with blockquotes and regular text', () => {
+		const input =
+			'Regular text with \\(x^2\\).\n\n> Quote with \\(y^2\\).\n\nMore text with \\(z^2\\).';
+		const output = preprocessLaTeX(input);
+
+		// All LaTeX should be converted, blockquote markers preserved
+		expect(output).toBe('Regular text with $x^2$.\n\n> Quote with $y^2$.\n\nMore text with $z^2$.');
+	});
+});
+
+// The fast path skips the whole protect/restore pipeline when the content has
+// neither `$` nor a backslash. These pin the assumption it relies on: such
+// content is returned byte-for-byte unchanged, and anything carrying a trigger
+// character still goes through the full pipeline.
+describe('preprocessLaTeX fast path', () => {
+	const untouched = [
+		['plain prose', 'The quick brown fox jumps over the lazy dog.'],
+		['headings and lists', '# Title\n\n- one\n- two\n\n## Sub\n\n1. first\n2. second'],
+		['fenced code without escapes', '```ts\nconst x = 1;\n```'],
+		['inline code and emphasis', 'Use `npm run build` with **bold** and _italic_.'],
+		['blockquotes', '> quoted line\n> another line'],
+		['tables', '| a | b |\n| --- | --- |\n| 1 | 2 |'],
+		['brackets and parens without escapes', 'array[0] and call(arg) and [link](/url)'],
+		['multi-paragraph prose', 'First para.\n\nSecond para.\n\nThird para.']
+	];
+
+	for (const [label, input] of untouched) {
+		test(`returns ${label} unchanged`, () => {
+			expect(preprocessLaTeX(input)).toBe(input);
+		});
+	}
+
+	test('still processes content once a trigger character is present', () => {
+		expect(preprocessLaTeX('inline \\(x^2\\) here')).toBe('inline $x^2$ here');
+		expect(preprocessLaTeX('Price: $5')).toBe('Price: \\$5');
+	});
+
+	test('fast path result matches the full pipeline for trigger-free content', () => {
+		// Appending a trigger char forces the slow path; stripping it back off
+		// must agree with what the fast path returned for the same prefix.
+		const body = 'Plain paragraph with no math.\n\nAnother paragraph here.';
+		const viaFastPath = preprocessLaTeX(body);
+		const viaFullPipeline = preprocessLaTeX(`${body}\n\n\\(z\\)`);
+
+		expect(viaFullPipeline.startsWith(viaFastPath)).toBe(true);
+	});
+});

tools/ui/tests/unit/mcp-default-overrides-merge.test.ts

@@ -0,0 +1,158 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { STORAGE_APP_NAME, CONFIG_LOCALSTORAGE_KEY } from '$lib/constants';
+
+// node env unit project has no DOM, install a minimal localStorage backed by a Map
+beforeAll(() => {
+	const store = new Map<string, string>();
+	const polyfill: Storage = {
+		get length() {
+			return store.size;
+		},
+		clear: () => store.clear(),
+		getItem: (k) => (store.has(k) ? store.get(k)! : null),
+		key: (i) => Array.from(store.keys())[i] ?? null,
+		removeItem: (k) => {
+			store.delete(k);
+		},
+		setItem: (k, v) => {
+			store.set(k, String(v));
+		}
+	};
+	(globalThis as unknown as { localStorage: Storage }).localStorage = polyfill;
+});
+
+/**
+ * Migration `mcp-default-overrides-merge-v1` folds the values of the parallel
+ * `mcpDefaultServerOverrides` config entry onto `mcpServers[i].enabled` (the
+ * single source of truth for new-chat defaults). The legacy key is kept on
+ * disk for downgrade compatibility.
+ */
+describe('mcp-default-overrides-merge-v1 migration', () => {
+	const MIGRATION_STATE_KEY = `${STORAGE_APP_NAME}.migration-state`;
+	const MCP_DEFAULT_OVERRIDES_KEY = `${STORAGE_APP_NAME}.mcpDefaultServerOverrides`;
+
+	beforeEach(async () => {
+		localStorage.clear();
+		// Reset the migration run counter so `runAllMigrations` is guaranteed to execute.
+		await import('$lib/services/migration.service').then((mod) =>
+			mod.MigrationService.resetState()
+		);
+	});
+
+	afterEach(() => {
+		localStorage.clear();
+	});
+
+	async function runMigrations() {
+		const { MigrationService } = await import('$lib/services/migration.service');
+		await MigrationService.runAllMigrations();
+	}
+
+	function readConfig(): Record<string, unknown> {
+		const raw = localStorage.getItem(CONFIG_LOCALSTORAGE_KEY);
+
+		return raw ? (JSON.parse(raw) as Record<string, unknown>) : {};
+	}
+
+	function writeConfig(config: Record<string, unknown>) {
+		localStorage.setItem(CONFIG_LOCALSTORAGE_KEY, JSON.stringify(config));
+	}
+
+	it('applies matching overrides onto mcpServers[i].enabled and preserves the legacy key', async () => {
+		writeConfig({
+			mcpServers: JSON.stringify([
+				{ id: 'exa', enabled: false, url: 'https://mcp.exa.ai/mcp' },
+				{ id: 'hf', enabled: false, url: 'https://huggingface.co/mcp' }
+			]),
+			[MCP_DEFAULT_OVERRIDES_KEY]: JSON.stringify([
+				{ serverId: 'exa', enabled: true },
+				{ serverId: 'hf', enabled: false }
+			])
+		});
+
+		await runMigrations();
+
+		const after = readConfig();
+		const servers = JSON.parse(after.mcpServers as string) as Array<{
+			id: string;
+			enabled: boolean;
+		}>;
+
+		expect(servers.find((s) => s.id === 'exa')?.enabled).toBe(true);
+		expect(servers.find((s) => s.id === 'hf')?.enabled).toBe(false);
+		expect(MCP_DEFAULT_OVERRIDES_KEY in after).toBe(true);
+	});
+
+	it('skips override ids that do not match any configured server', async () => {
+		writeConfig({
+			mcpServers: JSON.stringify([{ id: 'exa', enabled: false, url: 'https://mcp.exa.ai/mcp' }]),
+			[MCP_DEFAULT_OVERRIDES_KEY]: JSON.stringify([
+				{ serverId: 'orphan', enabled: true },
+				{ serverId: 'exa', enabled: true }
+			])
+		});
+
+		await runMigrations();
+
+		const after = readConfig();
+		const servers = JSON.parse(after.mcpServers as string) as Array<{
+			id: string;
+			enabled: boolean;
+		}>;
+
+		expect(servers).toHaveLength(1);
+		expect(servers[0].enabled).toBe(true);
+		expect(MCP_DEFAULT_OVERRIDES_KEY in after).toBe(true);
+	});
+
+	it('is a no-op when there are no legacy overrides', async () => {
+		writeConfig({
+			mcpServers: JSON.stringify([{ id: 'exa', enabled: true, url: 'https://mcp.exa.ai/mcp' }])
+		});
+
+		await runMigrations();
+
+		const after = readConfig();
+		const servers = JSON.parse(after.mcpServers as string) as Array<{
+			id: string;
+			enabled: boolean;
+		}>;
+
+		expect(servers[0].enabled).toBe(true);
+		expect(MCP_DEFAULT_OVERRIDES_KEY in after).toBe(false);
+	});
+
+	it('does not rewrite mcpServers when override.enabled already matches', async () => {
+		const originalServers = JSON.stringify([
+			{ id: 'exa', enabled: true, url: 'https://mcp.exa.ai/mcp' }
+		]);
+
+		writeConfig({
+			mcpServers: originalServers,
+			[MCP_DEFAULT_OVERRIDES_KEY]: JSON.stringify([{ serverId: 'exa', enabled: true }])
+		});
+
+		await runMigrations();
+
+		const after = readConfig();
+		expect(after.mcpServers).toBe(originalServers);
+		expect(MCP_DEFAULT_OVERRIDES_KEY in after).toBe(true);
+	});
+
+	it('records itself as completed so subsequent loads do not re-run', async () => {
+		writeConfig({
+			mcpServers: JSON.stringify([{ id: 'exa', enabled: false, url: 'https://mcp.exa.ai/mcp' }]),
+			[MCP_DEFAULT_OVERRIDES_KEY]: JSON.stringify([{ serverId: 'exa', enabled: true }])
+		});
+
+		const { MigrationService } = await import('$lib/services/migration.service');
+
+		await MigrationService.runAllMigrations();
+
+		const stateRaw = localStorage.getItem(MIGRATION_STATE_KEY);
+		expect(stateRaw).not.toBeNull();
+		const state = JSON.parse(stateRaw!) as { completed: string[]; failed: string[] };
+		expect(state.completed).toContain('mcp-default-overrides-merge-v1');
+		expect(state.failed).not.toContain('mcp-default-overrides-merge-v1');
+	});
+});

tools/ui/tests/unit/mcp-override-fallback.test.ts

@@ -0,0 +1,143 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { CONFIG_LOCALSTORAGE_KEY } from '$lib/constants';
+import { SETTINGS_KEYS } from '$lib/constants/settings-keys';
+import type { DatabaseConversation } from '$lib/types/database';
+
+// node env unit project has no DOM, install a minimal localStorage backed by a Map
+beforeAll(() => {
+	const store = new Map<string, string>();
+	const polyfill: Storage = {
+		get length() {
+			return store.size;
+		},
+		clear: () => store.clear(),
+		getItem: (k) => (store.has(k) ? store.get(k)! : null),
+		key: (i) => Array.from(store.keys())[i] ?? null,
+		removeItem: (k) => {
+			store.delete(k);
+		},
+		setItem: (k, v) => {
+			store.set(k, String(v));
+		}
+	};
+	(globalThis as unknown as { localStorage: Storage }).localStorage = polyfill;
+});
+
+/**
+ * Regression coverage for the bug where MCP servers flipped to "disabled"
+ * after sending the first message on a fresh chat (see comment in
+ * `MCPStore.createConversation`: empty `mcpServerOverrides` should inherit
+ * `mcpServers[i].enabled`, not be treated as all-off).
+ */
+describe('conversationsStore MCP override resolution', () => {
+	beforeEach(async () => {
+		localStorage.clear();
+		// Two configured servers: alpha is globally disabled, bravo enabled.
+		localStorage.setItem(
+			CONFIG_LOCALSTORAGE_KEY,
+			JSON.stringify({
+				[SETTINGS_KEYS.MCP_SERVERS]: JSON.stringify([
+					{ id: 'alpha', enabled: false, url: 'https://alpha.example.com/mcp' },
+					{ id: 'bravo', enabled: true, url: 'https://bravo.example.com/mcp' }
+				])
+			})
+		);
+
+		// The settings store constructor bails in node env (no `browser`),
+		// so seed the config directly. The shape mirrors what `loadConfig`
+		// would build from localStorage.
+		const { settingsStore } = await import('$lib/stores/settings.svelte');
+		const raw = localStorage.getItem(CONFIG_LOCALSTORAGE_KEY) ?? '{}';
+		const saved = JSON.parse(raw) as Record<string, unknown>;
+		settingsStore.config = {
+			...settingsStore.config,
+			[SETTINGS_KEYS.MCP_SERVERS]: saved[SETTINGS_KEYS.MCP_SERVERS]
+		};
+	});
+
+	afterEach(() => {
+		localStorage.clear();
+	});
+
+	function makeConversation(
+		overrides?: { serverId: string; enabled: boolean }[]
+	): DatabaseConversation {
+		return {
+			id: 'conv-1',
+			currNode: null,
+			lastModified: 0,
+			name: 'Test chat',
+			mcpServerOverrides: overrides
+		};
+	}
+
+	it('inherits server.enabled when no conversation is active', async () => {
+		const { conversationsStore } = await import('$lib/stores/conversations.svelte');
+		conversationsStore.activeConversation = null;
+
+		expect(conversationsStore.isMcpServerEnabledForChat('alpha')).toBe(false);
+		expect(conversationsStore.isMcpServerEnabledForChat('bravo')).toBe(true);
+	});
+
+	it('inherits server.enabled on a newly created chat with no overrides', async () => {
+		const { conversationsStore } = await import('$lib/stores/conversations.svelte');
+		conversationsStore.activeConversation = makeConversation();
+
+		// Empty override list: must fall back to global server.enabled, not all-off.
+		expect(conversationsStore.isMcpServerEnabledForChat('alpha')).toBe(false);
+		expect(conversationsStore.isMcpServerEnabledForChat('bravo')).toBe(true);
+	});
+
+	it('inherits server.enabled on a newly created chat when overrides is undefined', async () => {
+		const { conversationsStore } = await import('$lib/stores/conversations.svelte');
+		conversationsStore.activeConversation = makeConversation(undefined);
+
+		expect(conversationsStore.isMcpServerEnabledForChat('alpha')).toBe(false);
+		expect(conversationsStore.isMcpServerEnabledForChat('bravo')).toBe(true);
+	});
+
+	it('uses explicit per-chat overrides, with defaults for non-overridden servers', async () => {
+		const { conversationsStore } = await import('$lib/stores/conversations.svelte');
+		// Override flips bravo off for this chat, alpha keeps its global default.
+		conversationsStore.activeConversation = makeConversation([
+			{ serverId: 'bravo', enabled: false }
+		]);
+
+		expect(conversationsStore.isMcpServerEnabledForChat('alpha')).toBe(false);
+		expect(conversationsStore.isMcpServerEnabledForChat('bravo')).toBe(false);
+	});
+
+	it('getAllMcpServerOverrides returns a complete list merged from defaults', async () => {
+		const { conversationsStore } = await import('$lib/stores/conversations.svelte');
+		conversationsStore.activeConversation = makeConversation([
+			{ serverId: 'alpha', enabled: true }
+		]);
+
+		expect(conversationsStore.getAllMcpServerOverrides()).toEqual([
+			{ serverId: 'alpha', enabled: true },
+			{ serverId: 'bravo', enabled: true }
+		]);
+	});
+
+	it('getAllMcpServerOverrides falls back to defaults when there are no explicit overrides', async () => {
+		const { conversationsStore } = await import('$lib/stores/conversations.svelte');
+		conversationsStore.activeConversation = makeConversation();
+
+		expect(conversationsStore.getAllMcpServerOverrides()).toEqual([
+			{ serverId: 'alpha', enabled: false },
+			{ serverId: 'bravo', enabled: true }
+		]);
+	});
+
+	it('getMcpServerOverride returns the global default when the server has no explicit override', async () => {
+		const { conversationsStore } = await import('$lib/stores/conversations.svelte');
+		conversationsStore.activeConversation = makeConversation([
+			{ serverId: 'alpha', enabled: true }
+		]);
+
+		expect(conversationsStore.getMcpServerOverride('bravo')).toEqual({
+			serverId: 'bravo',
+			enabled: true
+		});
+	});
+});

tools/ui/tests/unit/mcp-servers-default.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { SETTINGS_KEYS } from '$lib/constants/settings-keys';
+
+/**
+ * Default-value policy for the `MCP_SERVERS` setting.
+ *
+ * Earlier versions of the UI preloaded a hard-coded list of suggested
+ * MCP servers into this setting on first install. That caused silent
+ * third-party HTTP requests at app load (see issue #25509) and a popup
+ * "recommendation" dialog (see issue #25274). New users must now opt
+ * in explicitly when adding a server, so the default is an empty list.
+ */
+describe('MCP_SERVERS default value', () => {
+	it('does not preload any servers in the MCP_SERVERS setting default', async () => {
+		const { SETTING_CONFIG_DEFAULT } = await import('$lib/constants/settings-registry');
+
+		expect(SETTING_CONFIG_DEFAULT[SETTINGS_KEYS.MCP_SERVERS]).toBe('[]');
+	}, 15000);
+});

tools/ui/tests/unit/mcp-service.test.ts

@@ -0,0 +1,338 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { Client } from '@modelcontextprotocol/sdk/client';
+import { MCPService } from '$lib/services/mcp.service';
+import { MCPConnectionPhase, MCPTransportType } from '$lib/enums';
+import type { MCPConnectionLog, MCPServerConfig } from '$lib/types';
+import { CORS_PROXY_HEADER_PREFIX } from '$lib/constants';
+
+type DiagnosticFetchFactory = (
+	serverName: string,
+	config: MCPServerConfig,
+	baseInit: RequestInit,
+	targetUrl: URL,
+	useProxy: boolean,
+	onLog?: (log: MCPConnectionLog) => void
+) => { fetch: typeof fetch; disable: () => void };
+
+const createDiagnosticFetch = (
+	config: MCPServerConfig,
+	onLog?: (log: MCPConnectionLog) => void,
+	baseInit: RequestInit = {},
+	useProxy = false
+) =>
+	(
+		MCPService as unknown as { createDiagnosticFetch: DiagnosticFetchFactory }
+	).createDiagnosticFetch('test-server', config, baseInit, new URL(config.url), useProxy, onLog);
+
+describe('MCPService', () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+		vi.unstubAllGlobals();
+	});
+
+	it('stops transport phase logging after handshake diagnostics are disabled', async () => {
+		const logs: MCPConnectionLog[] = [];
+		const response = new Response('{}', {
+			status: 200,
+			headers: { 'content-type': 'application/json' }
+		});
+
+		vi.stubGlobal('fetch', vi.fn().mockResolvedValue(response));
+
+		const config: MCPServerConfig = {
+			url: 'https://example.com/mcp',
+			transport: MCPTransportType.STREAMABLE_HTTP
+		};
+
+		const controller = createDiagnosticFetch(config, (log) => logs.push(log));
+
+		await controller.fetch(config.url, { method: 'POST', body: '{}' });
+		expect(logs).toHaveLength(2);
+		expect(logs.every((log) => log.message.includes('https://example.com/mcp'))).toBe(true);
+
+		controller.disable();
+		await controller.fetch(config.url, { method: 'POST', body: '{}' });
+
+		expect(logs).toHaveLength(2);
+	});
+
+	it('redacts all configured custom headers in diagnostic request logs', async () => {
+		const logs: MCPConnectionLog[] = [];
+		const response = new Response('{}', {
+			status: 200,
+			headers: { 'content-type': 'application/json' }
+		});
+
+		vi.stubGlobal('fetch', vi.fn().mockResolvedValue(response));
+
+		const config: MCPServerConfig = {
+			url: 'https://example.com/mcp',
+			transport: MCPTransportType.STREAMABLE_HTTP,
+			headers: {
+				'x-auth-token': 'secret-token',
+				'x-vendor-api-key': 'secret-key'
+			}
+		};
+
+		const controller = createDiagnosticFetch(config, (log) => logs.push(log), {
+			headers: config.headers
+		});
+
+		await controller.fetch(config.url, {
+			method: 'POST',
+			headers: { 'content-type': 'application/json' },
+			body: '{}'
+		});
+
+		expect(logs).toHaveLength(2);
+		expect(logs[0].details).toMatchObject({
+			request: {
+				headers: {
+					'x-auth-token': '[redacted]',
+					'x-vendor-api-key': '[redacted]',
+					'content-type': 'application/json'
+				}
+			}
+		});
+	});
+
+	it('wraps dynamic request headers when using the CORS proxy', async () => {
+		const logs: MCPConnectionLog[] = [];
+		const proxiedAuthToken = `${CORS_PROXY_HEADER_PREFIX}x-auth-token`;
+		const proxiedContentType = `${CORS_PROXY_HEADER_PREFIX}content-type`;
+		const proxiedSessionId = `${CORS_PROXY_HEADER_PREFIX}mcp-session-id`;
+		const response = new Response('{}', {
+			status: 200,
+			headers: { 'content-type': 'application/json' }
+		});
+		const fetchMock = vi.fn().mockResolvedValue(response);
+
+		vi.stubGlobal('fetch', fetchMock);
+
+		const config: MCPServerConfig = {
+			url: 'https://example.com/mcp',
+			transport: MCPTransportType.STREAMABLE_HTTP,
+			useProxy: true
+		};
+
+		const controller = createDiagnosticFetch(
+			config,
+			(log) => logs.push(log),
+			{
+				headers: {
+					authorization: 'Bearer llama-server-key',
+					[proxiedAuthToken]: 'target-token'
+				}
+			},
+			true
+		);
+
+		await controller.fetch('http://localhost:8080/cors-proxy?url=https%3A%2F%2Fexample.com%2Fmcp', {
+			method: 'POST',
+			headers: {
+				'content-type': 'application/json',
+				'mcp-session-id': 'session-request-12345'
+			},
+			body: '{}'
+		});
+
+		const sentHeaders = fetchMock.mock.calls[0]?.[1]?.headers as Headers;
+		expect(sentHeaders.get('authorization')).toBe('Bearer llama-server-key');
+		expect(sentHeaders.get(proxiedAuthToken)).toBe('target-token');
+		expect(sentHeaders.get(proxiedContentType)).toBe('application/json');
+		expect(sentHeaders.get(proxiedSessionId)).toBe('session-request-12345');
+		expect(sentHeaders.has('content-type')).toBe(false);
+		expect(sentHeaders.has('mcp-session-id')).toBe(false);
+		expect(logs[0].details).toMatchObject({
+			request: {
+				headers: {
+					authorization: '[redacted]',
+					[proxiedAuthToken]: '[redacted]',
+					[proxiedSessionId]: '....12345'
+				}
+			}
+		});
+	});
+
+	it('DELETE request with CORS proxy should return a fake 200 response', async () => {
+		const logs: MCPConnectionLog[] = [];
+		const fetchMock = vi.fn();
+
+		vi.stubGlobal('fetch', fetchMock);
+
+		const config: MCPServerConfig = {
+			url: 'https://example.com/mcp',
+			transport: MCPTransportType.STREAMABLE_HTTP,
+			useProxy: true
+		};
+
+		const controller = createDiagnosticFetch(config, (log) => logs.push(log), {}, true);
+
+		const response = await controller.fetch(
+			'http://localhost:8080/cors-proxy?url=https%3A%2F%2Fexample.com%2Fmcp',
+			{ method: 'DELETE' }
+		);
+
+		expect(fetchMock).not.toHaveBeenCalled();
+		expect(response.status).toBe(200);
+		expect(logs.at(-1)?.details).toMatchObject({
+			response: { status: 200, isFake: true }
+		});
+	});
+
+	it('partially redacts mcp-session-id in diagnostic request and response logs', async () => {
+		const logs: MCPConnectionLog[] = [];
+		const response = new Response('{}', {
+			status: 200,
+			headers: {
+				'content-type': 'application/json',
+				'mcp-session-id': 'session-response-67890'
+			}
+		});
+
+		vi.stubGlobal('fetch', vi.fn().mockResolvedValue(response));
+
+		const config: MCPServerConfig = {
+			url: 'https://example.com/mcp',
+			transport: MCPTransportType.STREAMABLE_HTTP
+		};
+
+		const controller = createDiagnosticFetch(config, (log) => logs.push(log));
+
+		await controller.fetch(config.url, {
+			method: 'POST',
+			headers: {
+				'content-type': 'application/json',
+				'mcp-session-id': 'session-request-12345'
+			},
+			body: '{}'
+		});
+
+		expect(logs).toHaveLength(2);
+		expect(logs[0].details).toMatchObject({
+			request: {
+				headers: {
+					'content-type': 'application/json',
+					'mcp-session-id': '....12345'
+				}
+			}
+		});
+		expect(logs[1].details).toMatchObject({
+			response: {
+				headers: {
+					'content-type': 'application/json',
+					'mcp-session-id': '....67890'
+				}
+			}
+		});
+	});
+
+	it('extracts JSON-RPC methods without logging the raw request body', async () => {
+		const logs: MCPConnectionLog[] = [];
+		const response = new Response('{}', {
+			status: 200,
+			headers: { 'content-type': 'application/json' }
+		});
+
+		vi.stubGlobal('fetch', vi.fn().mockResolvedValue(response));
+
+		const config: MCPServerConfig = {
+			url: 'https://example.com/mcp',
+			transport: MCPTransportType.STREAMABLE_HTTP
+		};
+
+		const controller = createDiagnosticFetch(config, (log) => logs.push(log));
+
+		await controller.fetch(config.url, {
+			method: 'POST',
+			body: JSON.stringify([
+				{ jsonrpc: '2.0', id: 1, method: 'initialize' },
+				{ jsonrpc: '2.0', method: 'notifications/initialized' }
+			])
+		});
+
+		expect(logs[0].details).toMatchObject({
+			request: {
+				method: 'POST',
+				body: {
+					kind: 'string',
+					size: expect.any(Number)
+				},
+				jsonRpcMethods: ['initialize', 'notifications/initialized']
+			}
+		});
+	});
+
+	it('adds a CORS hint to Failed to fetch diagnostic log messages', async () => {
+		const logs: MCPConnectionLog[] = [];
+		const fetchError = new TypeError('Failed to fetch');
+
+		vi.stubGlobal('fetch', vi.fn().mockRejectedValue(fetchError));
+
+		const config: MCPServerConfig = {
+			url: 'http://localhost:8000/mcp',
+			transport: MCPTransportType.STREAMABLE_HTTP
+		};
+
+		const controller = createDiagnosticFetch(config, (log) => logs.push(log));
+
+		await expect(controller.fetch(config.url, { method: 'POST', body: '{}' })).rejects.toThrow(
+			'Failed to fetch'
+		);
+
+		expect(logs).toHaveLength(2);
+		expect(logs[1].message).toBe(
+			'HTTP POST http://localhost:8000/mcp failed: Failed to fetch (check CORS?)'
+		);
+	});
+
+	it('detaches phase error logging after the initialize handshake completes', async () => {
+		const phaseLogs: Array<{ phase: MCPConnectionPhase; log: MCPConnectionLog }> = [];
+		const stopPhaseLogging = vi.fn();
+		let emitClientError: ((error: Error) => void) | undefined;
+
+		vi.spyOn(MCPService, 'createTransport').mockReturnValue({
+			transport: {} as never,
+			type: MCPTransportType.WEBSOCKET,
+			stopPhaseLogging
+		});
+		vi.spyOn(MCPService, 'listTools').mockResolvedValue([]);
+		vi.spyOn(Client.prototype, 'getServerVersion').mockReturnValue(undefined);
+		vi.spyOn(Client.prototype, 'getServerCapabilities').mockReturnValue(undefined);
+		vi.spyOn(Client.prototype, 'getInstructions').mockReturnValue(undefined);
+		vi.spyOn(Client.prototype, 'connect').mockImplementation(async function (this: Client) {
+			emitClientError = (error: Error) => this.onerror?.(error);
+			this.onerror?.(new Error('handshake protocol error'));
+		});
+
+		await MCPService.connect(
+			'test-server',
+			{
+				url: 'ws://example.com/mcp',
+				transport: MCPTransportType.WEBSOCKET
+			},
+			undefined,
+			undefined,
+			(phase, log) => phaseLogs.push({ phase, log })
+		);
+
+		expect(stopPhaseLogging).toHaveBeenCalledTimes(1);
+		expect(
+			phaseLogs.filter(
+				({ phase, log }) =>
+					phase === MCPConnectionPhase.ERROR &&
+					log.message === 'Protocol error: handshake protocol error'
+			)
+		).toHaveLength(1);
+
+		emitClientError?.(new Error('runtime protocol error'));
+
+		expect(
+			phaseLogs.filter(
+				({ phase, log }) =>
+					phase === MCPConnectionPhase.ERROR &&
+					log.message === 'Protocol error: runtime protocol error'
+			)
+		).toHaveLength(0);
+	});
+});

tools/ui/tests/unit/model-id-parser.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, it } from 'vitest';
+import { ModelsService } from '$lib/services/models.service';
+
+const { parseModelId } = ModelsService;
+
+describe('parseModelId', () => {
+	it('handles unknown patterns correctly', () => {
+		expect(parseModelId('model-name-1')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'model-name-1',
+			orgName: null,
+			params: null,
+			quantization: null,
+			raw: 'model-name-1',
+			tags: []
+		});
+
+		expect(parseModelId('org/model-name-2')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'model-name-2',
+			orgName: 'org',
+			params: null,
+			quantization: null,
+			raw: 'org/model-name-2',
+			tags: []
+		});
+	});
+
+	it('extracts model parameters correctly', () => {
+		expect(parseModelId('model-100B-BF16')).toMatchObject({ params: '100B' });
+		expect(parseModelId('model-100B:Q4_K_M')).toMatchObject({ params: '100B' });
+	});
+
+	it('extracts model parameters correctly in lowercase', () => {
+		expect(parseModelId('model-100b-bf16')).toMatchObject({ params: '100B' });
+		expect(parseModelId('model-100b:q4_k_m')).toMatchObject({ params: '100B' });
+	});
+
+	it('extracts effective parameters correctly', () => {
+		expect(parseModelId('model-E4B-BF16')).toMatchObject({ params: 'E4B' });
+		expect(parseModelId('model-e2b:q4_k_m')).toMatchObject({ params: 'E2B' });
+	});
+
+	it('extracts activated parameters correctly', () => {
+		expect(parseModelId('model-100B-A10B-BF16')).toMatchObject({ activatedParams: 'A10B' });
+		expect(parseModelId('model-100B-A10B:Q4_K_M')).toMatchObject({ activatedParams: 'A10B' });
+	});
+
+	it('extracts activated parameters correctly in lowercase', () => {
+		expect(parseModelId('model-100b-a10b-bf16')).toMatchObject({ activatedParams: 'A10B' });
+		expect(parseModelId('model-100b-a10b:q4_k_m')).toMatchObject({ activatedParams: 'A10B' });
+	});
+
+	it('extracts quantization correctly', () => {
+		// Dash-separated quantization
+		expect(parseModelId('model-100B-UD-IQ1_S')).toMatchObject({ quantization: 'UD-IQ1_S' });
+		expect(parseModelId('model-100B-IQ4_XS')).toMatchObject({ quantization: 'IQ4_XS' });
+		expect(parseModelId('model-100B-Q4_K_M')).toMatchObject({ quantization: 'Q4_K_M' });
+		expect(parseModelId('model-100B-Q8_0')).toMatchObject({ quantization: 'Q8_0' });
+		expect(parseModelId('model-100B-UD-Q8_K_XL')).toMatchObject({ quantization: 'UD-Q8_K_XL' });
+		expect(parseModelId('model-100B-F16')).toMatchObject({ quantization: 'F16' });
+		expect(parseModelId('model-100B-BF16')).toMatchObject({ quantization: 'BF16' });
+		expect(parseModelId('model-100B-MXFP4')).toMatchObject({ quantization: 'MXFP4' });
+
+		// Colon-separated quantization
+		expect(parseModelId('model-100B:UD-IQ1_S')).toMatchObject({ quantization: 'UD-IQ1_S' });
+		expect(parseModelId('model-100B:IQ4_XS')).toMatchObject({ quantization: 'IQ4_XS' });
+		expect(parseModelId('model-100B:Q4_K_M')).toMatchObject({ quantization: 'Q4_K_M' });
+		expect(parseModelId('model-100B:Q8_0')).toMatchObject({ quantization: 'Q8_0' });
+		expect(parseModelId('model-100B:UD-Q8_K_XL')).toMatchObject({ quantization: 'UD-Q8_K_XL' });
+		expect(parseModelId('model-100B:F16')).toMatchObject({ quantization: 'F16' });
+		expect(parseModelId('model-100B:BF16')).toMatchObject({ quantization: 'BF16' });
+		expect(parseModelId('model-100B:MXFP4')).toMatchObject({ quantization: 'MXFP4' });
+
+		// Dot-separated quantization
+		expect(parseModelId('nomic-embed-text-v2-moe.Q4_K_M')).toMatchObject({
+			quantization: 'Q4_K_M'
+		});
+	});
+
+	it('extracts additional tags correctly', () => {
+		expect(parseModelId('model-100B-foobar-Q4_K_M')).toMatchObject({ tags: ['foobar'] });
+		expect(parseModelId('model-100B-A10B-foobar-1M-BF16')).toMatchObject({
+			tags: ['foobar', '1M']
+		});
+		expect(parseModelId('model-100B-1M-foobar:UD-Q8_K_XL')).toMatchObject({
+			tags: ['1M', 'foobar']
+		});
+	});
+
+	it('filters out container format segments from tags', () => {
+		expect(parseModelId('model-100B-GGUF-Instruct-BF16')).toMatchObject({
+			tags: ['Instruct']
+		});
+		expect(parseModelId('model-100B-GGML-Instruct:Q4_K_M')).toMatchObject({
+			tags: ['Instruct']
+		});
+	});
+
+	it('handles real-world examples correctly', () => {
+		expect(parseModelId('meta-llama/Llama-3.1-8B')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'Llama-3.1',
+			orgName: 'meta-llama',
+			params: '8B',
+			quantization: null,
+			raw: 'meta-llama/Llama-3.1-8B',
+			tags: []
+		});
+
+		expect(parseModelId('openai/gpt-oss-120b-MXFP4')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'gpt-oss',
+			orgName: 'openai',
+			params: '120B',
+			quantization: 'MXFP4',
+			raw: 'openai/gpt-oss-120b-MXFP4',
+			tags: []
+		});
+
+		expect(parseModelId('openai/gpt-oss-20b:Q4_K_M')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'gpt-oss',
+			orgName: 'openai',
+			params: '20B',
+			quantization: 'Q4_K_M',
+			raw: 'openai/gpt-oss-20b:Q4_K_M',
+			tags: []
+		});
+
+		expect(parseModelId('Qwen/Qwen3-Coder-30B-A3B-Instruct-1M-BF16')).toStrictEqual({
+			activatedParams: 'A3B',
+			modelName: 'Qwen3-Coder',
+			orgName: 'Qwen',
+			params: '30B',
+			quantization: 'BF16',
+			raw: 'Qwen/Qwen3-Coder-30B-A3B-Instruct-1M-BF16',
+			tags: ['Instruct', '1M']
+		});
+	});
+
+	it('handles real-world examples with quantization in segments', () => {
+		expect(parseModelId('meta-llama/Llama-4-Scout-17B-16E-Instruct-Q4_K_M')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'Llama-4-Scout',
+			orgName: 'meta-llama',
+			params: '17B',
+			quantization: 'Q4_K_M',
+			raw: 'meta-llama/Llama-4-Scout-17B-16E-Instruct-Q4_K_M',
+			tags: ['16E', 'Instruct']
+		});
+
+		expect(parseModelId('MiniMaxAI/MiniMax-M2-IQ4_XS')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'MiniMax-M2',
+			orgName: 'MiniMaxAI',
+			params: null,
+			quantization: 'IQ4_XS',
+			raw: 'MiniMaxAI/MiniMax-M2-IQ4_XS',
+			tags: []
+		});
+
+		expect(parseModelId('MiniMaxAI/MiniMax-M2-UD-Q3_K_XL')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'MiniMax-M2',
+			orgName: 'MiniMaxAI',
+			params: null,
+			quantization: 'UD-Q3_K_XL',
+			raw: 'MiniMaxAI/MiniMax-M2-UD-Q3_K_XL',
+			tags: []
+		});
+
+		expect(parseModelId('mistralai/Devstral-2-123B-Instruct-2512-Q4_K_M')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'Devstral-2',
+			orgName: 'mistralai',
+			params: '123B',
+			quantization: 'Q4_K_M',
+			raw: 'mistralai/Devstral-2-123B-Instruct-2512-Q4_K_M',
+			tags: ['Instruct', '2512']
+		});
+
+		expect(parseModelId('mistralai/Devstral-Small-2-24B-Instruct-2512-Q8_0')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'Devstral-Small-2',
+			orgName: 'mistralai',
+			params: '24B',
+			quantization: 'Q8_0',
+			raw: 'mistralai/Devstral-Small-2-24B-Instruct-2512-Q8_0',
+			tags: ['Instruct', '2512']
+		});
+
+		expect(parseModelId('noctrex/GLM-4.7-Flash-MXFP4_MOE')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'GLM-4.7-Flash',
+			orgName: 'noctrex',
+			params: null,
+			quantization: 'MXFP4_MOE',
+			raw: 'noctrex/GLM-4.7-Flash-MXFP4_MOE',
+			tags: []
+		});
+
+		expect(parseModelId('Qwen/Qwen3-Coder-Next-Q4_K_M')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'Qwen3-Coder-Next',
+			orgName: 'Qwen',
+			params: null,
+			quantization: 'Q4_K_M',
+			raw: 'Qwen/Qwen3-Coder-Next-Q4_K_M',
+			tags: []
+		});
+
+		expect(parseModelId('openai/gpt-oss-120b-Q4_K_M')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'gpt-oss',
+			orgName: 'openai',
+			params: '120B',
+			quantization: 'Q4_K_M',
+			raw: 'openai/gpt-oss-120b-Q4_K_M',
+			tags: []
+		});
+
+		expect(parseModelId('openai/gpt-oss-20b-F16')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'gpt-oss',
+			orgName: 'openai',
+			params: '20B',
+			quantization: 'F16',
+			raw: 'openai/gpt-oss-20b-F16',
+			tags: []
+		});
+
+		expect(parseModelId('nomic-embed-text-v2-moe.Q4_K_M')).toStrictEqual({
+			activatedParams: null,
+			modelName: 'nomic-embed-text-v2-moe',
+			orgName: null,
+			params: null,
+			quantization: 'Q4_K_M',
+			raw: 'nomic-embed-text-v2-moe.Q4_K_M',
+			tags: []
+		});
+	});
+
+	it('handles ambiguous model names', () => {
+		// Qwen3.5 Instruct vs Thinking — tags should distinguish them
+		expect(parseModelId('Qwen/Qwen3.5-30B-A3B-Instruct')).toMatchObject({
+			modelName: 'Qwen3.5',
+			params: '30B',
+			activatedParams: 'A3B',
+			tags: ['Instruct']
+		});
+
+		expect(parseModelId('Qwen/Qwen3.5-30B-A3B-Thinking')).toMatchObject({
+			modelName: 'Qwen3.5',
+			params: '30B',
+			activatedParams: 'A3B',
+			tags: ['Thinking']
+		});
+
+		// Dot-separated quantization with variant suffixes
+		expect(parseModelId('gemma-3-27b-it-heretic-v2.Q8_0')).toMatchObject({
+			modelName: 'gemma-3',
+			params: '27B',
+			quantization: 'Q8_0',
+			tags: ['it', 'heretic', 'v2']
+		});
+
+		expect(parseModelId('gemma-3-27b-it.Q8_0')).toMatchObject({
+			modelName: 'gemma-3',
+			params: '27B',
+			quantization: 'Q8_0',
+			tags: ['it']
+		});
+	});
+});

tools/ui/tests/unit/model-names.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+import { isValidModelName, normalizeModelName } from '$lib/utils/model-names';
+
+describe('normalizeModelName', () => {
+	it('preserves Hugging Face org/model format (single slash)', () => {
+		// Single slash is treated as Hugging Face format and preserved
+		expect(normalizeModelName('meta-llama/Llama-3.1-8B')).toBe('meta-llama/Llama-3.1-8B');
+		expect(normalizeModelName('models/model-name-1')).toBe('models/model-name-1');
+	});
+
+	it('extracts filename from multi-segment paths', () => {
+		// Multiple slashes -> extract just the filename
+		expect(normalizeModelName('path/to/model/model-name-2')).toBe('model-name-2');
+		expect(normalizeModelName('/absolute/path/to/model')).toBe('model');
+	});
+
+	it('extracts filename from backslash paths', () => {
+		expect(normalizeModelName('C\\Models\\model-name-1')).toBe('model-name-1');
+		expect(normalizeModelName('path\\to\\model\\model-name-2')).toBe('model-name-2');
+	});
+
+	it('handles mixed path separators', () => {
+		expect(normalizeModelName('path/to\\model/model-name-2')).toBe('model-name-2');
+	});
+
+	it('returns simple names as-is', () => {
+		expect(normalizeModelName('simple-model')).toBe('simple-model');
+		expect(normalizeModelName('model-name-2')).toBe('model-name-2');
+	});
+
+	it('trims whitespace', () => {
+		expect(normalizeModelName('  model-name  ')).toBe('model-name');
+	});
+
+	it('returns empty string for empty input', () => {
+		expect(normalizeModelName('')).toBe('');
+		expect(normalizeModelName('   ')).toBe('');
+	});
+});
+
+describe('isValidModelName', () => {
+	it('returns true for valid names', () => {
+		expect(isValidModelName('model')).toBe(true);
+		expect(isValidModelName('path/to/model.bin')).toBe(true);
+	});
+
+	it('returns false for empty values', () => {
+		expect(isValidModelName('')).toBe(false);
+		expect(isValidModelName('   ')).toBe(false);
+	});
+});

tools/ui/tests/unit/parse-exec-shell-status.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { isExitCodeSummaryLine, parseExecShellCommandExitStatus } from '$lib/utils';
+
+describe('parseExecShellCommandExitStatus', () => {
+	it('returns undefined when result is empty', () => {
+		expect(parseExecShellCommandExitStatus(undefined)).toBeUndefined();
+		expect(parseExecShellCommandExitStatus('')).toBeUndefined();
+	});
+
+	it('parses a zero-exit summary at end of clean stdout', () => {
+		const status = parseExecShellCommandExitStatus('hello world\n[exit code: 0]');
+		expect(status).toEqual({
+			code: 0,
+			timedOut: false,
+			rawText: '[exit code: 0]'
+		});
+	});
+
+	it('parses a non-zero exit summary', () => {
+		const status = parseExecShellCommandExitStatus('cargo: error[E0425]\n[exit code: 101]');
+		expect(status?.code).toBe(101);
+		expect(status?.timedOut).toBe(false);
+	});
+
+	it('detects timed-out suffix', () => {
+		const status = parseExecShellCommandExitStatus(
+			'still building...\n[exit code: -1] [exit due to timed out]'
+		);
+		expect(status?.code).toBe(-1);
+		expect(status?.timedOut).toBe(true);
+	});
+
+	it('tolerates trailing whitespace after the tail line', () => {
+		const status = parseExecShellCommandExitStatus('[exit code: 0]   \n\n');
+		expect(status?.code).toBe(0);
+	});
+
+	it('does not match an explanatory mention of "[exit code:" not at end', () => {
+		// Any non-trailing occurrence should NOT trigger the badge - we
+		// anchor to the absolute end of the string.
+		const status = parseExecShellCommandExitStatus(
+			'the shell prints [exit code: 0]\nwhen done\nreally done\n'
+		);
+		expect(status).toBeUndefined();
+	});
+
+	it('does not match mid-stream exit lines followed by more output', () => {
+		const status = parseExecShellCommandExitStatus('[exit code: 0]\nmore output keeps streaming');
+		expect(status).toBeUndefined();
+	});
+});
+
+describe('isExitCodeSummaryLine', () => {
+	const status = parseExecShellCommandExitStatus('hello\n[exit code: 7]');
+
+	it('matches when line trims to the tail text', () => {
+		expect(isExitCodeSummaryLine('   [exit code: 7]   ', status)).toBe(true);
+	});
+
+	it('does not match unrelated lines', () => {
+		expect(isExitCodeSummaryLine('plain output line', status)).toBe(false);
+	});
+
+	it('returns false for missing status argument', () => {
+		expect(isExitCodeSummaryLine('[exit code: 7]', undefined)).toBe(false);
+	});
+});

tools/ui/tests/unit/parse-mcp-server-settings.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it, vi } from 'vitest';
+import { parseMcpServerSettings } from '$lib/utils/mcp';
+import { MCP_SERVER_ID_PREFIX } from '$lib/constants/mcp';
+
+/**
+ * Tests for the mcpServers settings parser.
+ *
+ * The parser has to be resilient to anything that may live in the
+ * user's localStorage: malformed JSON, wrong shapes, missing fields,
+ * falsy-but-not-zero numbers, and entry arrays that have been mutated
+ * by the user via the settings form.
+ */
+describe('parseMcpServerSettings', () => {
+	it('returns an empty array for falsy or whitespace-only input', () => {
+		expect(parseMcpServerSettings(null)).toEqual([]);
+		expect(parseMcpServerSettings(undefined)).toEqual([]);
+		expect(parseMcpServerSettings('')).toEqual([]);
+		expect(parseMcpServerSettings('   ')).toEqual([]);
+	});
+
+	it('returns an empty array and logs a warning for invalid JSON strings', () => {
+		const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+		expect(parseMcpServerSettings('{not-json')).toEqual([]);
+		expect(warn).toHaveBeenCalled();
+
+		warn.mockRestore();
+	});
+
+	it('returns an empty array for valid JSON that is not an array', () => {
+		expect(parseMcpServerSettings('"plain-string"')).toEqual([]);
+		expect(parseMcpServerSettings('{"id":"foo"}')).toEqual([]);
+		expect(parseMcpServerSettings('42')).toEqual([]);
+		expect(parseMcpServerSettings('null')).toEqual([]);
+	});
+
+	it('drops entries with no parseable id and substitutes a stable fallback', () => {
+		const parsed = parseMcpServerSettings(
+			JSON.stringify([{ url: 'https://a.test', enabled: true }, { url: 'https://b.test' }])
+		);
+
+		expect(parsed).toHaveLength(2);
+		expect(parsed[0]?.id).toBe(`${MCP_SERVER_ID_PREFIX}-1`);
+		expect(parsed[1]?.id).toBe(`${MCP_SERVER_ID_PREFIX}-2`);
+	});
+
+	it('reuses the first id when it is present and falls back only for missing ones', () => {
+		const parsed = parseMcpServerSettings(
+			JSON.stringify([
+				{ id: 'custom-1', url: 'https://a.test' },
+				{ url: 'https://b.test' },
+				{ id: 'custom-3', url: 'https://c.test' }
+			])
+		);
+
+		expect(parsed[0]?.id).toBe('custom-1');
+		expect(parsed[1]?.id).toBe(`${MCP_SERVER_ID_PREFIX}-2`);
+		expect(parsed[2]?.id).toBe('custom-3');
+	});
+
+	it('does not emit a per-server timeout, the request timeout is a live global setting', () => {
+		// A stored per-server requestTimeoutSeconds was never editable in
+		// any UI and froze the global setting at server creation time,
+		// making the Settings value a no-op for existing servers. The
+		// parser drops the field so the global applies live everywhere.
+		const parsed = parseMcpServerSettings(
+			JSON.stringify([{ id: 'a', url: 'https://a.test', requestTimeoutSeconds: 45 }])
+		);
+
+		expect(parsed[0]).not.toHaveProperty('requestTimeoutSeconds');
+	});
+
+	it('treats whitespace-only headers strings as undefined', () => {
+		const parsed = parseMcpServerSettings(
+			JSON.stringify([
+				{ id: 'a', url: 'https://a.test', headers: '   ' },
+				{ id: 'b', url: 'https://b.test', headers: '{"X-Foo":"bar"}' }
+			])
+		);
+
+		// The parser trims headers and coerces empty/whitespace to undefined.
+		expect(parsed[0]?.headers).toBeUndefined();
+		expect(parsed[1]?.headers).toBe('{"X-Foo":"bar"}');
+	});
+
+	it('defaults coercion for booleans (undefined -> false, true -> true)', () => {
+		const parsed = parseMcpServerSettings(
+			JSON.stringify([
+				{ id: 'a', url: 'https://a.test' },
+				{ id: 'b', url: 'https://b.test', enabled: true },
+				{ id: 'c', url: 'https://c.test', enabled: false },
+				{ id: 'd', url: 'https://d.test', useProxy: true }
+			])
+		);
+
+		expect(parsed[0]?.enabled).toBe(false);
+		expect(parsed[1]?.enabled).toBe(true);
+		expect(parsed[2]?.enabled).toBe(false);
+		expect(parsed[0]?.useProxy).toBe(false);
+		expect(parsed[3]?.useProxy).toBe(true);
+	});
+
+	it('keeps disabled entries in the list, enabled is state and never a visibility filter', () => {
+		// Regression guard for issue #25625: filtering the server list on
+		// `enabled` hides a toggled-off server from every UI surface with
+		// no way to re-enable it. Any list derived from this parser must
+		// contain disabled entries.
+		const parsed = parseMcpServerSettings(
+			JSON.stringify([
+				{ id: 'on', url: 'https://on.test', enabled: true },
+				{ id: 'off', url: 'https://off.test', enabled: false }
+			])
+		);
+
+		expect(parsed.map((entry) => entry.id)).toEqual(['on', 'off']);
+		expect(parsed[1]?.enabled).toBe(false);
+	});
+
+	it('preserves input order when mapping entries', () => {
+		const source = [
+			{ id: 'gamma', url: 'https://c.test' },
+			{ id: 'alpha', url: 'https://a.test' },
+			{ id: 'beta', url: 'https://b.test' }
+		];
+
+		const parsed = parseMcpServerSettings(JSON.stringify(source));
+
+		expect(parsed.map((entry) => entry.id)).toEqual(['gamma', 'alpha', 'beta']);
+	});
+
+	it('passes non-string raw input through the JSON-equality path', () => {
+		const parsed = parseMcpServerSettings([
+			{ id: 'a', url: 'https://a.test' },
+			{ id: 'b', url: 'https://b.test', enabled: true }
+		]);
+
+		expect(parsed).toHaveLength(2);
+		expect(parsed[0]?.id).toBe('a');
+		expect(parsed[1]?.enabled).toBe(true);
+	});
+
+	it('coerces non-string url values to an empty string rather than throwing', () => {
+		const parsed = parseMcpServerSettings(
+			JSON.stringify([{ id: 'a', url: 42 }, { id: 'b' }, { id: 'c', url: 'https://c.test' }])
+		);
+
+		expect(parsed[0]?.url).toBe('');
+		expect(parsed[1]?.url).toBe('');
+		expect(parsed[2]?.url).toBe('https://c.test');
+	});
+});

tools/ui/tests/unit/parse-toolcalls-memo.test.ts

@@ -0,0 +1,146 @@
+// Tests for the memoized parseToolCalls and O(1) tool message lookup in
+// deriveAgenticSections. These were added to prevent regressions where
+// streaming text tokens trigger redundant JSON.parse calls on unchanged
+// tool call data.
+
+import { describe, it, expect, vi } from 'vitest';
+import { deriveAgenticSections } from '$lib/utils/agentic';
+import type { ApiChatCompletionToolCall } from '$lib/types/api';
+import type { DatabaseMessage } from '$lib/types/database';
+import { MessageRole, AgenticSectionType } from '$lib/enums';
+
+function makeMessage(overrides: Partial<DatabaseMessage>): DatabaseMessage {
+	return {
+		id: 'm1',
+		convId: 'c1',
+		type: 'text',
+		timestamp: 0,
+		role: MessageRole.ASSISTANT,
+		content: '',
+		parent: null,
+		children: [],
+		...overrides
+	} as DatabaseMessage;
+}
+
+describe('parseToolCalls memoization', () => {
+	it('returns the same array reference for the same JSON string', () => {
+		// parseToolCalls is not exported, but deriveAgenticSections uses it
+		// internally. We verify memoization through behavior: calling
+		// deriveAgenticSections twice with the same toolCalls should not
+		// re-parse (which we verify by checking the returned sections
+		// are equivalent).
+		const toolCallsJson = JSON.stringify([
+			{ id: 'call_1', type: 'function', function: { name: 'test', arguments: '{}' } }
+		]);
+
+		const msg = makeMessage({ content: 'hello', toolCalls: toolCallsJson });
+		const sections1 = deriveAgenticSections(msg, [], [], false);
+		const sections2 = deriveAgenticSections(msg, [], [], false);
+
+		expect(sections1).toHaveLength(sections2.length);
+		expect(sections1[0].type).toBe(sections2[0].type);
+	});
+
+	it('does not re-parse JSON on cache hit', () => {
+		const toolCallsJson = JSON.stringify([
+			{ id: 'call_1', type: 'function', function: { name: 'test', arguments: '{}' } }
+		]);
+
+		const msg = makeMessage({ content: 'hello', toolCalls: toolCallsJson });
+		const spy = vi.spyOn(JSON, 'parse');
+
+		deriveAgenticSections(msg, [], [], false);
+		const callsAfterFirst = spy.mock.calls.length;
+
+		deriveAgenticSections(msg, [], [], false);
+		expect(spy.mock.calls.length).toBe(callsAfterFirst);
+
+		spy.mockRestore();
+	});
+
+	it('handles empty/undefined toolCalls without error', () => {
+		const msg = makeMessage({ content: 'hello' });
+		const sections = deriveAgenticSections(msg, [], [], false);
+
+		expect(sections).toHaveLength(1);
+		expect(sections[0].type).toBe(AgenticSectionType.TEXT);
+	});
+
+	it('handles invalid JSON gracefully', () => {
+		const msg = makeMessage({ content: 'hello', toolCalls: '{invalid' });
+		const sections = deriveAgenticSections(msg, [], [], false);
+
+		// Should return just the text section, no tool call sections
+		expect(sections).toHaveLength(1);
+		expect(sections[0].type).toBe(AgenticSectionType.TEXT);
+	});
+});
+
+describe('deriveAgenticSections O(1) tool message lookup', () => {
+	it('matches tool messages to tool calls by toolCallId', () => {
+		const toolCallsJson = JSON.stringify([
+			{ id: 'call_1', type: 'function', function: { name: 'test_1', arguments: '{}' } },
+			{ id: 'call_2', type: 'function', function: { name: 'test_2', arguments: '{}' } }
+		]);
+
+		const toolMessages = [
+			makeMessage({ role: MessageRole.TOOL, toolCallId: 'call_1', content: 'result_1' }),
+			makeMessage({ role: MessageRole.TOOL, toolCallId: 'call_2', content: 'result_2' })
+		];
+
+		const msg = makeMessage({ content: 'hello', toolCalls: toolCallsJson });
+		const sections = deriveAgenticSections(msg, toolMessages, [], false);
+
+		// Expect: TEXT + 2 TOOL_CALL sections
+		const toolCallSections = sections.filter((s) => s.type === AgenticSectionType.TOOL_CALL);
+		expect(toolCallSections).toHaveLength(2);
+		expect(toolCallSections[0].toolResult).toBe('result_1');
+		expect(toolCallSections[1].toolResult).toBe('result_2');
+	});
+
+	it('handles missing tool messages (pending calls during streaming)', () => {
+		const toolCallsJson = JSON.stringify([
+			{ id: 'call_1', type: 'function', function: { name: 'test', arguments: '{}' } }
+		]);
+
+		const msg = makeMessage({ content: '', toolCalls: toolCallsJson });
+		const sections = deriveAgenticSections(msg, [], [], true);
+
+		const toolCallSection = sections.find((s) => s.type === AgenticSectionType.TOOL_CALL_PENDING);
+		expect(toolCallSection).toBeDefined();
+		expect(toolCallSection?.content).toBe('');
+	});
+
+	it('scales with many tool calls (no O(n^2) blowup)', () => {
+		const N = 100;
+		const toolCalls = Array.from(
+			{ length: N },
+			(_, i): ApiChatCompletionToolCall => ({
+				id: `call_${i}`,
+				type: 'function',
+				function: { name: `tool_${i}`, arguments: '{}' }
+			})
+		);
+		const toolCallsJson = JSON.stringify(toolCalls);
+
+		const toolMessages = Array.from({ length: N }, (_, i) =>
+			makeMessage({
+				role: MessageRole.TOOL,
+				toolCallId: `call_${i}`,
+				content: `result_${i}`
+			})
+		);
+
+		const msg = makeMessage({ content: 'hello', toolCalls: toolCallsJson });
+
+		// If the lookup were still O(n^2), this would be noticeably slow
+		const start = Date.now();
+		const sections = deriveAgenticSections(msg, toolMessages, [], false);
+		const elapsed = Date.now() - start;
+
+		const toolCallSections = sections.filter((s) => s.type === AgenticSectionType.TOOL_CALL);
+		expect(toolCallSections).toHaveLength(N);
+		expect(elapsed).toBeLessThan(100); // Should be fast with O(1) lookup
+	});
+});

tools/ui/tests/unit/partial-tool-call-cleanup.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from 'vitest';
+import { MessageRole } from '$lib/enums';
+import { deriveAgenticSections } from '$lib/utils/agentic';
+import type { DatabaseMessage } from '$lib/types/database';
+
+function makeAssistant(overrides: Partial<DatabaseMessage> = {}): DatabaseMessage {
+	return {
+		id: overrides.id ?? 'ast-1',
+		convId: 'conv-1',
+		type: 'text',
+		timestamp: Date.now(),
+		role: MessageRole.ASSISTANT,
+		content: overrides.content ?? '',
+		parent: null,
+		children: [],
+		...overrides
+	} as DatabaseMessage;
+}
+
+// Mirrors the filter inside ChatService.convertDbMessageToApiChatMessageData:
+// a partial tool call captured mid-stream must not survive into the next request
+// payload. The fix in chatStore.savePartialResponseIfNeeded clears toolCalls to ''
+// on Stop/Send immediately, mirroring what the agentic flow already does in
+// onAssistantTurnComplete(...undefined).
+function buildApiToolCalls(message: DatabaseMessage): unknown[] | undefined {
+	if (!message.toolCalls) return undefined;
+	try {
+		const parsed = JSON.parse(message.toolCalls);
+		return Array.isArray(parsed) && parsed.length > 0 ? parsed : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+describe('partial tool call cleanup', () => {
+	// Reproduces the broken payload from the user's screenshot: model was
+	// streaming a tool call whose arguments JSON was cut mid-string. The outer
+	// envelope still parses, but the arguments themselves are invalid JSON and
+	// the server rejects the request.
+	it('marks a partial tool call payload as unsafe to re-send', () => {
+		const message = makeAssistant({
+			content: 'partial reasoning',
+			toolCalls: JSON.stringify([
+				{
+					id: 'call_1',
+					type: 'function',
+					function: {
+						name: 'exec_shell_command',
+						arguments: '{"command":`grep -n \\"read_to\\" ` /Users'
+					}
+				}
+			])
+		});
+
+		const apiToolCalls = buildApiToolCalls(message);
+
+		// The bug: even though arguments are invalid, the outer array parses and
+		// the request gets sent. Function arguments must be parseable JSON on their
+		// own for the server to execute the tool.
+		expect(apiToolCalls).toBeDefined();
+		const args = (apiToolCalls![0] as { function: { arguments: string } }).function.arguments;
+		expect(() => JSON.parse(args)).toThrow();
+	});
+
+	// After Stop, savePartialResponseIfNeeded clears toolCalls and the agentic
+	// flow does the same in its silent-return detection. The next request reads
+	// toolCalls = '' and the conversion drops the field entirely so the server
+	// never sees the half-streamed call.
+	it('drops tool_calls from the API request after toolCalls is cleared', () => {
+		const clearedMessage = makeAssistant({
+			content: 'partial reasoning',
+			toolCalls: ''
+		});
+
+		const apiToolCalls = buildApiToolCalls(clearedMessage);
+		expect(apiToolCalls).toBeUndefined();
+	});
+
+	// The cleanup path keeps the partial reasoning content visible in the UI;
+	// only the tool_calls field is reset. deriveAgenticSections should still
+	// surface the reasoning as interrupted (no content / no tool calls behind
+	// it) without resurrecting the dead tool call block.
+	it('keeps reasoning content visible after cleanup, without a tool call block', () => {
+		const cleared = makeAssistant({
+			content: '',
+			reasoningContent: 'thinking about read_to',
+			toolCalls: ''
+		});
+
+		const sections = deriveAgenticSections(cleared);
+		expect(sections).toHaveLength(1);
+		expect(sections[0].type).toBe('reasoning');
+		expect(sections.some((s) => s.type.includes('tool_call'))).toBe(false);
+	});
+});

tools/ui/tests/unit/pwa.spec.ts

@@ -0,0 +1,193 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const DIST_DIR = resolve(__dirname, '../../dist');
+const distExists = existsSync(DIST_DIR);
+
+// PWA Build Output tests are integration tests that require a built dist/.
+// CI builds first then runs these tests; local devs should run `npm run build` or use `npm run test:pwa`.
+describe('PWA Build Output', () => {
+	if (!distExists) {
+		console.warn(`⚠ Skipping PWA Build Output tests - dist/ not found (run 'npm run build' first)`);
+		it('skipped - dist/ not found', () => {});
+		return;
+	}
+
+	const swContent = readFileSync(resolve(DIST_DIR, 'sw.js'), 'utf-8');
+	const indexContent = readFileSync(resolve(DIST_DIR, 'index.html'), 'utf-8');
+
+	describe('Core files exist', () => {
+		it('service worker (sw.js) exists', () => {
+			expect(existsSync(resolve(DIST_DIR, 'sw.js')), 'sw.js not found').toBeTruthy();
+		});
+
+		it('workbox library exists (hashed filename)', () => {
+			// SvelteKit generates workbox-{hash}.js files
+			const files = readdirSync(DIST_DIR).filter((f) => f.match(/^workbox-[^.]+\.js$/));
+			expect(files.length).toBeGreaterThan(0);
+		});
+
+		it('manifest.webmanifest exists', () => {
+			expect(
+				existsSync(resolve(DIST_DIR, 'manifest.webmanifest')),
+				'manifest.webmanifest not found'
+			).toBeTruthy();
+		});
+
+		it('SvelteKit bundle.js exists in _app/immutable/', () => {
+			// SvelteKit generates hashed bundle names in _app/immutable/
+			const appDir = resolve(DIST_DIR, '_app', 'immutable');
+			expect(existsSync(appDir), '_app/immutable/ not found').toBeTruthy();
+			const files = readdirSync(appDir).filter((f) => f.startsWith('bundle.') && f.endsWith('.js'));
+			expect(files.length).toBeGreaterThan(0);
+		});
+
+		it('SvelteKit bundle.css exists in _app/immutable/assets/', () => {
+			// SvelteKit generates hashed CSS bundles in _app/immutable/assets/
+			const cssDir = resolve(DIST_DIR, '_app', 'immutable', 'assets');
+			expect(existsSync(cssDir), '_app/immutable/assets/ not found').toBeTruthy();
+			const files = readdirSync(cssDir).filter(
+				(f) => f.startsWith('bundle.') && f.endsWith('.css')
+			);
+			expect(files.length).toBeGreaterThan(0);
+		});
+
+		it('version.json exists in _app/', () => {
+			// SvelteKit stores version.json in _app directory
+			expect(
+				existsSync(resolve(DIST_DIR, '_app', 'version.json')),
+				'_app/version.json not found'
+			).toBeTruthy();
+		});
+	});
+
+	describe('version.json content', () => {
+		it('has valid JSON with version field', () => {
+			const content = readFileSync(resolve(DIST_DIR, '_app', 'version.json'), 'utf-8');
+			const parsed = JSON.parse(content);
+			expect(parsed).toHaveProperty('version');
+			expect(typeof parsed.version).toBe('string');
+			expect(parsed.version.length).toBeGreaterThan(0);
+		});
+	});
+
+	describe('Service worker content', () => {
+		it('service worker has minified self.define format', () => {
+			expect(swContent).toBeTruthy();
+			// SvelteKit's workbox-plugin-sveltekit produces a minified SW with self.define
+			expect(swContent).toMatch(/if\(!self.define\)/);
+		});
+
+		it('references hashed workbox file (SvelteKit build output)', () => {
+			expect(swContent).toBeTruthy();
+			// SvelteKit's workbox-plugin-sveltekit references hashed workbox files
+			expect(swContent).toMatch(/define\(\["\.\/workbox-[a-zA-Z0-9]+"\]/);
+		});
+
+		it('precache contains SvelteKit bundle.js with content hash', () => {
+			expect(swContent).toBeTruthy();
+			// SvelteKit uses content-hashed bundle names in _app/immutable/
+			expect(swContent).toMatch(/"_app\/immutable\/bundle\.[a-zA-Z0-9_-]+\.js"/);
+		});
+
+		it('precache contains SvelteKit bundle.css with content hash', () => {
+			expect(swContent).toBeTruthy();
+			// SvelteKit uses content-hashed CSS bundle names in _app/immutable/assets/
+			expect(swContent).toMatch(/"_app\/immutable\/assets\/bundle\.[a-zA-Z0-9_-]+\.css"/);
+		});
+
+		it('precache contains _app/version.json', () => {
+			expect(swContent).toBeTruthy();
+			// SvelteKit stores version.json in _app directory
+			expect(swContent).toMatch(/"_app\/version\.json"/);
+		});
+
+		it('precache contains manifest.webmanifest', () => {
+			expect(swContent).toBeTruthy();
+			expect(swContent).toMatch(/"manifest\.webmanifest"/);
+		});
+
+		it('no navigation route — API endpoints bypass PWA', () => {
+			expect(swContent).toBeTruthy();
+			// NavigationRoute is intentionally absent so direct browser
+			// navigation to server API endpoints returns JSON, not HTML.
+			expect(swContent).not.toMatch(/NavigationRoute/);
+		});
+
+		it('has runtime caching for API routes', () => {
+			expect(swContent).toBeTruthy();
+			expect(swContent).toMatch(/api-cache/);
+			expect(swContent).toMatch(/NetworkFirst/);
+		});
+	});
+
+	describe('index.html content', () => {
+		it('has modulepreload link for SvelteKit bundle with content hash', () => {
+			expect(indexContent).toBeTruthy();
+			// SvelteKit generates hashed bundle names in _app/immutable/
+			expect(indexContent).toMatch(/href="(\.\/|\/)_app\/immutable\/bundle\.[a-zA-Z0-9_-]+\.js"/);
+		});
+
+		it('has stylesheet link for SvelteKit bundle.css with content hash', () => {
+			expect(indexContent).toBeTruthy();
+			expect(indexContent).toMatch(
+				/href="(\.\/|\/)_app\/immutable\/assets\/bundle\.[a-zA-Z0-9_-]+\.css"/
+			);
+		});
+
+		it('has dynamic import for SvelteKit bundle with content hash', () => {
+			expect(indexContent).toBeTruthy();
+			expect(indexContent).toMatch(
+				/import\("(\.\/|\/)_app\/immutable\/bundle\.[a-zA-Z0-9_-]+\.js"\)/
+			);
+		});
+
+		it('has __sveltekit__ variable (SvelteKit adds hash suffix)', () => {
+			expect(indexContent).toBeTruthy();
+			// SvelteKit 2.x uses __sveltekit__ as base with random suffix
+			expect(indexContent).toMatch(/__sveltekit_[a-zA-Z0-9-]+/);
+		});
+
+		it('has PWA manifest link', () => {
+			expect(indexContent).toBeTruthy();
+			expect(indexContent).toMatch(/rel="manifest" href="(\.?\/)?manifest\.webmanifest"/);
+		});
+
+		it('has apple-touch-icon link', () => {
+			expect(indexContent).toBeTruthy();
+			expect(indexContent).toMatch(/rel="apple-touch-icon"/);
+		});
+
+		it('has _app paths for SvelteKit bundles', () => {
+			expect(indexContent).toBeTruthy();
+			// SvelteKit uses _app paths for hashed assets
+			expect(indexContent).toMatch(/_app\//);
+		});
+	});
+
+	describe('SvelteKit _app directory', () => {
+		it('_app directory exists (SvelteKit uses it for hashed assets)', () => {
+			expect(existsSync(resolve(DIST_DIR, '_app'))).toBeTruthy();
+		});
+	});
+
+	describe('Hashed workbox files', () => {
+		it('workbox-*.js files exist in dist root (SvelteKit build output)', () => {
+			const files = readdirSync(DIST_DIR).filter((f) => f.match(/^workbox-[^.]+\.js$/));
+			expect(files.length).toBeGreaterThan(0);
+		});
+	});
+
+	describe('Static assets', () => {
+		it('has favicon.ico', () => {
+			expect(existsSync(resolve(DIST_DIR, 'favicon.ico'))).toBeTruthy();
+		});
+
+		it('has PWA icons', () => {
+			expect(existsSync(resolve(DIST_DIR, 'pwa-64x64.png'))).toBeTruthy();
+			expect(existsSync(resolve(DIST_DIR, 'pwa-192x192.png'))).toBeTruthy();
+			expect(existsSync(resolve(DIST_DIR, 'pwa-512x512.png'))).toBeTruthy();
+		});
+	});
+});

tools/ui/tests/unit/reasoning-context.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest';
+import { MessageRole } from '$lib/enums';
+
+/**
+ * Tests for the new reasoning content handling.
+ * In the new architecture, reasoning content is stored in a dedicated
+ * `reasoningContent` field on DatabaseMessage, not embedded in content with tags.
+ * The API sends it as `reasoning_content` on ApiChatMessageData.
+ */
+
+describe('reasoning content in new structured format', () => {
+	it('reasoning is stored as separate field, not in content', () => {
+		// Simulate what the new chat store does
+		const message = {
+			content: 'The answer is 4.',
+			reasoningContent: 'Let me think: 2+2=4, basic arithmetic.'
+		};
+
+		// Content should be clean
+		expect(message.content).not.toContain('<<<');
+		expect(message.content).toBe('The answer is 4.');
+
+		// Reasoning in dedicated field
+		expect(message.reasoningContent).toBe('Let me think: 2+2=4, basic arithmetic.');
+	});
+
+	it('convertDbMessageToApiChatMessageData includes reasoning_content', () => {
+		// Simulate the conversion logic
+		const dbMessage = {
+			role: MessageRole.ASSISTANT,
+			content: 'The answer is 4.',
+			reasoningContent: 'Let me think: 2+2=4, basic arithmetic.'
+		};
+
+		const apiMessage: Record<string, unknown> = {
+			role: dbMessage.role,
+			content: dbMessage.content
+		};
+		if (dbMessage.reasoningContent) {
+			apiMessage.reasoning_content = dbMessage.reasoningContent;
+		}
+
+		expect(apiMessage.content).toBe('The answer is 4.');
+		expect(apiMessage.reasoning_content).toBe('Let me think: 2+2=4, basic arithmetic.');
+		// No internal tags leak into either field
+		expect(apiMessage.content).not.toContain('<<<');
+		expect(apiMessage.reasoning_content).not.toContain('<<<');
+	});
+
+	it('API message excludes reasoning when excludeReasoningFromContext is true', () => {
+		const dbMessage = {
+			role: MessageRole.ASSISTANT,
+			content: 'The answer is 4.',
+			reasoningContent: 'internal thinking'
+		};
+
+		const excludeReasoningFromContext = true;
+
+		const apiMessage: Record<string, unknown> = {
+			role: dbMessage.role,
+			content: dbMessage.content
+		};
+		if (!excludeReasoningFromContext && dbMessage.reasoningContent) {
+			apiMessage.reasoning_content = dbMessage.reasoningContent;
+		}
+
+		expect(apiMessage.content).toBe('The answer is 4.');
+		expect(apiMessage.reasoning_content).toBeUndefined();
+	});
+
+	it('handles messages with no reasoning', () => {
+		const dbMessage = {
+			role: MessageRole.ASSISTANT,
+			content: 'No reasoning here.',
+			reasoningContent: undefined
+		};
+
+		const apiMessage: Record<string, unknown> = {
+			role: dbMessage.role,
+			content: dbMessage.content
+		};
+		if (dbMessage.reasoningContent) {
+			apiMessage.reasoning_content = dbMessage.reasoningContent;
+		}
+
+		expect(apiMessage.content).toBe('No reasoning here.');
+		expect(apiMessage.reasoning_content).toBeUndefined();
+	});
+});

tools/ui/tests/unit/redact.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { redactValue } from '$lib/utils/redact';
+
+describe('redactValue', () => {
+	it('returns [redacted] by default', () => {
+		expect(redactValue('secret-token')).toBe('[redacted]');
+	});
+
+	it('shows last N characters when showLastChars is provided', () => {
+		expect(redactValue('session-abc12', 5)).toBe('....abc12');
+	});
+
+	it('handles value shorter than showLastChars', () => {
+		expect(redactValue('ab', 5)).toBe('....ab');
+	});
+
+	it('returns [redacted] when showLastChars is 0', () => {
+		expect(redactValue('secret', 0)).toBe('[redacted]');
+	});
+});

tools/ui/tests/unit/request-helpers.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest';
+import {
+	getRequestUrl,
+	getRequestMethod,
+	getRequestBody,
+	summarizeRequestBody,
+	formatDiagnosticErrorMessage,
+	extractJsonRpcMethods
+} from '$lib/utils/request-helpers';
+
+describe('getRequestUrl', () => {
+	it('returns a plain string input as-is', () => {
+		expect(getRequestUrl('https://example.com/mcp')).toBe('https://example.com/mcp');
+	});
+
+	it('returns href from a URL object', () => {
+		expect(getRequestUrl(new URL('https://example.com/mcp'))).toBe('https://example.com/mcp');
+	});
+
+	it('returns url from a Request object', () => {
+		const req = new Request('https://example.com/mcp');
+		expect(getRequestUrl(req)).toBe('https://example.com/mcp');
+	});
+});
+
+describe('getRequestMethod', () => {
+	it('prefers method from init', () => {
+		expect(getRequestMethod('https://example.com', { method: 'POST' })).toBe('POST');
+	});
+
+	it('falls back to Request.method', () => {
+		const req = new Request('https://example.com', { method: 'PUT' });
+		expect(getRequestMethod(req)).toBe('PUT');
+	});
+
+	it('falls back to baseInit.method', () => {
+		expect(getRequestMethod('https://example.com', undefined, { method: 'DELETE' })).toBe('DELETE');
+	});
+
+	it('defaults to GET', () => {
+		expect(getRequestMethod('https://example.com')).toBe('GET');
+	});
+});
+
+describe('getRequestBody', () => {
+	it('returns body from init', () => {
+		expect(getRequestBody('https://example.com', { body: 'payload' })).toBe('payload');
+	});
+
+	it('returns undefined when no body is present', () => {
+		expect(getRequestBody('https://example.com')).toBeUndefined();
+	});
+});
+
+describe('summarizeRequestBody', () => {
+	it('returns empty for null', () => {
+		expect(summarizeRequestBody(null)).toEqual({ kind: 'empty' });
+	});
+
+	it('returns empty for undefined', () => {
+		expect(summarizeRequestBody(undefined)).toEqual({ kind: 'empty' });
+	});
+
+	it('returns string kind with size', () => {
+		expect(summarizeRequestBody('hello')).toEqual({ kind: 'string', size: 5 });
+	});
+
+	it('returns blob kind with size', () => {
+		const blob = new Blob(['abc']);
+		expect(summarizeRequestBody(blob)).toEqual({ kind: 'blob', size: 3 });
+	});
+
+	it('returns formdata kind', () => {
+		expect(summarizeRequestBody(new FormData())).toEqual({ kind: 'formdata' });
+	});
+
+	it('returns arraybuffer kind with size', () => {
+		expect(summarizeRequestBody(new ArrayBuffer(8))).toEqual({ kind: 'arraybuffer', size: 8 });
+	});
+});
+
+describe('formatDiagnosticErrorMessage', () => {
+	it('appends CORS hint for Failed to fetch', () => {
+		expect(formatDiagnosticErrorMessage(new TypeError('Failed to fetch'))).toBe(
+			'Failed to fetch (check CORS?)'
+		);
+	});
+
+	it('passes through other error messages unchanged', () => {
+		expect(formatDiagnosticErrorMessage(new Error('timeout'))).toBe('timeout');
+	});
+
+	it('handles non-Error values', () => {
+		expect(formatDiagnosticErrorMessage('some string')).toBe('some string');
+	});
+});
+
+describe('extractJsonRpcMethods', () => {
+	it('extracts methods from a JSON-RPC array', () => {
+		const body = JSON.stringify([
+			{ jsonrpc: '2.0', id: 1, method: 'initialize' },
+			{ jsonrpc: '2.0', method: 'notifications/initialized' }
+		]);
+		expect(extractJsonRpcMethods(body)).toEqual(['initialize', 'notifications/initialized']);
+	});
+
+	it('extracts method from a single JSON-RPC message', () => {
+		const body = JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list' });
+		expect(extractJsonRpcMethods(body)).toEqual(['tools/list']);
+	});
+
+	it('returns undefined for non-string body', () => {
+		expect(extractJsonRpcMethods(null)).toBeUndefined();
+		expect(extractJsonRpcMethods(undefined)).toBeUndefined();
+	});
+
+	it('returns undefined for invalid JSON', () => {
+		expect(extractJsonRpcMethods('not json')).toBeUndefined();
+	});
+
+	it('returns undefined when no methods found', () => {
+		expect(extractJsonRpcMethods(JSON.stringify({ foo: 'bar' }))).toBeUndefined();
+	});
+});

tools/ui/tests/unit/sanitize-headers.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+import { sanitizeHeaders } from '$lib/utils/api-headers';
+import { CORS_PROXY_HEADER_PREFIX } from '$lib/constants';
+
+describe('sanitizeHeaders', () => {
+	it('returns empty object for undefined input', () => {
+		expect(sanitizeHeaders()).toEqual({});
+	});
+
+	it('passes through non-sensitive headers', () => {
+		const headers = new Headers({ 'content-type': 'application/json', accept: 'text/html' });
+		expect(sanitizeHeaders(headers)).toEqual({
+			'content-type': 'application/json',
+			accept: 'text/html'
+		});
+	});
+
+	it('redacts known sensitive headers', () => {
+		const headers = new Headers({
+			authorization: 'Bearer secret',
+			'x-api-key': 'key-123',
+			'content-type': 'application/json'
+		});
+		const result = sanitizeHeaders(headers);
+		expect(result.authorization).toBe('[redacted]');
+		expect(result['x-api-key']).toBe('[redacted]');
+		expect(result['content-type']).toBe('application/json');
+	});
+
+	it('partially redacts headers specified in partialRedactHeaders', () => {
+		const headers = new Headers({ 'mcp-session-id': 'session-12345' });
+		const partial = new Map([['mcp-session-id', 5]]);
+		expect(sanitizeHeaders(headers, undefined, partial)['mcp-session-id']).toBe('....12345');
+	});
+
+	it('fully redacts mcp-session-id when no partialRedactHeaders is given', () => {
+		const headers = new Headers({ 'mcp-session-id': 'session-12345' });
+		expect(sanitizeHeaders(headers)['mcp-session-id']).toBe('[redacted]');
+	});
+
+	it('redacts extra headers provided by the caller', () => {
+		const headers = new Headers({
+			'x-vendor-key': 'vendor-secret',
+			'content-type': 'application/json'
+		});
+		const result = sanitizeHeaders(headers, ['x-vendor-key']);
+		expect(result['x-vendor-key']).toBe('[redacted]');
+		expect(result['content-type']).toBe('application/json');
+	});
+
+	it('handles case-insensitive extra header names', () => {
+		const headers = new Headers({ 'X-Custom-Token': 'token-value' });
+		const result = sanitizeHeaders(headers, ['X-CUSTOM-TOKEN']);
+		expect(result['x-custom-token']).toBe('[redacted]');
+	});
+
+	it('redacts proxied sensitive and custom target headers', () => {
+		const proxiedAuthorization = `${CORS_PROXY_HEADER_PREFIX}authorization`;
+		const proxiedSessionId = `${CORS_PROXY_HEADER_PREFIX}mcp-session-id`;
+		const proxiedVendorKey = `${CORS_PROXY_HEADER_PREFIX}x-vendor-key`;
+		const headers = new Headers({
+			[proxiedAuthorization]: 'Bearer secret',
+			[proxiedSessionId]: 'session-12345',
+			[proxiedVendorKey]: 'vendor-secret'
+		});
+		const partial = new Map([['mcp-session-id', 5]]);
+		const result = sanitizeHeaders(headers, ['x-vendor-key'], partial);
+
+		expect(result[proxiedAuthorization]).toBe('[redacted]');
+		expect(result[proxiedSessionId]).toBe('....12345');
+		expect(result[proxiedVendorKey]).toBe('[redacted]');
+	});
+});

tools/ui/tests/unit/search-results-fixture.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { extractSearchResults, extractSearchQuery } from '$lib/utils/search-results';
+
+const SAMPLE = `Title: World Cup 2026 | Match schedule, fixtures, results & stadiums
+URL: https://www.fifa.com/en/tournaments/mens/worldcup/canadamexicousa2026/articles/match-schedule-fixtures-results-teams-stadiums
+Published: 2026-06-22T00:01:00.000Z
+Author: N/A
+Highlights:
+Find out the full match schedule for World Cup 2026 in Canada, Mexico and USA with fixtures and results from each of the 104 games in the ...
+---
+Title: 2026 FIFA World Cup match schedule: Fixtures, results, features - ESPN
+URL: https://www.espn.com/soccer/story/_/id/48939282/2026-fifa-world-cup-fixtures-results-match-schedule-group-stage-knockout-rounds-bracket
+Published: 2026-07-08T07:07:00.000Z
+Author: ESPN
+Highlights:
+Round of 32 · Tuesday, July 7 · Argentina 3-2 Egypt (Atlanta) Switzerland (4) 0-0 (3) Colombia (Vancouver, Canada) · Monday, July 6 · Portugal 0-1 ...
+---
+Title: BBC
+URL: https://www.bbc.co.uk/sport/football/world-cup/schedule
+Published: N/A
+Author: N/A
+Highlights:
+Something
+# World Cup
+...`;
+
+const QUERY_ARGS = '{"query":"FIFA World Cup 2026 schedule"}';
+
+describe('real-world Exa fixture', () => {
+	it('extracts every search result and preserves rich highlights', () => {
+		const results = extractSearchResults(SAMPLE);
+		expect(results.length).toBe(3);
+		expect(results[0].title).toContain('World Cup 2026 | Match schedule');
+		expect(results[0].url).toContain('fifa.com');
+		expect(results[1].title).toContain('2026 FIFA World Cup match schedule');
+		expect(results[1].author).toBe('ESPN');
+		expect(results[1].highlights).toContain('Round of 32');
+		expect(results[2].title).toBe('BBC');
+	});
+
+	it('parses the query out of the tool-args JSON', () => {
+		expect(extractSearchQuery(QUERY_ARGS)).toBe('FIFA World Cup 2026 schedule');
+	});
+});

tools/ui/tests/unit/search-results.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest';
+import {
+	extractSearchResults,
+	extractSearchQuery,
+	faviconForUrl,
+	isWebSearchToolName
+} from '$lib/utils/search-results';
+
+describe('extractSearchResults', () => {
+	it('parses the Exa fixture with multiple results', () => {
+		const fixture = `Title: World Cup 2026 | Match schedule, fixtures
+URL: https://www.fifa.com/articles/match-schedule
+Published: 2026-06-22T00:01:00.000Z
+Author: N/A
+Highlights:
+Find out the full match schedule for World Cup 2026
+---
+Title: 2026 FIFA World Cup match schedule
+URL: https://www.espn.com/soccer/story/abc/def
+Published: 2026-07-08T07:07:00.000Z
+Author: ESPN
+Highlights:
+Round of 32 · Tuesday, July 7
+---
+Title: BBC
+URL: https://www.bbc.co.uk/sport/football/world-cup/schedule
+Published: N/A
+Author: N/A
+Highlights:
+# FIFA World Cup Schedule
+...`;
+		const results = extractSearchResults(fixture);
+		expect(results.length).toBe(3);
+		expect(results[0].title).toContain('World Cup 2026');
+		expect(results[0].url).toBe('https://www.fifa.com/articles/match-schedule');
+		expect(results[0].published).toBe('2026-06-22T00:01:00.000Z');
+		// N/A filtered out
+		expect(results[0].author).toBeUndefined();
+		expect(results[0].highlights).toContain('match schedule');
+		expect(results[1].author).toBe('ESPN');
+		expect(results[2].author).toBeUndefined(); // N/A filtered
+	});
+
+	it('returns empty array for empty input', () => {
+		expect(extractSearchResults('')).toEqual([]);
+		expect(extractSearchResults(undefined)).toEqual([]);
+		expect(extractSearchResults(null)).toEqual([]);
+	});
+
+	it('skips chunks missing title or url', () => {
+		const txt = `Title: no url here
+Highlights:
+foo
+---
+Title: foo
+URL: https://x.com
+---
+just a paragraph
+---
+Title: b
+URL: not a url`;
+		const results = extractSearchResults(txt);
+		// Only middle one should pass (has title + url).
+		expect(results.length).toBe(1);
+		expect(results[0].url).toBe('https://x.com');
+	});
+
+	it('parses a single result without separators', () => {
+		const txt = `Title: only one
+URL: https://example.com/test
+Published: 2026-01-01T00:00:00Z
+Author: alice
+Highlights:
+a highlight`;
+		const results = extractSearchResults(txt);
+		expect(results.length).toBe(1);
+		expect(results[0].title).toBe('only one');
+		expect(results[0].author).toBe('alice');
+		expect(results[0].highlights).toBe('a highlight');
+	});
+
+	it('extracts query from JSON toolArgs', () => {
+		expect(extractSearchQuery('{"query":"foo"}')).toBe('foo');
+		expect(extractSearchQuery('  {"query":"  foo  "}  ')).toBe('foo');
+		expect(extractSearchQuery('not json')).toBe('');
+		expect(extractSearchQuery(null)).toBe('');
+		expect(extractSearchQuery('{"query":123}')).toBe('');
+	});
+
+	it('resolves favicon URLs from origins', () => {
+		expect(faviconForUrl('https://example.com/path/to/page')).toBe(
+			'https://example.com/favicon.ico'
+		);
+		expect(faviconForUrl('http://example.com/x')).toBe('http://example.com/favicon.ico');
+		expect(faviconForUrl('not a url')).toBeNull();
+	});
+});
+
+describe('isWebSearchToolName', () => {
+	it('excludes tools that take the same query argument but are not web searches', () => {
+		expect(isWebSearchToolName('search_pull_requests')).toBe(false);
+		expect(isWebSearchToolName('search_code')).toBe(false);
+		expect(isWebSearchToolName('search_repositories')).toBe(false);
+		expect(isWebSearchToolName('search_issues')).toBe(false);
+	});
+
+	it('handles empty / missing input', () => {
+		expect(isWebSearchToolName(null)).toBe(false);
+		expect(isWebSearchToolName(undefined)).toBe(false);
+		expect(isWebSearchToolName('')).toBe(false);
+	});
+
+	it('returns false for unrelated tools', () => {
+		expect(isWebSearchToolName('web_fetch')).toBe(false);
+		expect(isWebSearchToolName('read_file')).toBe(false);
+		expect(isWebSearchToolName('exec_shell_command')).toBe(false);
+	});
+});

tools/ui/tests/unit/sse.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest';
+import { parseSseJsonStream } from '$lib/utils/sse';
+
+function makeSseResponse(events: string[]): Response {
+	const body = events.join('\n\n') + '\n\n';
+	return new Response(body, {
+		status: 200,
+		headers: { 'content-type': 'text/event-stream' }
+	});
+}
+
+describe('parseSseJsonStream', () => {
+	it('yields parsed data for each record', async () => {
+		const response = makeSseResponse(['data: {"chunk": "a"}', 'data: {"chunk": "b"}']);
+		const collected: unknown[] = [];
+		for await (const ev of parseSseJsonStream(response)) {
+			collected.push(ev.data);
+		}
+		expect(collected).toEqual([{ chunk: 'a' }, { chunk: 'b' }]);
+	});
+
+	it('stops on [DONE] sentinel', async () => {
+		const response = makeSseResponse([
+			'data: {"chunk": "a"}',
+			'data: [DONE]',
+			'data: {"chunk": "after-done"}'
+		]);
+		const collected: unknown[] = [];
+		for await (const ev of parseSseJsonStream(response)) {
+			collected.push(ev.data);
+		}
+		expect(collected).toEqual([{ chunk: 'a' }]);
+	});
+
+	it('skips malformed JSON records', async () => {
+		const response = makeSseResponse([
+			'data: {"chunk": "ok"}',
+			'data: {not-json}',
+			'data: {"chunk": "also-ok"}'
+		]);
+		const collected: unknown[] = [];
+		for await (const ev of parseSseJsonStream(response)) {
+			collected.push(ev.data);
+		}
+		expect(collected).toEqual([{ chunk: 'ok' }, { chunk: 'also-ok' }]);
+	});
+
+	it('handles records split across multiple chunks (partial last line)', async () => {
+		const full = 'data: {"chunk": "x"}\n\ndata: {"chunk": "y"}\n\n';
+		const stream = new ReadableStream<Uint8Array>({
+			start(controller) {
+				const enc = new TextEncoder();
+				controller.enqueue(enc.encode(full.slice(0, full.length / 2)));
+				controller.enqueue(enc.encode(full.slice(full.length / 2)));
+				controller.close();
+			}
+		});
+		const response = new Response(stream, {
+			status: 200,
+			headers: { 'content-type': 'text/event-stream' }
+		});
+		const collected: unknown[] = [];
+		for await (const ev of parseSseJsonStream(response)) {
+			collected.push(ev.data);
+		}
+		expect(collected).toEqual([{ chunk: 'x' }, { chunk: 'y' }]);
+	});
+
+	it('returns immediately if response has no body', async () => {
+		const response = new Response(null, { status: 200 });
+		const collected: unknown[] = [];
+		for await (const ev of parseSseJsonStream(response)) {
+			collected.push(ev.data);
+		}
+		expect(collected).toEqual([]);
+	});
+});

tools/ui/tests/unit/stream-discovery.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import { ChatService } from '$lib/services/chat.service';
+import type { ApiStreamSession } from '$lib/types';
+
+function makeSession(overrides: Partial<ApiStreamSession>): ApiStreamSession {
+	return {
+		conversation_id: 'conv',
+		is_done: true,
+		total_bytes: 0,
+		started_at: 0,
+		completed_at: 0,
+		...overrides
+	};
+}
+
+describe('selectActiveStream', () => {
+	it('returns null on empty input', () => {
+		expect(ChatService.selectActiveStream([])).toBeNull();
+	});
+
+	it('returns null on null or undefined input', () => {
+		expect(ChatService.selectActiveStream(null)).toBeNull();
+		expect(ChatService.selectActiveStream(undefined)).toBeNull();
+	});
+
+	it('returns the single session when it is running', () => {
+		const s = makeSession({ conversation_id: 'only', is_done: false, started_at: 42 });
+		expect(ChatService.selectActiveStream([s])).toBe(s);
+	});
+
+	it('returns null when the single session is finalized', () => {
+		const s = makeSession({ conversation_id: 'only', is_done: true, started_at: 42 });
+		expect(ChatService.selectActiveStream([s])).toBeNull();
+	});
+
+	it('prefers a still running session over a finalized one regardless of started_at', () => {
+		const finalized = makeSession({ conversation_id: 'old', is_done: true, started_at: 1000 });
+		const running = makeSession({ conversation_id: 'new', is_done: false, started_at: 10 });
+		expect(ChatService.selectActiveStream([finalized, running])?.conversation_id).toBe('new');
+		expect(ChatService.selectActiveStream([running, finalized])?.conversation_id).toBe('new');
+	});
+
+	it('among running sessions, picks the most recently started one', () => {
+		const a = makeSession({ conversation_id: 'a', is_done: false, started_at: 100 });
+		const b = makeSession({ conversation_id: 'b', is_done: false, started_at: 200 });
+		const c = makeSession({ conversation_id: 'c', is_done: false, started_at: 150 });
+		expect(ChatService.selectActiveStream([a, b, c])?.conversation_id).toBe('b');
+		expect(ChatService.selectActiveStream([c, a, b])?.conversation_id).toBe('b');
+	});
+
+	it('returns null when all sessions are finalized, the DB already holds the content', () => {
+		const a = makeSession({ conversation_id: 'a', is_done: true, started_at: 10 });
+		const b = makeSession({ conversation_id: 'b', is_done: true, started_at: 30 });
+		const c = makeSession({ conversation_id: 'c', is_done: true, started_at: 20 });
+		expect(ChatService.selectActiveStream([a, b, c])).toBeNull();
+	});
+
+	it('keeps the first match on ties when both are running with identical started_at', () => {
+		// reduce visits left to right, the initial accumulator stays unless a strictly greater value appears
+		const a = makeSession({ conversation_id: 'first', is_done: false, started_at: 50 });
+		const b = makeSession({ conversation_id: 'second', is_done: false, started_at: 50 });
+		expect(ChatService.selectActiveStream([a, b])?.conversation_id).toBe('first');
+	});
+
+	it('handles a typical realistic mix: two finalized old, one freshly running, one freshly finalized', () => {
+		const old1 = makeSession({ conversation_id: 'old1', is_done: true, started_at: 100 });
+		const old2 = makeSession({ conversation_id: 'old2', is_done: true, started_at: 200 });
+		const freshFin = makeSession({ conversation_id: 'freshFin', is_done: true, started_at: 500 });
+		const running = makeSession({ conversation_id: 'running', is_done: false, started_at: 400 });
+		expect(ChatService.selectActiveStream([old1, old2, freshFin, running])?.conversation_id).toBe(
+			'running'
+		);
+	});
+});

tools/ui/tests/unit/stream-resume.test.ts

@@ -0,0 +1,128 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+// node env unit project has no DOM, install a minimal localStorage backed by a Map
+beforeAll(() => {
+	const store = new Map<string, string>();
+	const polyfill: Storage = {
+		get length() {
+			return store.size;
+		},
+		clear: () => store.clear(),
+		getItem: (k) => (store.has(k) ? store.get(k)! : null),
+		key: (i) => Array.from(store.keys())[i] ?? null,
+		removeItem: (k) => {
+			store.delete(k);
+		},
+		setItem: (k, v) => {
+			store.set(k, String(v));
+		}
+	};
+	(globalThis as unknown as { localStorage: Storage }).localStorage = polyfill;
+});
+
+import { ChatService } from '$lib/services/chat.service';
+import { STREAM_RESUME_LOCALSTORAGE_KEY_PREFIX } from '$lib/constants';
+
+describe('ChatService stream resume', () => {
+	beforeEach(() => {
+		localStorage.clear();
+	});
+	afterEach(() => {
+		localStorage.clear();
+	});
+
+	it('returns null when no state exists for the conversation', () => {
+		expect(ChatService.getStreamState('conv-a')).toBeNull();
+	});
+
+	it('saves and reads back the byte count', () => {
+		ChatService.saveStreamState('conv-a', 4242);
+		const got = ChatService.getStreamState('conv-a');
+		expect(got).not.toBeNull();
+		expect(got!.bytesReceived).toBe(4242);
+		expect(typeof got!.updatedAt).toBe('number');
+	});
+
+	it('overwrites the previous byte count on a new save for the same conversation', () => {
+		ChatService.saveStreamState('conv-a', 100);
+		ChatService.saveStreamState('conv-a', 200);
+		const got = ChatService.getStreamState('conv-a');
+		expect(got!.bytesReceived).toBe(200);
+	});
+
+	it('keeps states for distinct conversations isolated', () => {
+		ChatService.saveStreamState('conv-a', 10);
+		ChatService.saveStreamState('conv-b', 20);
+		expect(ChatService.getStreamState('conv-a')!.bytesReceived).toBe(10);
+		expect(ChatService.getStreamState('conv-b')!.bytesReceived).toBe(20);
+	});
+
+	it('clears the state for a given conversation', () => {
+		ChatService.saveStreamState('conv-a', 10);
+		ChatService.clearStreamState('conv-a');
+		expect(ChatService.getStreamState('conv-a')).toBeNull();
+	});
+
+	it('ignores empty conversation id on save', () => {
+		ChatService.saveStreamState('', 1);
+		expect(ChatService.getStreamState('')).toBeNull();
+	});
+
+	it('returns null on corrupted storage payload', () => {
+		localStorage.setItem(`${STREAM_RESUME_LOCALSTORAGE_KEY_PREFIX}conv-a`, '{not-json');
+		expect(ChatService.getStreamState('conv-a')).toBeNull();
+	});
+
+	it('persists the model alongside the byte count', () => {
+		ChatService.saveStreamState('conv-a', 10, 'model-x');
+		expect(ChatService.getStreamState('conv-a')!.model).toBe('model-x');
+	});
+
+	it('stores a null model when none is provided', () => {
+		ChatService.saveStreamState('conv-a', 10);
+		expect(ChatService.getStreamState('conv-a')!.model).toBeNull();
+	});
+
+	it('overwrites the model on a new save for the same conversation', () => {
+		ChatService.saveStreamState('conv-a', 10, 'model-x');
+		ChatService.saveStreamState('conv-a', 20, 'model-y');
+		expect(ChatService.getStreamState('conv-a')!.model).toBe('model-y');
+	});
+
+	describe('resumeStreamIdentity', () => {
+		it('appends the persisted model so the resume key matches the frozen POST identity', () => {
+			ChatService.saveStreamState('conv-a', 10, 'model-x');
+			expect(
+				ChatService.resumeStreamIdentity('conv-a', ChatService.getStreamState('conv-a'), 'dropdown')
+			).toBe('conv-a::model-x');
+		});
+
+		it('keeps the bare conv id when the persisted model is null', () => {
+			ChatService.saveStreamState('conv-a', 10);
+			expect(
+				ChatService.resumeStreamIdentity('conv-a', ChatService.getStreamState('conv-a'), 'dropdown')
+			).toBe('conv-a');
+		});
+
+		it('falls back to the current model only when no state is persisted', () => {
+			expect(ChatService.resumeStreamIdentity('conv-a', null, 'dropdown')).toBe('conv-a::dropdown');
+		});
+
+		it('ignores the fallback when a state exists, the persisted value is authoritative', () => {
+			ChatService.saveStreamState('conv-a', 10, 'model-x');
+			expect(
+				ChatService.resumeStreamIdentity('conv-a', ChatService.getStreamState('conv-a'), 'dropdown')
+			).toBe('conv-a::model-x');
+		});
+
+		it('falls back when a legacy state has no model field', () => {
+			localStorage.setItem(
+				`${STREAM_RESUME_LOCALSTORAGE_KEY_PREFIX}conv-a`,
+				JSON.stringify({ bytesReceived: 10, updatedAt: 1 })
+			);
+			expect(
+				ChatService.resumeStreamIdentity('conv-a', ChatService.getStreamState('conv-a'), 'dropdown')
+			).toBe('conv-a::dropdown');
+		});
+	});
+});

tools/ui/tests/unit/tool-call-meta.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { tryParseToolResultObject } from '$lib/utils';
+
+describe('tryParseToolResultObject', () => {
+	it('returns null when no result is provided', () => {
+		expect(tryParseToolResultObject(undefined)).toBeNull();
+		expect(tryParseToolResultObject('')).toBeNull();
+	});
+
+	it('returns the parsed object when the result is JSON', () => {
+		expect(tryParseToolResultObject('{"result":"ok","bytes":42}')).toEqual({
+			result: 'ok',
+			bytes: 42
+		});
+	});
+
+	it('returns null for JSON arrays (only objects are useful to callers)', () => {
+		expect(tryParseToolResultObject('[1,2,3]')).toBeNull();
+	});
+
+	it('returns null for JSON primitives', () => {
+		expect(tryParseToolResultObject('"raw string"')).toBeNull();
+		expect(tryParseToolResultObject('42')).toBeNull();
+	});
+
+	it('returns null for invalid JSON', () => {
+		expect(tryParseToolResultObject('not json')).toBeNull();
+		expect(tryParseToolResultObject('{bad')).toBeNull();
+	});
+});

tools/ui/tests/unit/tool-calls.test.ts

@@ -0,0 +1,416 @@
+import { describe, expect, it } from 'vitest';
+import { AgenticSectionType, BuiltInTool } from '$lib/enums';
+import type { AgenticSection } from '$lib/utils';
+import { parseToolArgs } from '$lib/components/app/chat/ChatMessages/ChatMessage/ChatMessageToolCall/parsers/_shared';
+import {
+	parseWriteFileMeta,
+	type WriteFileMeta
+} from '$lib/components/app/chat/ChatMessages/ChatMessage/ChatMessageToolCall/parsers/write-file';
+import { parseEditFileMeta } from '$lib/components/app/chat/ChatMessages/ChatMessage/ChatMessageToolCall/parsers/edit-file';
+import { parseReadFileMeta } from '$lib/components/app/chat/ChatMessages/ChatMessage/ChatMessageToolCall/parsers/read-file';
+import { parseGrepSearchMeta } from '$lib/components/app/chat/ChatMessages/ChatMessage/ChatMessageToolCall/parsers/grep-search';
+import { parseFileGlobSearchMeta } from '$lib/components/app/chat/ChatMessages/ChatMessage/ChatMessageToolCall/parsers/file-glob-search';
+import { parseRunJavascriptMeta } from '$lib/components/app/chat/ChatMessages/ChatMessage/ChatMessageToolCall/parsers/run-javascript';
+import { parseExecShellCommandMeta } from '$lib/components/app/chat/ChatMessages/ChatMessage/ChatMessageToolCall/parsers/exec-shell-command';
+
+function makeSection(
+	overrides: Partial<AgenticSection> = {},
+	toolName = BuiltInTool.READ_FILE
+): AgenticSection {
+	return {
+		type: AgenticSectionType.TOOL_CALL,
+		content: '',
+		toolName,
+		toolArgs: JSON.stringify({ path: '/foo.txt' }),
+		toolResult: undefined,
+		...overrides
+	};
+}
+
+describe('parseToolArgs (shared)', () => {
+	it('returns null when the section has no toolArgs', () => {
+		const result = parseToolArgs(BuiltInTool.READ_FILE, makeSection({ toolArgs: undefined }));
+		expect(result).toBeNull();
+	});
+
+	it('returns null when the tool name does not match', () => {
+		const result = parseToolArgs(
+			BuiltInTool.READ_FILE,
+			makeSection({ toolArgs: '{"path":"/x"}' }, BuiltInTool.WRITE_FILE)
+		);
+		expect(result).toBeNull();
+	});
+
+	it('returns null when args are not valid final JSON (partial: false)', () => {
+		const result = parseToolArgs(
+			BuiltInTool.READ_FILE,
+			makeSection({ toolArgs: '{"path": "/foo.tx' })
+		);
+		expect(result).toBeNull();
+	});
+
+	it('returns parsed args when valid final JSON', () => {
+		const result = parseToolArgs(
+			BuiltInTool.READ_FILE,
+			makeSection({ toolArgs: '{"path":"/foo.txt"}' })
+		);
+		expect(result).toEqual({ path: '/foo.txt' });
+	});
+
+	it('accepts partial JSON when partial: true', () => {
+		const result = parseToolArgs(
+			BuiltInTool.READ_FILE,
+			makeSection({ toolArgs: '{"path": "/foo.tx' }),
+			{ partial: true }
+		);
+		expect(result).toEqual({ path: '/foo.tx' });
+	});
+});
+
+describe('parseWriteFileMeta', () => {
+	it('returns null for sections with a different tool name', () => {
+		expect(
+			parseWriteFileMeta(
+				makeSection({ toolName: BuiltInTool.READ_FILE, toolArgs: '{"path":"/x","content":"y"}' })
+			)
+		).toBeNull();
+	});
+
+	it('returns null when args have no path-like field', () => {
+		expect(
+			parseWriteFileMeta(
+				makeSection({ toolName: BuiltInTool.WRITE_FILE, toolArgs: '{"content":"x"}' })
+			)
+		).toBeNull();
+	});
+
+	it('accepts partial args (renders incrementally as content streams in)', () => {
+		const meta = parseWriteFileMeta(
+			makeSection({ toolName: BuiltInTool.WRITE_FILE, toolArgs: '{"path":"/foo.t' })
+		);
+		expect(meta?.filePath).toBe('/foo.t');
+	});
+
+	it('returns file path, language, content, bytes, resultMessage', () => {
+		const meta = parseWriteFileMeta(
+			makeSection(
+				{
+					toolName: BuiltInTool.WRITE_FILE,
+					toolArgs: '{"path":"/foo.ts","content":"x"}',
+					toolResult: '{"result":"wrote","bytes":42}'
+				},
+				BuiltInTool.WRITE_FILE
+			)
+		);
+		expect(meta).toMatchObject<Partial<WriteFileMeta>>({
+			filePath: '/foo.ts',
+			language: expect.any(String),
+			content: 'x',
+			bytesWritten: 42,
+			resultMessage: 'wrote'
+		});
+	});
+
+	it('surfaces errorMessage from the result blob', () => {
+		const meta = parseWriteFileMeta(
+			makeSection({
+				toolName: BuiltInTool.WRITE_FILE,
+				toolArgs: '{"path":"/foo","content":"x"}',
+				toolResult: '{"error":"permission denied"}'
+			})
+		);
+		expect(meta?.errorMessage).toBe('permission denied');
+	});
+});
+
+describe('parseEditFileMeta', () => {
+	it('parses edits array and applies editsApplied from the result', () => {
+		const section = makeSection(
+			{
+				toolName: BuiltInTool.EDIT_FILE,
+				toolArgs:
+					'{"path":"/foo.ts","edits":[{"old_text":"a","new_text":"b"},{"old_text":"c","new_text":"d"}]}',
+				toolResult: '{"result":"ok","edits_applied":2}'
+			},
+			BuiltInTool.EDIT_FILE
+		);
+		const meta = parseEditFileMeta(section);
+		expect(meta?.edits).toEqual([
+			{ oldText: 'a', newText: 'b' },
+			{ oldText: 'c', newText: 'd' }
+		]);
+		expect(meta?.editsApplied).toBe(2);
+		expect(meta?.resultMessage).toBe('ok');
+	});
+
+	it('drops edits with empty old_text', () => {
+		const section = makeSection(
+			{
+				toolName: BuiltInTool.EDIT_FILE,
+				toolArgs: '{"path":"/foo","edits":[{"old_text":""},{"old_text":"a","new_text":""}]}'
+			},
+			BuiltInTool.EDIT_FILE
+		);
+		const meta = parseEditFileMeta(section);
+		// First entry is dropped (empty old_text). Second is kept
+		// (empty new_text is fine - it's the "delete" case).
+		expect(meta?.edits).toEqual([{ oldText: 'a', newText: '' }]);
+	});
+
+	it('errorMessage wins over result message', () => {
+		const section = makeSection(
+			{
+				toolName: BuiltInTool.EDIT_FILE,
+				toolArgs: '{"path":"/foo"}',
+				toolResult: '{"error":"bad path","result":"ok"}'
+			},
+			BuiltInTool.EDIT_FILE
+		);
+		const meta = parseEditFileMeta(section);
+		expect(meta?.errorMessage).toBe('bad path');
+		expect(meta?.resultMessage).toBeUndefined();
+	});
+});
+
+describe('parseReadFileMeta', () => {
+	it('parses file name alone (no range)', () => {
+		const meta = parseReadFileMeta(
+			makeSection({ toolArgs: '{"path":"/foo.txt"}' }, BuiltInTool.READ_FILE)
+		);
+		expect(meta?.fileName).toBe('foo.txt');
+		expect(meta?.lineRange).toBeNull();
+	});
+
+	it('parses start_line + end_line into a range', () => {
+		const meta = parseReadFileMeta(
+			makeSection(
+				{ toolArgs: '{"path":"/foo.ts","start_line":10,"end_line":20}' },
+				BuiltInTool.READ_FILE
+			)
+		);
+		expect(meta?.lineRange).toEqual({ start: 10, end: 20 });
+	});
+
+	it('parses start_line + line_count into a range', () => {
+		const meta = parseReadFileMeta(
+			makeSection(
+				{ toolArgs: '{"path":"/foo.ts","start_line":10,"line_count":5}' },
+				BuiltInTool.READ_FILE
+			)
+		);
+		expect(meta?.lineRange).toEqual({ start: 10, end: 14 });
+	});
+
+	it('returns null when args cannot be parsed', () => {
+		expect(parseReadFileMeta(makeSection({ toolArgs: '{bad' }, BuiltInTool.READ_FILE))).toBeNull();
+	});
+});
+
+describe('parseGrepSearchMeta', () => {
+	it('returns null when path or pattern is missing', () => {
+		expect(
+			parseGrepSearchMeta(
+				makeSection({ toolName: BuiltInTool.GREP_SEARCH, toolArgs: '{"pattern":"foo"}' })
+			)
+		).toBeNull();
+		expect(
+			parseGrepSearchMeta(
+				makeSection({ toolName: BuiltInTool.GREP_SEARCH, toolArgs: '{"path":"/x"}' })
+			)
+		).toBeNull();
+	});
+
+	it('parses structured plain_text_response into matches', () => {
+		const meta = parseGrepSearchMeta(
+			makeSection(
+				{
+					toolName: BuiltInTool.GREP_SEARCH,
+					toolArgs: '{"path":"/x","pattern":"foo"}',
+					toolResult: JSON.stringify({ plain_text_response: 'a.ts:hello\nb.ts:world' })
+				},
+				BuiltInTool.GREP_SEARCH
+			)
+		);
+		expect(meta?.matches).toHaveLength(2);
+		expect(meta?.matches[0]).toEqual({ file: 'a.ts', content: 'hello' });
+	});
+
+	it('falls back to raw-text parsing when result is not JSON', () => {
+		const meta = parseGrepSearchMeta(
+			makeSection(
+				{
+					toolName: BuiltInTool.GREP_SEARCH,
+					toolArgs: '{"path":"/x","pattern":"foo"}',
+					toolResult: 'a.ts:hello\nb.ts:world'
+				},
+				BuiltInTool.GREP_SEARCH
+			)
+		);
+		expect(meta?.matches).toHaveLength(2);
+	});
+
+	it('parses line numbers when return_line_numbers is true', () => {
+		const meta = parseGrepSearchMeta(
+			makeSection(
+				{
+					toolName: BuiltInTool.GREP_SEARCH,
+					toolArgs: '{"path":"/x","pattern":"foo","return_line_numbers":true}',
+					toolResult: 'a.ts:12:hello'
+				},
+				BuiltInTool.GREP_SEARCH
+			)
+		);
+		expect(meta?.matches[0]).toEqual({ file: 'a.ts', line: 12, content: 'hello' });
+		expect(meta?.showLineNumbers).toBe(true);
+	});
+});
+
+describe('parseFileGlobSearchMeta', () => {
+	it('falls back to raw-text parsing when result is not JSON', () => {
+		const meta = parseFileGlobSearchMeta(
+			makeSection(
+				{
+					toolName: BuiltInTool.FILE_GLOB_SEARCH,
+					toolArgs: '{"path":"/x"}',
+					toolResult: 'a.ts\nb.ts'
+				},
+				BuiltInTool.FILE_GLOB_SEARCH
+			)
+		);
+		expect(meta?.matches).toEqual(['a.ts', 'b.ts']);
+	});
+
+	it('parses plain_text_response from a JSON object', () => {
+		const meta = parseFileGlobSearchMeta(
+			makeSection(
+				{
+					toolName: BuiltInTool.FILE_GLOB_SEARCH,
+					toolArgs: '{"path":"/x"}',
+					toolResult: JSON.stringify({ plain_text_response: 'a.ts\nb.ts' })
+				},
+				BuiltInTool.FILE_GLOB_SEARCH
+			)
+		);
+		expect(meta?.matches).toEqual(['a.ts', 'b.ts']);
+	});
+
+	it('surfaces errorMessage from the result blob', () => {
+		const meta = parseFileGlobSearchMeta(
+			makeSection(
+				{
+					toolName: BuiltInTool.FILE_GLOB_SEARCH,
+					toolArgs: '{"path":"/x"}',
+					toolResult: JSON.stringify({ error: 'permission denied' })
+				},
+				BuiltInTool.FILE_GLOB_SEARCH
+			)
+		);
+		expect(meta?.errorMessage).toBe('permission denied');
+	});
+});
+
+describe('parseRunJavascriptMeta', () => {
+	it('returns null when code is missing', () => {
+		expect(
+			parseRunJavascriptMeta(makeSection({ toolName: BuiltInTool.RUN_JAVASCRIPT, toolArgs: '{}' }))
+		).toBeNull();
+	});
+
+	it('reads code and timeout', () => {
+		const meta = parseRunJavascriptMeta(
+			makeSection(
+				{ toolName: BuiltInTool.RUN_JAVASCRIPT, toolArgs: '{"code":"Math.PI","timeout_ms":5000}' },
+				BuiltInTool.RUN_JAVASCRIPT
+			)
+		);
+		expect(meta?.code).toBe('Math.PI');
+		expect(meta?.timeoutMs).toBe(5000);
+	});
+
+	it('reads error field from a JSON-object result', () => {
+		const meta = parseRunJavascriptMeta(
+			makeSection(
+				{
+					toolName: BuiltInTool.RUN_JAVASCRIPT,
+					toolArgs: '{"code":"throw new Error()"}',
+					toolResult: JSON.stringify({ error: 'undefined is not a function' })
+				},
+				BuiltInTool.RUN_JAVASCRIPT
+			)
+		);
+		expect(meta?.errorMessage).toBe('undefined is not a function');
+	});
+
+	it('does NOT treat a JSON-array result as an error', () => {
+		// SandboxService returns successful output as a JSON array;
+		// only JSON objects carry `error`. Raw arrays must round-trip
+		// through unchanged.
+		const meta = parseRunJavascriptMeta(
+			makeSection(
+				{
+					toolName: BuiltInTool.RUN_JAVASCRIPT,
+					toolArgs: '{"code":"[1,2,3]"}',
+					toolResult: '[1,2,3]'
+				},
+				BuiltInTool.RUN_JAVASCRIPT
+			)
+		);
+		expect(meta?.errorMessage).toBeUndefined();
+	});
+
+	it('scans a non-JSON string result for an `Error:` line', () => {
+		const meta = parseRunJavascriptMeta(
+			makeSection(
+				{
+					toolName: BuiltInTool.RUN_JAVASCRIPT,
+					toolArgs: '{"code":"foo"}',
+					toolResult: 'Error: undefined is not a function\n  at <anonymous>:1:1'
+				},
+				BuiltInTool.RUN_JAVASCRIPT
+			)
+		);
+		expect(meta?.errorMessage).toBe('undefined is not a function');
+	});
+});
+
+describe('parseExecShellCommandMeta', () => {
+	it('reads command from the args', () => {
+		const meta = parseExecShellCommandMeta(
+			makeSection(
+				{ toolName: BuiltInTool.EXEC_SHELL_COMMAND, toolArgs: '{"command":"ls -la"}' },
+				BuiltInTool.EXEC_SHELL_COMMAND
+			)
+		);
+		expect(meta?.command).toBe('ls -la');
+	});
+
+	it('accepts cmd / shell_command aliases', () => {
+		expect(
+			parseExecShellCommandMeta(
+				makeSection(
+					{ toolName: BuiltInTool.EXEC_SHELL_COMMAND, toolArgs: '{"cmd":"ls"}' },
+					BuiltInTool.EXEC_SHELL_COMMAND
+				)
+			)?.command
+		).toBe('ls');
+		expect(
+			parseExecShellCommandMeta(
+				makeSection(
+					{ toolName: BuiltInTool.EXEC_SHELL_COMMAND, toolArgs: '{"shell_command":"ls"}' },
+					BuiltInTool.EXEC_SHELL_COMMAND
+				)
+			)?.command
+		).toBe('ls');
+	});
+
+	it('returns null when no command alias is present', () => {
+		expect(
+			parseExecShellCommandMeta(
+				makeSection(
+					{ toolName: BuiltInTool.EXEC_SHELL_COMMAND, toolArgs: '{"cwd":"/x"}' },
+					BuiltInTool.EXEC_SHELL_COMMAND
+				)
+			)
+		).toBeNull();
+	});
+});

tools/ui/tests/unit/uri-template.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect } from 'vitest';
+import {
+	extractTemplateVariables,
+	expandTemplate,
+	isTemplateComplete,
+	normalizeResourceUri
+} from '../../src/lib/utils/uri-template';
+import { URI_TEMPLATE_OPERATORS } from '../../src/lib/constants/uri-template';
+
+describe('extractTemplateVariables', () => {
+	it('extracts simple variables', () => {
+		const vars = extractTemplateVariables('file:///{path}');
+		expect(vars).toEqual([{ name: 'path', operator: '' }]);
+	});
+
+	it('extracts multiple variables', () => {
+		const vars = extractTemplateVariables('db://{schema}/{table}');
+		expect(vars).toEqual([
+			{ name: 'schema', operator: '' },
+			{ name: 'table', operator: '' }
+		]);
+	});
+
+	it('extracts variables with operators', () => {
+		const vars = extractTemplateVariables('http://example.com{+path}');
+		expect(vars).toEqual([{ name: 'path', operator: URI_TEMPLATE_OPERATORS.RESERVED }]);
+	});
+
+	it('extracts comma-separated variable lists', () => {
+		const vars = extractTemplateVariables('{x,y,z}');
+		expect(vars).toEqual([
+			{ name: 'x', operator: '' },
+			{ name: 'y', operator: '' },
+			{ name: 'z', operator: '' }
+		]);
+	});
+
+	it('deduplicates variable names', () => {
+		const vars = extractTemplateVariables('{name}/{name}');
+		expect(vars).toEqual([{ name: 'name', operator: '' }]);
+	});
+
+	it('handles fragment expansion', () => {
+		const vars = extractTemplateVariables('http://example.com/page{#section}');
+		expect(vars).toEqual([{ name: 'section', operator: URI_TEMPLATE_OPERATORS.FRAGMENT }]);
+	});
+
+	it('handles path segment expansion', () => {
+		const vars = extractTemplateVariables('http://example.com{/path}');
+		expect(vars).toEqual([{ name: 'path', operator: URI_TEMPLATE_OPERATORS.PATH_SEGMENT }]);
+	});
+
+	it('returns empty array for template without variables', () => {
+		const vars = extractTemplateVariables('http://example.com/static');
+		expect(vars).toEqual([]);
+	});
+
+	it('strips explode modifier', () => {
+		const vars = extractTemplateVariables('{list*}');
+		expect(vars).toEqual([{ name: 'list', operator: '' }]);
+	});
+
+	it('strips prefix modifier', () => {
+		const vars = extractTemplateVariables('{value:5}');
+		expect(vars).toEqual([{ name: 'value', operator: '' }]);
+	});
+});
+
+describe('expandTemplate', () => {
+	it('expands simple variable', () => {
+		const result = expandTemplate('file:///{path}', { path: 'src/main.rs' });
+		expect(result).toBe('file:///src%2Fmain.rs');
+	});
+
+	it('expands reserved variable (no encoding)', () => {
+		const result = expandTemplate('file:///{+path}', { path: 'src/main.rs' });
+		expect(result).toBe('file:///src/main.rs');
+	});
+
+	it('expands multiple variables', () => {
+		const result = expandTemplate('db://{schema}/{table}', {
+			schema: 'public',
+			table: 'users'
+		});
+		expect(result).toBe('db://public/users');
+	});
+
+	it('leaves empty for missing variables', () => {
+		const result = expandTemplate('{missing}', {});
+		expect(result).toBe('');
+	});
+
+	it('expands fragment', () => {
+		const result = expandTemplate('http://example.com/page{#section}', {
+			section: 'intro'
+		});
+		expect(result).toBe('http://example.com/page#intro');
+	});
+
+	it('expands path segments', () => {
+		const result = expandTemplate('http://example.com{/path}', { path: 'docs' });
+		expect(result).toBe('http://example.com/docs');
+	});
+
+	it('expands query parameters', () => {
+		const result = expandTemplate('http://example.com{?q}', { q: 'search term' });
+		expect(result).toBe('http://example.com?q=search%20term');
+	});
+
+	it('expands multiple query parameters', () => {
+		const result = expandTemplate('http://example.com{?q,sort}', {
+			q: 'search term',
+			sort: 'descending'
+		});
+		expect(result).toBe('http://example.com?q=search%20term&sort=descending');
+	});
+
+	it('keeps static parts unchanged', () => {
+		const result = expandTemplate('http://example.com/static', {});
+		expect(result).toBe('http://example.com/static');
+	});
+});
+
+describe('isTemplateComplete', () => {
+	it('returns true when all variables are filled', () => {
+		expect(isTemplateComplete('file:///{path}', { path: 'test.txt' })).toBe(true);
+	});
+
+	it('returns false when a variable is missing', () => {
+		expect(isTemplateComplete('db://{schema}/{table}', { schema: 'public' })).toBe(false);
+	});
+
+	it('returns false when a variable is empty', () => {
+		expect(isTemplateComplete('file:///{path}', { path: '' })).toBe(false);
+	});
+
+	it('returns false when a variable is whitespace only', () => {
+		expect(isTemplateComplete('file:///{path}', { path: '   ' })).toBe(false);
+	});
+
+	it('returns true for template without variables', () => {
+		expect(isTemplateComplete('http://example.com/static', {})).toBe(true);
+	});
+
+	it('returns true when all multiple variables are filled', () => {
+		expect(isTemplateComplete('db://{schema}/{table}', { schema: 'public', table: 'users' })).toBe(
+			true
+		);
+	});
+});
+
+describe('normalizeResourceUri', () => {
+	it('passes through a normal URI unchanged', () => {
+		expect(normalizeResourceUri('svelte://svelte/$effect.md')).toBe('svelte://svelte/$effect.md');
+	});
+
+	it('normalizes triple-slash URIs from path-style template expansion', () => {
+		expect(normalizeResourceUri('svelte:///svelte/$effect.md')).toBe('svelte://svelte/$effect.md');
+	});
+
+	it('normalizes quadruple-slash URIs', () => {
+		expect(normalizeResourceUri('svelte:////svelte/$effect.md')).toBe('svelte://svelte/$effect.md');
+	});
+
+	it('handles file:// URIs', () => {
+		expect(normalizeResourceUri('file:///home/user/doc.txt')).toBe('file://home/user/doc.txt');
+	});
+
+	it('handles http URIs unchanged', () => {
+		expect(normalizeResourceUri('http://example.com/path')).toBe('http://example.com/path');
+	});
+
+	it('returns non-URI strings unchanged', () => {
+		expect(normalizeResourceUri('not-a-uri')).toBe('not-a-uri');
+	});
+});