kiku-agent 1.3.1 → 1.3.3

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

@@ -0,0 +1,144 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import {
+  isPidAlive,
+  killProcessTreeSync,
+  registerBackgroundProcess,
+  unregisterBackgroundProcess,
+  getBackgroundProcess,
+  listBackgroundProcesses,
+  stopBackgroundProcess,
+  stopAllBackgroundProcessesSync,
+  initProcessExitHooks,
+  clearProcessRegistry,
+  killWslProcessByName,
+} from '../processManager.js';
+
+test('isPidAlive correctly identifies running and dead processes', () => {
+  assert.equal(isPidAlive(process.pid), true, 'Current node process should be alive');
+  assert.equal(isPidAlive(0), false, 'PID 0 should not be alive');
+  assert.equal(isPidAlive(-1), false, 'Negative PID should not be alive');
+  assert.equal(isPidAlive(null), false, 'Null PID should return false');
+  assert.equal(isPidAlive(99999999), false, 'Arbitrary high PID should not be alive');
+});
+
+test('processManager registers, queries, and unregisters background processes', () => {
+  clearProcessRegistry();
+
+  const dummyPid = process.pid;
+  const rec = registerBackgroundProcess('test-proc', dummyPid, {
+    command: 'node',
+    args: ['test.js'],
+    metadata: { test: true },
+  });
+
+  assert.equal(rec.name, 'test-proc');
+  assert.equal(rec.pid, dummyPid);
+  assert.equal(rec.status, 'running');
+
+  const fetched = getBackgroundProcess('test-proc');
+  assert.ok(fetched);
+  assert.equal(fetched.name, 'test-proc');
+  assert.equal(fetched.pid, dummyPid);
+  assert.equal(fetched.isAlive, true);
+
+  const list = listBackgroundProcesses();
+  assert.ok(list.some(p => p.name === 'test-proc' && p.pid === dummyPid));
+
+  const removed = unregisterBackgroundProcess('test-proc');
+  assert.equal(removed, true);
+  assert.equal(getBackgroundProcess('test-proc'), null);
+
+  clearProcessRegistry();
+});
+
+test('processManager tracks real child process and terminates it cleanly via tree kill', async () => {
+  clearProcessRegistry();
+
+  const child = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 20000)'], {
+    stdio: 'ignore',
+    windowsHide: true,
+  });
+
+  assert.ok(child.pid > 0);
+  assert.equal(isPidAlive(child.pid), true);
+
+  registerBackgroundProcess('sleep-job', child, {
+    command: process.execPath,
+    metadata: { job: 'timeout' },
+  });
+
+  const procInfo = getBackgroundProcess('sleep-job');
+  assert.equal(procInfo.isAlive, true);
+  assert.equal(procInfo.pid, child.pid);
+
+  const stopResult = stopBackgroundProcess('sleep-job');
+  assert.equal(stopResult.ok, true);
+  assert.equal(stopResult.status, 'stopped');
+
+  await new Promise(r => setTimeout(r, 200));
+  assert.equal(isPidAlive(child.pid), false, 'Child process should be terminated');
+
+  clearProcessRegistry();
+});
+
+test('processManager validates input arguments defensively', () => {
+  assert.throws(() => registerBackgroundProcess('', 1234), /must be a non-empty string/);
+  assert.throws(() => registerBackgroundProcess('bad-pid', -5), /Invalid PID/);
+  assert.throws(() => registerBackgroundProcess('bad-null', null), /Invalid PID/);
+});
+
+test('initProcessExitHooks is idempotent and safe', () => {
+  assert.doesNotThrow(() => {
+    initProcessExitHooks();
+    initProcessExitHooks();
+  });
+});
+
+test('killWslProcessByName handles safe fallback', () => {
+  assert.equal(killWslProcessByName(null, 'test'), false);
+  assert.equal(killWslProcessByName('Ubuntu', null), false);
+});
+
+test('stopAllBackgroundProcessesSync cleanly stops all registered processes', () => {
+  clearProcessRegistry();
+
+  const child1 = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 20000)'], { stdio: 'ignore' });
+  const child2 = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 20000)'], { stdio: 'ignore' });
+
+  registerBackgroundProcess('worker-1', child1);
+  registerBackgroundProcess('worker-2', child2);
+
+  const stopped = stopAllBackgroundProcessesSync();
+  assert.equal(stopped.length, 2);
+
+  assert.equal(isPidAlive(child1.pid), false);
+  assert.equal(isPidAlive(child2.pid), false);
+
+  clearProcessRegistry();
+});
+
+test('stopAllBackgroundProcessesSync preserves persistOnExit processes on exit unless force is passed', () => {
+  clearProcessRegistry();
+
+  const persistentChild = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 20000)'], { stdio: 'ignore' });
+  const ephemeralChild = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 20000)'], { stdio: 'ignore' });
+
+  registerBackgroundProcess('daemon-service', persistentChild, { persistOnExit: true });
+  registerBackgroundProcess('worker-job', ephemeralChild);
+
+  const normalExitStopped = stopAllBackgroundProcessesSync({ force: false });
+  assert.equal(normalExitStopped.length, 1);
+  assert.equal(normalExitStopped[0].name, 'worker-job');
+  assert.equal(isPidAlive(ephemeralChild.pid), false);
+  assert.equal(isPidAlive(persistentChild.pid), true, 'Persistent daemon should remain alive on standard exit');
+
+  const forcedStopped = stopAllBackgroundProcessesSync({ force: true });
+  assert.equal(forcedStopped.length, 1);
+  assert.equal(forcedStopped[0].name, 'daemon-service');
+  assert.equal(isPidAlive(persistentChild.pid), false, 'Persistent daemon stops when forced');
+
+  clearProcessRegistry();
+});
+

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

