kiku-agent 1.3.1 → 1.3.3

package/server/agent/tests/mcpClient.test.js

@@ -0,0 +1,201 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import os from 'node:os';
+import path from 'node:path';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+import { McpClientManager } from '../mcpClient.js';
+import { KikuAgent } from '../agentCore.js';
+import { routeCommand } from '../commands.js';
+import { PACKAGE_VERSION } from '../version.js';
+
+const stdioServerPath = fileURLToPath(new URL('../../mcp/stdio.js', import.meta.url));
+
+test('McpClientManager connects over stdio, discovers tools, and executes tool call', { timeout: 30_000 }, async () => {
+  const manager = new McpClientManager({ clientInfo: { name: 'kiku-agent-test', version: PACKAGE_VERSION }, autoLoad: false });
+
+  try {
+    const connResult = await manager.connect('local_kiku', {
+      command: process.execPath,
+      args: [stdioServerPath],
+      cwd: process.cwd(),
+    }, { persist: false });
+
+    assert.equal(connResult.success, true);
+    assert.equal(connResult.serverName, 'local_kiku');
+    assert.ok(connResult.toolsCount >= 10);
+
+    const schemas = manager.getToolsSchema();
+    assert.ok(schemas.length >= 10);
+    const searchTool = schemas.find(s => s.function.name === 'mcp_local_kiku_search_works');
+    assert.ok(searchTool, 'Tool should be registered with server namespace prefix');
+    assert.equal(searchTool.type, 'function');
+    assert.ok(searchTool.function.description.includes('[MCP Server: local_kiku]'));
+
+    const callResult = await manager.callTool('mcp_local_kiku_search_works', { year: 2026 });
+    assert.equal(callResult.status, 'success');
+    assert.equal(callResult.server, 'local_kiku');
+    assert.equal(callResult.tool, 'search_works');
+    assert.ok(callResult.count > 0);
+
+    
+    const directCall = await manager.callTool('search_works', { year: 2026 });
+    assert.equal(directCall.status, 'success');
+
+   
+    const status = manager.getStatus();
+    assert.equal(status.activeServersCount, 1);
+    assert.equal(status.servers[0].name, 'local_kiku');
+  } finally {
+    await manager.disconnectAll();
+  }
+});
+
+test('KikuAgent dynamically registers MCP tools into tool schema and system prompt', { timeout: 30_000 }, async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-mcp-agent-test-'));
+  const agent = new KikuAgent({
+    mcpManager: new McpClientManager({
+      autoLoad: false,
+      globalConfigPath: path.join(tempDir, 'mcp_servers.json'),
+    }),
+    client: {
+      provider: 'lmstudio',
+      model: 'test-model',
+      async chat() { return { role: 'assistant', content: 'test response' }; },
+      async checkConnection() { return { connected: true, models: ['test-model'] }; }
+    }
+  });
+  await agent.ready();
+
+  const initialToolsCount = agent.getAllToolsSchema().length;
+
+  try {
+    const conn = await agent.connectMcp('test_kiku', {
+      command: process.execPath,
+      args: [stdioServerPath],
+      cwd: process.cwd(),
+    });
+    assert.equal(conn.success, true);
+
+    const updatedTools = agent.getAllToolsSchema();
+    assert.ok(updatedTools.length > initialToolsCount);
+    assert.ok(updatedTools.some(t => t.function.name.startsWith('mcp_test_kiku_')));
+    assert.ok(agent.systemPrompt.includes('mcp_test_kiku_'));
+
+    
+    assert.equal(await routeCommand('/mcp status', { agent, sub: 'status' }), 'HANDLED');
+    assert.equal(await routeCommand('/mcp tools', { agent, sub: 'tools' }), 'HANDLED');
+
+    
+    const disconn = await agent.disconnectMcp('test_kiku');
+    assert.equal(disconn, true);
+    assert.equal(agent.getAllToolsSchema().length, initialToolsCount);
+  } finally {
+    await agent.mcpManager.disconnectAll();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('DynamicToolRouter pins tools mentioned with @ in the prompt with top priority', () => {
+  const agent = new KikuAgent({
+    mcpManager: new McpClientManager({ autoLoad: false }),
+    client: {
+      provider: 'lmstudio',
+      model: 'test-model',
+      async chat() { return { role: 'assistant', content: 'test response' }; },
+      async checkConnection() { return { connected: true, models: ['test-model'] }; }
+    }
+  });
+
+  const routed = agent.router.routeToolsForQuery('Please tell me about her works @search_works');
+  assert.ok(routed.length > 0);
+  assert.equal(routed[0].function.name, 'search_works');
+
+  const routedAwards = agent.router.routeToolsForQuery('@get_awards check all music awards');
+  assert.ok(routedAwards.length > 0);
+  assert.equal(routedAwards[0].function.name, 'get_awards');
+});
+
+test('McpClientManager persists configurations across disconnects and supports save/remove', async () => {
+  const manager = new McpClientManager({ autoLoad: false });
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-mcp-config-test-'));
+  const configPath = path.join(tempDir, 'mcp_servers.json');
+
+  try {
+    manager.persistedConfigs.set('test_server', {
+      type: 'streamable-http',
+      url: 'https://example.com/mcp',
+      enabled: true,
+    });
+
+    const status = manager.getStatus();
+    assert.equal(status.totalConfiguredCount, 1);
+    assert.equal(status.servers[0].name, 'test_server');
+    assert.equal(status.servers[0].status, 'saved_offline');
+
+    const saveRes = await manager.savePersistedConfig(configPath);
+    assert.equal(saveRes.success, true);
+    assert.equal(saveRes.filePath, configPath);
+    assert.ok(saveRes.count >= 1);
+    const saved = JSON.parse(await readFile(configPath, 'utf8'));
+    assert.equal(saved.mcpServers.test_server.url, 'https://example.com/mcp');
+
+    const removed = await manager.remove('test_server', { persist: false });
+    assert.equal(removed, true);
+    assert.equal(manager.persistedConfigs.has('test_server'), false);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('McpClientManager permanently removes a server from every loaded config source', async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-mcp-source-remove-test-'));
+  const globalConfigPath = path.join(tempDir, 'mcp_servers.json');
+  const workspaceConfigPath = path.join(tempDir, 'opencode.json');
+
+  await writeFile(globalConfigPath, JSON.stringify({
+    mcpServers: {
+      duplicate_server: { type: 'remote', url: 'https://global.example/mcp', enabled: false },
+      global_only: { type: 'remote', url: 'https://global-only.example/mcp', enabled: false },
+    },
+  }, null, 2));
+  await writeFile(workspaceConfigPath, JSON.stringify({
+    $schema: 'https://opencode.ai/config.json',
+    mcp: {
+      duplicate_server: { type: 'remote', url: 'https://workspace.example/mcp', enabled: false },
+      workspace_only: { type: 'remote', url: 'https://workspace-only.example/mcp', enabled: false },
+    },
+  }, null, 2));
+
+  const managerOptions = {
+    globalConfigPath,
+    configPaths: [globalConfigPath, workspaceConfigPath],
+  };
+
+  try {
+    const manager = new McpClientManager(managerOptions);
+    await manager.loadPersistedServers();
+
+    const before = manager.getStatus().servers.find(server => server.name === 'duplicate_server');
+    assert.ok(before);
+    assert.deepEqual(new Set(before.sources), new Set([globalConfigPath, workspaceConfigPath]));
+
+    assert.equal(await manager.remove('duplicate_server'), true);
+
+    const savedGlobal = JSON.parse(await readFile(globalConfigPath, 'utf8'));
+    const savedWorkspace = JSON.parse(await readFile(workspaceConfigPath, 'utf8'));
+    assert.equal(savedGlobal.mcpServers.duplicate_server, undefined);
+    assert.equal(savedWorkspace.mcp.duplicate_server, undefined);
+    assert.ok(savedGlobal.mcpServers.global_only);
+    assert.ok(savedWorkspace.mcp.workspace_only);
+    assert.equal(savedWorkspace.$schema, 'https://opencode.ai/config.json');
+
+    const restartedManager = new McpClientManager(managerOptions);
+    await restartedManager.loadPersistedServers();
+    assert.equal(restartedManager.persistedConfigs.has('duplicate_server'), false);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+

package/server/agent/tests/memoryRoute.test.js

@@ -0,0 +1,173 @@
+import test, { after } from 'node:test';
+import assert from 'node:assert/strict';
+import { Readable } from 'node:stream';
+import { EventEmitter } from 'node:events';
+import { AgentMemory } from '../memory.js';
+import { setMemoryStore, handleMemoryGetRoute, handleMemoryActionRoute } from '../../web-chat/routes/memoryRoute.js';
+
+function request(body, headers = {}) {
+  const req = Readable.from([JSON.stringify(body === undefined ? {} : body)]);
+  req.socket = { remoteAddress: '127.0.0.1' };
+  req.headers = headers;
+  return req;
+}
+
+function response() {
+  const res = new EventEmitter();
+  res.chunks = '';
+  res.writeHead = (code) => { res.statusCode = code; res.headersSent = true; };
+  res.write = (data) => { res.chunks += data; };
+  res.end = (data = '') => { res.chunks += data; res.writableEnded = true; res.emit('finish'); };
+  res.json = () => JSON.parse(res.chunks);
+  return res;
+}
+
+function freshStore() {
+  setMemoryStore(new AgentMemory({ persistence: false }));
+}
+
+async function getJson() {
+  const res = response();
+  await handleMemoryGetRoute(request(), res);
+  assert.equal(res.statusCode, 200);
+  return res.json();
+}
+
+async function postJson(body, headers = {}) {
+  const res = response();
+  await handleMemoryActionRoute(request(body, headers), res);
+  return { status: res.statusCode, body: res.chunks ? res.json() : null };
+}
+
+test('memory GET reports empty store with persistence flag', async () => {
+  freshStore();
+  const data = await getJson();
+  assert.equal(data.status, 'ok');
+  assert.equal(data.factsCount, 0);
+  assert.equal(data.persistent, false);
+  assert.deepEqual(data.facts, []);
+  assert.deepEqual(data.topTopics, []);
+});
+
+test('memory add stores, lists, searches and deletes facts', async () => {
+  freshStore();
+  const added = await postJson({ action: 'add', content: 'ผู้ใช้ชื่นชอบซีรีส์ In Blossom', category: 'drama', tags: ['In Blossom'] });
+  assert.equal(added.status, 200);
+  assert.ok(added.body.fact.id);
+  assert.equal(added.body.fact.category, 'drama');
+  assert.ok(added.body.fact.createdAt);
+
+  const listed = await getJson();
+  assert.equal(listed.factsCount, 1);
+  assert.equal(listed.factsByCategory.drama, 1);
+
+  const found = await postJson({ action: 'search', query: 'Blossom' });
+  assert.equal(found.status, 200);
+  assert.equal(found.body.count, 1);
+
+  const missed = await postJson({ action: 'search', query: 'Versace' });
+  assert.equal(missed.body.count, 0);
+
+  const removed = await postJson({ action: 'delete', id: added.body.fact.id });
+  assert.equal(removed.status, 200);
+  assert.equal((await getJson()).factsCount, 0);
+});
+
+test('memory add/delete validate input strictly', async () => {
+  freshStore();
+  assert.equal((await postJson({ action: 'add', content: '   ' })).status, 400);
+  assert.equal((await postJson({ action: 'add', content: 'x'.repeat(2001) })).status, 400);
+  assert.equal((await postJson({ action: 'delete', id: 'bad id!' })).status, 400);
+  assert.equal((await postJson({ action: 'delete', id: 'fact_missing' })).status, 404);
+  assert.equal((await postJson({ action: 'unknown-op' })).status, 400);
+});
+
+test('memory preserves raw content verbatim for UI-side escaping', async () => {
+  freshStore();
+  const evil = '<script>alert(1)</script>';
+  const added = await postJson({ action: 'add', content: evil });
+  assert.equal(added.status, 200);
+  assert.equal(added.body.fact.content, evil);
+});
+
+test('memory GET enriches archived sessions with preview and topics', async () => {
+  freshStore();
+  const data = await getJson();
+  assert.deepEqual(data.sessions, []);
+});
+
+test('memory session_summary returns 400/404 for invalid or unknown ids', async () => {
+  freshStore();
+  assert.equal((await postJson({ action: 'session_summary' })).status, 400);
+  assert.equal((await postJson({ action: 'session_summary', sessionId: 'bad id!' })).status, 400);
+  assert.equal((await postJson({ action: 'session_summary', sessionId: 'sess_missing' })).status, 404);
+});
+
+test('memory session_summary builds exchanges from an archived session on disk', async () => {
+  freshStore();
+  const mem = new AgentMemory({ persistence: false });
+  mem.sessions = [{
+    id: 'sess_live_1',
+    createdAt: new Date('2026-09-15T10:00:00Z'),
+    endedAt: new Date('2026-09-15T10:05:00Z'),
+    messageCount: 2,
+    summary: null,
+  }];
+  mem.loadArchivedSession = async (sessionId) => {
+    assert.equal(sessionId, 'sess_live_1');
+    return {
+      id: 'sess_live_1',
+      createdAt: new Date('2026-09-15T10:00:00Z'),
+      endedAt: new Date('2026-09-15T10:05:00Z'),
+      stats: { totalDurationMs: 65400, totalToolCalls: 2 },
+      messages: [
+        { role: 'user', parts: [{ type: 'text', content: 'In Blossom ออกปีไหน' }] },
+        { role: 'assistant', parts: [{ type: 'text', content: 'ออกอากาศปี 2024 ค่ะ' }] },
+      ],
+    };
+  };
+  setMemoryStore(mem);
+  const result = await postJson({ action: 'session_summary', sessionId: 'sess_live_1' });
+  assert.equal(result.status, 200);
+  assert.equal(result.body.status, 'ok');
+  assert.equal(result.body.sessionId, 'sess_live_1');
+  assert.equal(result.body.messageCount, 2);
+  assert.equal(result.body.stats.totalToolCalls, 2);
+  assert.equal(result.body.summary.questionCount, 1);
+  assert.equal(result.body.summary.durationMs, 65400);
+  assert.equal(result.body.summary.keyExchanges.length, 1);
+  assert.equal(result.body.summary.keyExchanges[0].question, 'In Blossom ออกปีไหน');
+  assert.equal(result.body.summary.keyExchanges[0].answerPreview, 'ออกอากาศปี 2024 ค่ะ');
+});
+
+test('memory export returns a downloadable snapshot', async () => {
+  freshStore();
+  await postJson({ action: 'add', content: 'fact one' });
+  const exported = await postJson({ action: 'export' });
+  assert.equal(exported.status, 200);
+  assert.ok(exported.body.exportedAt);
+  assert.equal(exported.body.facts.length, 1);
+  assert.equal(exported.body.facts[0].content, 'fact one');
+});
+
+test('memory clear requires an admin key', async () => {
+  freshStore();
+  await postJson({ action: 'add', content: 'fact one' });
+  const origAdminKey = process.env.WEBCHAT_ADMIN_KEY;
+  process.env.WEBCHAT_ADMIN_KEY = 'mem-route-test-admin';
+  try {
+    assert.equal((await postJson({ action: 'clear' })).status, 401);
+    assert.equal((await postJson({ action: 'clear' }, { 'x-api-key': 'wrong' })).status, 401);
+    assert.equal((await getJson()).factsCount, 1);
+    const cleared = await postJson({ action: 'clear' }, { 'x-api-key': 'mem-route-test-admin' });
+    assert.equal(cleared.status, 200);
+    assert.equal((await getJson()).factsCount, 0);
+  } finally {
+    if (origAdminKey !== undefined) process.env.WEBCHAT_ADMIN_KEY = origAdminKey;
+    else delete process.env.WEBCHAT_ADMIN_KEY;
+  }
+});
+
+after(() => {
+  setMemoryStore(new AgentMemory({ persistence: false }));
+});

package/server/agent/tests/memoryUiNormalization.test.js

@@ -0,0 +1,75 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+import { getSettingsHtml } from '../../web-chat/ui/settingsBuilder.js';
+
+test('memory session fields use normalized wrappers and fluid responsive classes', async () => {
+  const html = getSettingsHtml();
+  const css = await readFile(new URL('../../web-chat/ui/styles/main.css', import.meta.url), 'utf8');
+
+  assert.match(html, /class="memory-input-layout memory-input-layout--textarea"/);
+  assert.match(html, /class="memory-input-layout memory-search-field"/);
+  assert.match(html, /id="mem-search" class="form-control memory-field"/);
+  assert.doesNotMatch(html, /id="mem-search"[^>]+min-width:\s*200px/);
+  assert.match(css, /#tab-memory \.memory-field::placeholder[\s\S]*line-height:\s*1\.45/);
+  assert.match(css, /#tab-memory input\.memory-field::placeholder[\s\S]*text-overflow:\s*ellipsis/);
+  assert.match(css, /#tab-memory textarea\.memory-field[\s\S]*line-height:\s*1\.6/);
+  assert.match(css, /#tab-memory \.memory-field \{[\s\S]*min-inline-size:\s*0/);
+  assert.match(css, /padding:\s*0\.625rem 0\.875rem/);
+  assert.match(css, /@media \(max-width:\s*40rem\)[\s\S]*grid-template-columns:\s*minmax\(0, 1fr\)/);
+});
+
+test('memory sessions browser ships session list, filter chips and i18n strings', async () => {
+  const html = getSettingsHtml();
+  const css = await readFile(new URL('../../web-chat/ui/styles/main.css', import.meta.url), 'utf8');
+
+  assert.match(html, /id="mem-sessions-list" class="mem-sessions"/);
+  assert.match(html, /id="mem-category-filter" class="mem-category-filter"/);
+  assert.match(html, /onclick="loadMemorySessions\(true\)"/);
+  assert.match(html, /toggleMemorySession\(this\.dataset\.sessionId\)/);
+  assert.match(html, /filterMemoryFactsByCategory\(this\.dataset\.cat\)/);
+  assert.match(html, /cardTitleMemSessions/);
+  assert.match(html, /memSessionsEmpty/);
+
+  assert.match(css, /#tab-memory \.mem-sessions \{[\s\S]*?flex-direction:\s*column/);
+  assert.match(css, /#tab-memory \.mem-session \{[\s\S]*?border-radius:\s*14px/);
+  assert.match(css, /#tab-memory \.mem-session-head \{[\s\S]*?cursor:\s*pointer/);
+  assert.match(css, /#tab-memory \.mem-session-detail-wrap \{[\s\S]*?border-top:\s*1px dashed/);
+  assert.match(css, /#tab-memory \.mem-filter-chip \{[\s\S]*?border-radius:\s*999px/);
+  assert.match(css, /#tab-memory \.mem-sessions-empty \{[\s\S]*?border:\s*1px dashed/);
+});
+
+test('memory sessions use spaced layout classes instead of cramped inline styles', async () => {
+  const html = getSettingsHtml();
+  const css = await readFile(new URL('../../web-chat/ui/styles/main.css', import.meta.url), 'utf8');
+
+  assert.match(html, /id="mem-status-grid" class="mem-stats"/);
+  assert.match(html, /id="mem-topics" class="mem-topics"/);
+  assert.match(html, /id="mem-facts-list" class="mem-facts"/);
+  assert.match(html, /class="[^"]*\bmem-fact-content\b/);
+  assert.match(html, /class="[^"]*\bmem-fact-meta\b/);
+  assert.match(html, /class="[^"]*\bmem-topic-chip\b/);
+  assert.doesNotMatch(html, /id="mem-facts-list"[^>]*style=/);
+  assert.doesNotMatch(html, /id="mem-status-grid"[^>]*style=/);
+
+  assert.match(css, /#tab-memory \.mem-stats \{[\s\S]*?gap:\s*14px/);
+  assert.match(css, /#tab-memory \.mem-stat \{[\s\S]*?padding:\s*16px 18px/);
+  assert.match(css, /#tab-memory \.mem-stat-value \{[\s\S]*?margin-top:\s*8px/);
+  assert.match(css, /#tab-memory \.mem-topics \{[\s\S]*?gap:\s*10px/);
+  assert.match(css, /#tab-memory \.mem-topic-chip \{[\s\S]*?padding:\s*6px 14px/);
+  assert.match(css, /#tab-memory \.mem-facts \{[\s\S]*?gap:\s*12px/);
+  assert.match(css, /#tab-memory \.mem-fact \{[\s\S]*?padding:\s*16px 18px/);
+  assert.match(css, /#tab-memory \.mem-fact-main \{[\s\S]*?gap:\s*14px/);
+  assert.match(css, /#tab-memory \.mem-fact-content \{[\s\S]*?line-height:\s*1\.7/);
+  assert.match(css, /#tab-memory \.mem-fact-meta \{[\s\S]*?margin-top:\s*12px/);
+  assert.match(css, /#tab-memory \.mem-actions \{[\s\S]*?margin-top:\s*18px/);
+  assert.match(css, /#tab-memory \.form-label \{[\s\S]*?margin-bottom:\s*8px/);
+});
+
+test('LM Studio settings default Gemma sessions to a 32K loaded context and one parallel slot', () => {
+  const html = getSettingsHtml();
+  assert.match(html, /id="cfg-lms-context"[^>]+value="32768"/);
+  assert.match(html, /id="cfg-cpu-threads"[^>]+value="1"/);
+  assert.match(html, /id="cfg-context-limit"[^>]+value="32768"/);
+});

package/server/agent/tests/modelCompatibility.test.js

@@ -0,0 +1,148 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { LLMClient } from '../llmClient.js';
+import { getModelCompatibility, normalizeAssistantMessage, StreamContentNormalizer } from '../modelCompatibility.js';
+
+test('model compatibility registry selects profiles for major model families', () => {
+  assert.equal(getModelCompatibility('vllm', 'Qwen/Qwen3-8B').id, 'qwen3');
+  assert.equal(getModelCompatibility('vllm', 'Qwen/Qwen3-Coder-30B').toolProtocol, 'qwen3-xml');
+  assert.equal(getModelCompatibility('vllm', 'deepseek-ai/DeepSeek-R1').reasoningProtocol, 'deepseek');
+  assert.equal(getModelCompatibility('vllm', 'meta-llama/Llama-3.1-8B-Instruct').toolProtocol, 'llama-json');
+  assert.equal(getModelCompatibility('vllm', 'mistralai/Mistral-7B-Instruct-v0.3').toolProtocol, 'mistral');
+});
+
+test('normalizer converts legacy function calls and tagged Qwen calls', () => {
+  const legacy = normalizeAssistantMessage({
+    role: 'assistant',
+    content: 'answer',
+    function_call: { name: 'search_works', arguments: { query: 'In Blossom' } }
+  });
+  assert.equal(legacy.tool_calls[0].function.name, 'search_works');
+  assert.deepEqual(JSON.parse(legacy.tool_calls[0].function.arguments), { query: 'In Blossom' });
+
+  const qwen = normalizeAssistantMessage({
+    role: 'assistant',
+    content: '<tool_call>{"name":"search_works","arguments":{"query":"In Blossom"}}</tool_call>'
+  });
+  assert.equal(qwen.tool_calls[0].function.name, 'search_works');
+  assert.equal(qwen.content, '');
+});
+
+test('normalizer keeps reasoning separate from Qwen think content', () => {
+  const result = normalizeAssistantMessage({
+    role: 'assistant',
+    content: '<think>internal plan</think>Final answer'
+  });
+  assert.equal(result.reasoning_content, 'internal plan');
+  assert.equal(result.content, 'Final answer');
+});
+
+test('stream content normalizer handles split think tags and flushes final content', () => {
+  const normalizer = new StreamContentNormalizer();
+  assert.deepEqual(normalizer.push('Before <th'), { answer: 'Before ', reasoning: '' });
+  assert.deepEqual(normalizer.push('ink>hidden</think>After'), { answer: 'After', reasoning: 'hidden' });
+  assert.deepEqual(normalizer.flush(), { answer: '', reasoning: '' });
+});
+
+test('LLMClient applies Qwen3 thinking request options only when requested', async () => {
+  const client = new LLMClient({ provider: 'vllm', model: 'Qwen/Qwen3-8B', baseUrl: 'http://127.0.0.1:8000/v1' });
+  const originalFetch = globalThis.fetch;
+  let request;
+  globalThis.fetch = async (url, options) => {
+    request = JSON.parse(options.body);
+    return new Response(JSON.stringify({ choices: [{ message: { role: 'assistant', content: 'ok' } }] }), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' }
+    });
+  };
+  try {
+    await client.chat([{ role: 'user', content: 'hello' }], { stream: false, thinkingMode: 'hide' });
+    assert.deepEqual(request.chat_template_kwargs, { enable_thinking: false });
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('LLMClient flushes a final SSE event without a trailing newline', async () => {
+  const client = new LLMClient({ provider: 'vllm', model: 'Qwen/Qwen2.5-7B-Instruct', baseUrl: 'http://127.0.0.1:8000/v1' });
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => {
+    const body = `data: ${JSON.stringify({ choices: [{ delta: { content: 'final' } }] })}`;
+    const stream = new ReadableStream({ start(controller) { controller.enqueue(new TextEncoder().encode(body)); controller.close(); } });
+    return new Response(stream, { status: 200, headers: { 'Content-Type': 'text/event-stream' } });
+  };
+  try {
+    const result = await client.chat([{ role: 'user', content: 'hello' }], { stream: true });
+    assert.equal(result.content, 'final');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('normalizer converts Meta Llama 3.1+ Pythonic tool calls', () => {
+  const llama = normalizeAssistantMessage({
+    role: 'assistant',
+    content: '<|python_tag|>search_works(query="In Blossom", limit=5, verified=true)'
+  });
+  assert.equal(llama.tool_calls.length, 1);
+  assert.equal(llama.tool_calls[0].function.name, 'search_works');
+  const args = JSON.parse(llama.tool_calls[0].function.arguments);
+  assert.equal(args.query, 'In Blossom');
+  assert.equal(args.limit, 5);
+  assert.equal(args.verified, true);
+  assert.equal(llama.content, '');
+});
+
+test('stream content normalizer suppresses tool tags from answer stream and buffers them', () => {
+  const normalizer = new StreamContentNormalizer();
+  const chunk1 = normalizer.push('Answer before <tool_');
+  assert.equal(chunk1.answer, 'Answer before ');
+
+  const chunk2 = normalizer.push('call>{"name":"search_works","arguments":{"query":"In Blossom"}}</tool_call> answer after');
+  assert.equal(chunk2.answer, ' answer after');
+  assert.equal(chunk2.reasoning, '');
+
+  const flushed = normalizer.flush();
+  assert.ok(flushed.toolCallBuffer.includes('search_works'));
+});
+
+test('toAnthropicMessages preserves extended thinking blocks and groups parallel tool results', async () => {
+  const { toAnthropicMessages, normalizeAnthropicResponse } = await import('../cloudAdapters.js');
+  
+  const normalized = normalizeAnthropicResponse({
+    content: [
+      { type: 'thinking', thinking: 'internal thought plan', signature: 'sig_abc123' },
+      { type: 'text', text: 'Calling tool now' },
+      { type: 'tool_use', id: 'toolu_1', name: 'search_works', input: { query: 'Ju Jingyi' } }
+    ]
+  });
+  assert.equal(normalized.thinking_blocks.length, 1);
+  assert.equal(normalized.thinking_blocks[0].signature, 'sig_abc123');
+
+  const history = [
+    { role: 'user', content: 'Who is Ju Jingyi?' },
+    normalized,
+    { role: 'tool', tool_call_id: 'toolu_1', content: JSON.stringify({ status: 'success', name: 'Ju Jingyi' }) },
+    { role: 'tool', tool_call_id: 'toolu_2', content: JSON.stringify({ status: 'error', error: 'not found' }) }
+  ];
+
+  const anthropic = toAnthropicMessages(history);
+ 
+  const asstMsg = anthropic.messages.find(m => m.role === 'assistant');
+  assert.ok(asstMsg);
+  assert.equal(asstMsg.content[0].type, 'thinking');
+  assert.equal(asstMsg.content[0].signature, 'sig_abc123');
+  assert.equal(asstMsg.content[1].type, 'text');
+  assert.equal(asstMsg.content[2].type, 'tool_use');
+
+ 
+  const userToolMsg = anthropic.messages[anthropic.messages.length - 1];
+  assert.equal(userToolMsg.role, 'user');
+  assert.equal(userToolMsg.content.length, 2);
+  assert.equal(userToolMsg.content[0].tool_use_id, 'toolu_1');
+  assert.equal(userToolMsg.content[0].is_error, undefined);
+  assert.equal(userToolMsg.content[1].tool_use_id, 'toolu_2');
+  assert.equal(userToolMsg.content[1].is_error, true);
+});
+