@@ -0,0 +1,44 @@
+import test, { after } from 'node:test';
+import os from 'node:os';
+import path from 'node:path';
+import assert from 'node:assert/strict';
+const isolatedSettingsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kiku-provider-test-'));
+process.env.KIKU_DATA_DIR = isolatedSettingsDir;
+after(() => fs.rmSync(isolatedSettingsDir, { recursive: true, force: true }));
+import fs from 'node:fs';
+const { SETTINGS_FILE } = await import("../appPaths.js");
+const {
+  savePersistedActiveProvider,
+  savePersistedProviderModel,
+  getPersistedActiveProvider,
+  loadPersistedSettings,
+  CLOUD_PROVIDERS,
+} = await import("../config.js");
+const { LLMClient } = await import("../llmClient.js");
+
+test('Provider and Model settings persist across restarts', () => {
+  const originalGroqModel = CLOUD_PROVIDERS.groq.defaultModel;
+  const originalLmStudioModel = CLOUD_PROVIDERS.lmstudio.defaultModel;
+
+  try {
+    savePersistedActiveProvider('groq', 'openai/gpt-oss-120b');
+    savePersistedProviderModel('groq', 'llama-3.3-70b-versatile');
+
+    assert.equal(getPersistedActiveProvider(), 'groq');
+    const settings = loadPersistedSettings();
+    assert.equal(settings.activeProvider, 'groq');
+    assert.equal(settings.providerModels?.groq, 'llama-3.3-70b-versatile');
+
+    const client = new LLMClient();
+    assert.equal(client.provider, 'groq');
+    assert.equal(client.model, 'llama-3.3-70b-versatile');
+
+    client.switchProvider('openrouter', { model: 'openrouter/auto' });
+    assert.equal(getPersistedActiveProvider(), 'openrouter');
+  } finally {
+    try { if (fs.existsSync(SETTINGS_FILE)) fs.unlinkSync(SETTINGS_FILE); } catch {}
+    CLOUD_PROVIDERS.groq.defaultModel = originalGroqModel || 'openai/gpt-oss-120b';
+    CLOUD_PROVIDERS.lmstudio.defaultModel = originalLmStudioModel || 'google/gemma-4-e4b';
+    loadPersistedSettings();
+  }
+});

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

@@ -0,0 +1,83 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { TEST_SCENARIOS } from './scenariosData.js';
+import { DynamicToolRouter } from '../toolRouter.js';
+import { detectDominantLanguage } from '../agentCore.js';
+import { executeTool } from '../tools.js';
+import { AgentMemory } from '../memory.js';
+
+test('Benchmark: Test scenarios contain comprehensive valid entries', () => {
+  assert.ok(TEST_SCENARIOS.length >= 20);
+  const categories = new Set(TEST_SCENARIOS.map(s => s.category));
+  assert.ok(categories.has('works'));
+  assert.ok(categories.has('music'));
+  assert.ok(categories.has('brand'));
+  assert.ok(categories.has('awards'));
+  assert.ok(categories.has('profile'));
+  assert.ok(categories.has('timeline'));
+  assert.ok(categories.has('research'));
+  assert.ok(categories.has('system'));
+});
+
+test('Benchmark: DynamicToolRouter routes all test scenario prompts correctly', () => {
+  const router = new DynamicToolRouter();
+
+  for (const scenario of TEST_SCENARIOS) {
+    const routedTools = router.routeToolsForQuery(scenario.query);
+    const routedNames = new Set(routedTools.map(t => t.function.name));
+
+    assert.ok(routedTools.length > 0, `Scenario ${scenario.id} returned empty routed tools`);
+    assert.ok(routedTools.length <= 15, `Scenario ${scenario.id} exceeded tool limit`);
+
+    const hasExpectedTool = scenario.expectedTools.some(toolName => routedNames.has(toolName));
+    assert.ok(hasExpectedTool, `Scenario ${scenario.id} did not include any expected tools: ${scenario.expectedTools.join(', ')}`);
+  }
+});
+
+test('Benchmark: Language detection accurately identifies scenario query languages', () => {
+  for (const scenario of TEST_SCENARIOS) {
+    const detected = detectDominantLanguage(scenario.query);
+    assert.equal(detected, scenario.language, `Scenario ${scenario.id} expected ${scenario.language} but got ${detected}`);
+  }
+});
+
+test('Benchmark: Direct tool execution verifies domain facts across categories', async () => {
+  const worksRes = await executeTool('search_works', { query: 'In Blossom' });
+  assert.equal(worksRes.status, 'success');
+  assert.ok(worksRes.count > 0);
+
+  const discoRes = await executeTool('search_discography', { query: 'FIND THE WAY' });
+  assert.equal(discoRes.status, 'success');
+  assert.ok(discoRes.count > 0);
+
+  const brandRes = await executeTool('get_brand_endorsements', {});
+  assert.equal(brandRes.status, 'success');
+  assert.ok(brandRes.brands.length > 0);
+
+  const profileRes = await executeTool('get_profile_and_fandom', {});
+  assert.equal(profileRes.status, 'success');
+  assert.ok(profileRes.profile.nameCn.includes('鞠婧祎'));
+
+  const awardsRes = await executeTool('get_awards', {});
+  assert.equal(awardsRes.status, 'success');
+  assert.ok(awardsRes.awards.length > 0);
+
+  const statsRes = await executeTool('get_system_stats', {});
+  assert.equal(statsRes.status, 'success');
+  assert.ok(statsRes.stats.totalWorks > 0);
+});
+
+test('Benchmark: Memory query-aware ranking retrieves top relevant scenario facts', () => {
+  const memory = new AgentMemory();
+  for (const scenario of TEST_SCENARIOS) {
+    memory.addFact(`Ju Jingyi scenario fact for ${scenario.id}: ${scenario.expectedKeywords.join(' ')}`, {
+      category: scenario.category,
+      tags: scenario.expectedKeywords,
+      confidence: 'high'
+    });
+  }
+
+  const retrieved = memory.getRelevantFacts('In Blossom drama Yang Caiwei', 3);
+  assert.ok(retrieved.length > 0);
+  assert.ok(retrieved.some(f => f.content.includes('drama_in_blossom_detail')));
+});

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

@@ -0,0 +1,126 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  classifyToolResult,
+  formatDetailDuration,
+  parseDetailsRequest,
+  serializeDetailValue,
+  summarizeQueryDetails,
+  getCopyableContent,
+  copyToClipboard,
+  formatQueryDetails,
+} from '../queryDetails.js';
+
+test('details request supports latest, query, view, markdown, and raw tool selection', () => {
+  assert.deepEqual(parseDetailsRequest(''), {
+    error: null, queryNumber: null, view: 'answer', toolIndex: null,
+  });
+  assert.deepEqual(parseDetailsRequest('Q12 tools'), {
+    error: null, queryNumber: 12, view: 'tools', toolIndex: null,
+  });
+  assert.deepEqual(parseDetailsRequest('latest thinking'), {
+    error: null, queryNumber: null, view: 'thinking', toolIndex: null,
+  });
+  assert.deepEqual(parseDetailsRequest('3 tool 2'), {
+    error: null, queryNumber: 3, view: 'tool', toolIndex: 2,
+  });
+  assert.deepEqual(parseDetailsRequest('Q1 all'), {
+    error: null, queryNumber: 1, view: 'all', toolIndex: null,
+  });
+  assert.deepEqual(parseDetailsRequest('Q2 markdown'), {
+    error: null, queryNumber: 2, view: 'markdown', toolIndex: null,
+  });
+  assert.match(parseDetailsRequest('tool').error, /positive tool number/);
+  assert.match(parseDetailsRequest('Q1 unknown').error, /Unknown details view/);
+});
+
+test('query details summary separates successful, empty, and failed tools', () => {
+  const details = {
+    answer: 'answer',
+    thinking: 'thought',
+    tools: [
+      { duration: 10, result: { status: 'ok', count: 2 } },
+      { duration: 20, result: { status: 'not_found' } },
+      { duration: 30, result: { status: 'error' } },
+    ],
+  };
+
+  assert.deepEqual(summarizeQueryDetails(details), {
+    toolCount: 3,
+    successfulTools: 1,
+    failedTools: 1,
+    emptyTools: 1,
+    toolDurationMs: 60,
+    thinkingCharacters: 7,
+    answerCharacters: 6,
+  });
+  assert.equal(classifyToolResult({ count: 0 }).state, 'not_found');
+});
+
+test('detail formatting is bounded and handles non-serializable values', () => {
+  assert.equal(formatDetailDuration(45), '45ms');
+  assert.equal(formatDetailDuration(1250), '1.25s');
+  assert.equal(serializeDetailValue({ long: 'x'.repeat(100) }, 30).truncated, true);
+  assert.equal(serializeDetailValue({ long: 'x'.repeat(100) }).truncated, false);
+
+  const cyclic = {};
+  cyclic.self = cyclic;
+  assert.equal(serializeDetailValue(cyclic).truncated, false);
+});
+
+test('getCopyableContent extracts untruncated answers, thinking, tools, and markdown', () => {
+  const details = {
+    number: 1,
+    status: 'complete',
+    prompt: 'Who is Ju Jingyi?',
+    answer: 'Ju Jingyi (鞠婧祎) is a famous Chinese singer and actress.',
+    thinking: 'Analyzing profile catalog and works...',
+    tools: [
+      {
+        name: 'get_profile',
+        duration: 15,
+        args: {},
+        result: { status: 'success', nameCn: '鞠婧祎' },
+      },
+    ],
+  };
+
+  const ans = getCopyableContent(details, { view: 'answer' });
+  assert.equal(ans.text, 'Ju Jingyi (鞠婧祎) is a famous Chinese singer and actress.');
+  assert.equal(ans.type, 'answer');
+
+  const think = getCopyableContent(details, { view: 'thinking' });
+  assert.equal(think.text, 'Analyzing profile catalog and works...');
+  assert.equal(think.type, 'thinking');
+
+  const tool1 = getCopyableContent(details, { view: 'tool', toolIndex: 1 });
+  assert.match(tool1.text, /get_profile/);
+  assert.equal(tool1.type, 'tool');
+
+  const md = getCopyableContent(details, { view: 'markdown' });
+  assert.match(md.text, /# Question 1/);
+  assert.match(md.text, /## Thinking/);
+  assert.match(md.text, /## Answer/);
+  assert.equal(md.type, 'markdown');
+});
+
+test('copyToClipboard safely executes cross-platform child process', () => {
+  const result = copyToClipboard('test copy');
+  assert.equal(typeof result, 'boolean');
+});
+
+test('formatQueryDetails formats diagnostics without throwing', () => {
+  const formatted = formatQueryDetails({
+    number: 1,
+    status: 'complete',
+    prompt: 'test prompt',
+    answer: 'test answer',
+    durationMs: 50,
+  });
+  assert.match(formatted, /=== Answer • Q1 ===/);
+  assert.match(formatted, /test answer/);
+
+  assert.equal(formatQueryDetails(null), 'No query diagnostics recorded.');
+});
+

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

@@ -0,0 +1,180 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFileSync } from 'node:fs';
+import { Readable } from 'node:stream';
+import { EventEmitter } from 'node:events';
+import { getWebChatHtml } from '../../webChatHtml.js';
+import { handleChatRoute } from '../../web-chat/routes/chatRoute.js';
+
+test('Web Chat HTML contains timeline-modal, research-modal, and verify-modal', () => {
+  const html = getWebChatHtml();
+  assert.match(html, /id="timeline-modal"/, 'timeline-modal must exist');
+  assert.match(html, /id="timeline-body"/, 'timeline-body must exist inside modal');
+  assert.match(html, /id="research-modal"/, 'research-modal must exist');
+  assert.match(html, /id="research-modal-input"/, 'research-modal-input textarea must exist');
+  assert.match(html, /id="verify-modal"/, 'verify-modal must exist');
+  assert.match(html, /id="verify-modal-input"/, 'verify-modal-input textarea must exist');
+
+  // Verify quick action menu items call modal openers
+  assert.match(html, /onclick="openResearchModal\(\); closeQuickActions\(\)"/);
+  assert.match(html, /onclick="openVerifyModal\(\); closeQuickActions\(\)"/);
+  assert.match(html, /onclick="openTimelineModal\(\); closeQuickActions\(\)"/);
+});
+
+test('client.js parses timeline data correctly whether wrapped in data array or milestones', () => {
+  const src = readFileSync(new URL('../../web-chat/ui/scripts/client.js', import.meta.url), 'utf8');
+
+  // Verify loadTimelineData parses array from json.data
+  assert.ok(src.includes('const items = Array.isArray(json)'));
+  assert.ok(src.includes('Array.isArray(json.data) ? json.data'));
+
+  // Test parsing logic with actual API responses
+  const apiFormat = {
+    status: 'success',
+    code: 200,
+    data: [
+      { id: '1', year: '2013', era: 'snh48', title: 'Debut' },
+      { id: '2', year: '2024', era: 'solo', title: 'In Blossom' }
+    ]
+  };
+
+  const parseItems = (json) => {
+    return Array.isArray(json)
+      ? json
+      : (Array.isArray(json.data) ? json.data : (json.data?.milestones || json.milestones || []));
+  };
+
+  const parsed = parseItems(apiFormat);
+  assert.equal(parsed.length, 2);
+  assert.equal(parsed[0].title, 'Debut');
+  assert.equal(parsed[1].title, 'In Blossom');
+});
+
+test('chatRoute streams /research queries via agent.runResearch with subagent_progress SSE', async () => {
+  const progressEvents = [];
+  let calledQuery = '';
+  let calledOptions = null;
+
+  const mockAgent = {
+    async runResearch(question, options = {}) {
+      calledQuery = question;
+      calledOptions = options;
+      options.onProgress?.({ type: 'worker-start', id: 'worker-1', label: 'Local Catalog Explorer' });
+      options.onProgress?.({ type: 'worker-complete', id: 'worker-1', label: 'Local Catalog Explorer' });
+      return {
+        id: 'res_test_123',
+        answer: 'จวีจิ้งอีได้รับรางวัลมากมายตั้งแต่ยุค SNH48 จนถึงศิลปินเดี่ยว',
+        sources: ['https://weibo.com/jujingyi'],
+        reports: [{ toolCalls: [{ name: 'get_awards', args: {}, result: { count: 5 }, duration: 12 }] }]
+      };
+    },
+    session: {
+      createUserMessage: () => {},
+      createAssistantMessage: () => {}
+    },
+    conversationHistory: []
+  };
+
+  const mockResolve = async () => ({
+    ready: true,
+    agent: mockAgent,
+    client: { provider: 'lmstudio' },
+    provider: 'lmstudio'
+  });
+
+  const req = Readable.from([JSON.stringify({ query: '/research รางวัลทั้งหมดของจวีจิ้งอี', stream: true })]);
+  req.headers = { accept: 'text/event-stream' };
+  req.socket = { remoteAddress: '127.0.0.1' };
+
+  const res = new EventEmitter();
+  res.chunks = '';
+  res.writeHead = (code, headers) => { res.statusCode = code; res.headers = headers; };
+  res.write = (chunk) => { res.chunks += chunk; };
+  res.end = (chunk = '') => { res.chunks += chunk; res.writableEnded = true; };
+
+  await handleChatRoute(req, res, new URL('http://localhost/api/chat'), { resolveConnection: mockResolve });
+
+  assert.equal(calledQuery, 'รางวัลทั้งหมดของจวีจิ้งอี');
+  assert.equal(calledOptions?.mode, 'research');
+
+  // Verify SSE stream contains subagent_progress and final answer
+  assert.ok(res.chunks.includes('subagent_progress'));
+  assert.ok(res.chunks.includes('Local Catalog Explorer'));
+  assert.ok(res.chunks.includes('จวีจิ้งอีได้รับรางวัลมากมาย'));
+  assert.ok(res.chunks.includes('"type":"final"'));
+  assert.ok(res.chunks.includes('[DONE]'));
+});
+
+test('chatRoute streams /verify queries via agent.runResearch with mode: verify', async () => {
+  let calledQuery = '';
+  let calledOptions = null;
+
+  const mockAgent = {
+    async runResearch(claim, options = {}) {
+      calledQuery = claim;
+      calledOptions = options;
+      options.onProgress?.({ type: 'worker-start', id: 'worker-verify', label: 'Fact Verification' });
+      return {
+        id: 'verify_test_123',
+        answer: 'VERIFIED: จวีจิ้งอีเป็น Brand Ambassador ของ FRED Paris จริง',
+        sources: ['https://fred.com'],
+        reports: []
+      };
+    },
+    session: {
+      createUserMessage: () => {},
+      createAssistantMessage: () => {}
+    },
+    conversationHistory: []
+  };
+
+  const mockResolve = async () => ({
+    ready: true,
+    agent: mockAgent,
+    client: { provider: 'lmstudio' },
+    provider: 'lmstudio'
+  });
+
+  const req = Readable.from([JSON.stringify({ query: '/verify จวีจิ้งอีเป็นแบรนด์แอมบาสเดอร์ของ FRED Paris', stream: true })]);
+  req.headers = { accept: 'text/event-stream' };
+  req.socket = { remoteAddress: '127.0.0.1' };
+
+  const res = new EventEmitter();
+  res.chunks = '';
+  res.writeHead = () => {};
+  res.write = (chunk) => { res.chunks += chunk; };
+  res.end = (chunk = '') => { res.chunks += chunk; res.writableEnded = true; };
+
+  await handleChatRoute(req, res, new URL('http://localhost/api/chat'), { resolveConnection: mockResolve });
+
+  assert.equal(calledQuery, 'จวีจิ้งอีเป็นแบรนด์แอมบาสเดอร์ของ FRED Paris');
+  assert.equal(calledOptions?.mode, 'verify');
+  assert.ok(res.chunks.includes('VERIFIED'));
+});
+
+test('chatRoute returns guidance when /research or /verify is sent with empty argument', async () => {
+  const mockAgent = {
+    runResearch: async () => assert.fail('should not call runResearch when empty')
+  };
+  const mockResolve = async () => ({
+    ready: true,
+    agent: mockAgent,
+    client: { provider: 'lmstudio' },
+    provider: 'lmstudio'
+  });
+
+  const req = Readable.from([JSON.stringify({ query: '/research', stream: true })]);
+  req.headers = { accept: 'text/event-stream' };
+  req.socket = { remoteAddress: '127.0.0.1' };
+
+  const res = new EventEmitter();
+  res.chunks = '';
+  res.writeHead = () => {};
+  res.write = (chunk) => { res.chunks += chunk; };
+  res.end = (chunk = '') => { res.chunks += chunk; res.writableEnded = true; };
+
+  await handleChatRoute(req, res, new URL('http://localhost/api/chat'), { resolveConnection: mockResolve });
+
+  assert.ok(res.chunks.includes('ระบบวิจัยเชิงลึก'));
+  assert.ok(res.chunks.includes('3 Subagent Workers'));
+});