kiku-agent 1.3.2 → 1.3.4

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

@@ -0,0 +1,108 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { appendDomainFilters, planSearchRequest, rerankSearchResults } from '../searchQueryPlanner.js';
+import { prepareToolArguments, toolsSchema } from '../tools.js';
+
+test('search planner normalizes conversational Thai and romanized Chinese entities', () => {
+  const plan = planSearchRequest({
+    keywords: 'ช่วยอปเดตขาวกองถาย Wan hua sin jie ปี 2026 หน่อย',
+    target_language: 'zh',
+    domain_filter: ['https://www.weibo.com/search', 'bilibili.com'],
+  }, { kind: 'chinese' });
+
+  assert.match(plan.keywords, /万花世界/);
+  assert.match(plan.keywords, /电视剧/);
+  assert.match(plan.keywords, /拍摄进度/);
+  assert.match(plan.keywords, /2026/);
+  assert.deepEqual(plan.domains, ['weibo.com', 'bilibili.com']);
+});
+
+test('search planner resolves a romanized performer name to native script and qualifier', () => {
+  const plan = planSearchRequest('latest update for Song Xinran', { kind: 'news' });
+  assert.match(plan.keywords, /宋昕冉/);
+  assert.match(plan.keywords, /SNH48/);
+});
+
+test('post-retrieval reranker promotes intent and domain matches', () => {
+  const plan = planSearchRequest({ keywords: 'Song Xinran event', domain_filter: ['weibo.com'] });
+  const ranked = rerankSearchResults([
+    { title: 'Unrelated sports result', snippet: 'football table', url: 'https://example.com/a' },
+    { title: '宋昕冉 SNH48 event update', snippet: 'latest official schedule', url: 'https://weibo.com/a' },
+  ], plan);
+  assert.match(ranked[0].title, /宋昕冉/);
+  assert.ok(ranked.length === 1 || ranked[0].relevanceScore > ranked.at(-1).relevanceScore);
+});
+
+test('structured search fields pass through tool argument sanitation while legacy query remains accepted', () => {
+  const structured = prepareToolArguments('web_search', {
+    keywords: '万花世界 拍摄进度',
+    target_language: 'zh',
+    domain_filter: ['weibo.com'],
+  }, toolsSchema);
+  assert.equal(structured.safe, true);
+  assert.deepEqual(structured.args.domain_filter, ['weibo.com']);
+
+  const legacy = prepareToolArguments('web_search', { query: 'Ju Jingyi news' }, toolsSchema);
+  assert.equal(legacy.safe, true);
+  assert.equal(legacy.args.query, 'Ju Jingyi news');
+  assert.match(appendDomainFilters('鞠婧祎', ['weibo.com']), /site:weibo\.com/);
+});
+
+test('planner parity: bilibili, youtube, encyclopedia, and music tools accept canonical keywords', () => {
+  const bili = prepareToolArguments('search_bilibili', {
+    keywords: '宋昕冉 SNH48 舞台',
+    target_language: 'zh',
+  }, toolsSchema);
+  assert.equal(bili.safe, true);
+  assert.equal(bili.args.keywords, '宋昕冉 SNH48 舞台');
+
+  const biliLegacy = prepareToolArguments('search_bilibili', { keyword: '鞠婧祎 舞台' }, toolsSchema);
+  assert.equal(biliLegacy.safe, true);
+  assert.equal(biliLegacy.args.keyword, '鞠婧祎 舞台');
+
+  const yt = prepareToolArguments('search_youtube', { keywords: 'Ju Jingyi FIND THE WAY' }, toolsSchema);
+  assert.equal(yt.safe, true);
+  assert.equal(yt.args.keywords, 'Ju Jingyi FIND THE WAY');
+
+  const ytLegacy = prepareToolArguments('search_youtube', { query: 'Ju Jingyi live stage' }, toolsSchema);
+  assert.equal(ytLegacy.safe, true);
+
+  const baike = prepareToolArguments('search_encyclopedia', {
+    keywords: '宋昕冉 SNH48',
+    target_language: 'zh',
+  }, toolsSchema);
+  assert.equal(baike.safe, true);
+
+  const baikeLegacy = prepareToolArguments('search_encyclopedia', { term: '鞠婧祎', language: 'zh' }, toolsSchema);
+  assert.equal(baikeLegacy.safe, true);
+
+  const music = prepareToolArguments('search_music_platforms', { keywords: 'Ju Jingyi 叹云兮' }, toolsSchema);
+  assert.equal(music.safe, true);
+
+  const musicLegacy = prepareToolArguments('search_music_platforms', { term: 'Ju Jingyi' }, toolsSchema);
+  assert.equal(musicLegacy.safe, true);
+});
+
+test('planner parity: handlers reject empty input without touching the network', async () => {
+  const { toolHandlers } = await import('../tools.js');
+  const bili = await toolHandlers.search_bilibili({});
+  assert.equal(bili.status, 'error');
+  assert.match(bili.message, /keyword parameter is required/);
+
+  const enc = await toolHandlers.search_encyclopedia({});
+  assert.equal(enc.status, 'error');
+
+  const music = await toolHandlers.search_music_platforms({});
+  assert.equal(music.status, 'error');
+
+  const yt = await toolHandlers.search_youtube({});
+  assert.equal(yt.status, 'error');
+});
+
+test('planner resolves performer queries to entity-native terms for encyclopedia-style lookup', () => {
+  const plan = planSearchRequest({ keywords: 'ค้นหาข้อมูลของ Song Xinran SNH48 ให้หน่อย' });
+  const native = plan.entities[0]?.native;
+  assert.ok(native && /宋昕冉|SNH48/.test(`${native} ${plan.keywords}`));
+  assert.match(plan.keywords, /宋昕冉/);
+});

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

@@ -46,14 +46,14 @@ test('Security Remediation: StaticRoute blocks path traversal and sensitive file
 
 test('Security Remediation: SSRF Alternate IP Encodings (decimal, hex, octal, classful) are detected and blocked', async () => {
   const encodings = [
-    '2130706433',     // 127.0.0.1 in decimal integer
-    '0x7f000001',     // 127.0.0.1 in hex integer
-    '0x7f.0.0.1',     // 127.0.0.1 in dotted hex
-    '0177.0.0.1',     // 127.0.0.1 in octal
-    '127.1',          // 127.0.0.1 in 2-part classful
-    '10.1',           // 10.0.0.1 in 2-part classful
-    '192.168.1',      // 192.168.0.1 in 3-part classful
-    '0',              // 0.0.0.0
+    '2130706433',
+    '0x7f000001',
+    '0x7f.0.0.1',
+    '0177.0.0.1',
+    '127.1',
+    '10.1',
+    '192.168.1',
+    '0',
     '0.0.0.0'
   ];
 
@@ -77,6 +77,13 @@ test('Security Remediation: SSRF Alternate IP Encodings (decimal, hex, octal, cl
   }
 });
 
+test('Security Remediation: IPv4-mapped and compatible IPv6 private encodings are blocked', async () => {
+  for (const ip of ['::ffff:7f00:1', '0:0:0:0:0:ffff:7f00:1', '::7f00:1']) {
+    const result = await assertSafeUrlHostnameSsrf(ip);
+    assert.equal(result.safe, false, `assertSafeUrlHostnameSsrf should reject ${ip}`);
+  }
+});
+
 test('Security Remediation: HierarchicalStore.resolvePointer strictly confines file resolution to allowed store directories', async () => {
   const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'kiku-store-test-'));
   try {
@@ -196,7 +203,7 @@ test('Security Remediation: ?testRateLimit= is completely ignored when NODE_ENV
     const req = {
       method: 'GET',
       url: '/api/v1/health?testRateLimit=1',
-      headers: { host: 'localhost:3000' },
+      headers: { host: 'localhost:3000', 'x-kiku-force-production': 'true' },
       socket: { remoteAddress: '127.0.0.1' }
     };
     const res = {

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

@@ -0,0 +1,154 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { Readable } from 'node:stream';
+import { EventEmitter } from 'node:events';
+import { resolveClientIp } from '../../web-chat/core/security.js';
+import { isTrustedRequest } from '../../web-chat/core/urlGuard.js';
+import { AgentJobManager } from '../jobManager.js';
+import { handleChatRoute } from '../../web-chat/routes/chatRoute.js';
+
+test('Security Remediation 2: resolveClientIp blocks spoofed loopback IPs from external proxy connections', () => {
+  const origVercel = process.env.VERCEL;
+  const origTrust = process.env.KIKU_TRUST_PROXY;
+  try {
+    process.env.VERCEL = '1';
+
+   
+    const reqSpoof = {
+      socket: { remoteAddress: '203.0.113.50' },
+      headers: { 'x-forwarded-for': '127.0.0.1, 203.0.113.50' }
+    };
+    const ip = resolveClientIp(reqSpoof);
+    assert.equal(ip, '203.0.113.50');
+    assert.equal(isTrustedRequest(reqSpoof), false, 'Spoofed loopback header must not make request trusted');
+
+    
+    const reqSpoofV6 = {
+      socket: { remoteAddress: '198.51.100.99' },
+      headers: { 'x-forwarded-for': '::1' }
+    };
+    const ipV6 = resolveClientIp(reqSpoofV6);
+    assert.equal(ipV6, '198.51.100.99');
+    assert.equal(isTrustedRequest(reqSpoofV6), false);
+
+   
+    const reqDirectLocal = {
+      socket: { remoteAddress: '127.0.0.1' },
+      headers: {}
+    };
+    assert.equal(resolveClientIp(reqDirectLocal), '127.0.0.1');
+    assert.equal(isTrustedRequest(reqDirectLocal), true);
+  } finally {
+    if (origVercel !== undefined) process.env.VERCEL = origVercel;
+    else delete process.env.VERCEL;
+    if (origTrust !== undefined) process.env.KIKU_TRUST_PROXY = origTrust;
+    else delete process.env.KIKU_TRUST_PROXY;
+  }
+});
+
+test('Concurrency Remediation 2: AgentJobManager bounds concurrent heavy research/verify jobs', async () => {
+  const manager = new AgentJobManager(10, 2);
+
+  let finishJob1;
+  const p1 = new Promise(r => { finishJob1 = r; });
+  let finishJob2;
+  const p2 = new Promise(r => { finishJob2 = r; });
+
+  const run1 = manager.run('research', 'Task 1', () => p1);
+  const run2 = manager.run('verify', 'Task 2', () => p2);
+
+ 
+  await assert.rejects(
+    async () => {
+      await manager.run('research', 'Task 3', async () => 'result 3');
+    },
+    /Too many concurrent research tasks running/
+  );
+
+  finishJob1('done 1');
+  await run1;
+
+
+  const result3 = await manager.run('research', 'Task 3', async () => 'result 3');
+  assert.equal(result3, 'result 3');
+
+  finishJob2('done 2');
+  await run2;
+});
+
+test('Lifecycle Parity Remediation 2: chatRoute JSON mode persists conversation history and catches errors gracefully', async () => {
+  const mockAgent = {
+    conversationHistory: [],
+    session: {
+      createUserMessage(msg) { this.lastUser = msg; },
+      createAssistantMessage(msg) { this.lastAssistant = msg; }
+    },
+    runResearch: async (target) => {
+      if (target === 'fail-query') {
+        throw new Error('LLM provider timeout');
+      }
+      return {
+        answer: `Detailed findings on ${target}`,
+        sources: ['https://example.com/source'],
+        reports: [{ toolCalls: [{ name: 'search_works', args: { query: target }, result: { count: 1 } }] }]
+      };
+    }
+  };
+
+  const req = Readable.from([JSON.stringify({ query: '/research In Blossom roles', stream: false })]);
+  req.method = 'POST';
+  req.url = '/api/chat';
+  req.headers = { 'content-type': 'application/json' };
+  req.socket = { remoteAddress: '127.0.0.1' };
+
+  let responseData = null;
+  const mockRes = new EventEmitter();
+  mockRes.setHeader = () => {};
+  mockRes.writeHead = () => {};
+  mockRes.write = () => {};
+  mockRes.end = (data) => {
+    mockRes.writableEnded = true;
+    if (data) {
+      try { responseData = JSON.parse(data); } catch { responseData = data; }
+    }
+  };
+
+  const mockResolve = async () => ({
+    ready: true,
+    agent: mockAgent,
+    client: { provider: 'lmstudio' },
+    provider: 'lmstudio'
+  });
+
+  const url = new URL('http://localhost/api/chat');
+  await handleChatRoute(req, mockRes, url, { resolveConnection: mockResolve });
+
+  assert.equal(responseData.status, 'success');
+  assert.match(responseData.answer, /Detailed findings on In Blossom roles/);
+  assert.equal(mockAgent.conversationHistory.length, 2, 'History must contain user and assistant messages');
+  assert.equal(mockAgent.conversationHistory[0].role, 'user');
+  assert.equal(mockAgent.conversationHistory[1].role, 'assistant');
+
+ 
+  const reqFail = Readable.from([JSON.stringify({ query: '/verify fail-query', stream: false })]);
+  reqFail.method = 'POST';
+  reqFail.url = '/api/chat';
+  reqFail.headers = { 'content-type': 'application/json' };
+  reqFail.socket = { remoteAddress: '127.0.0.1' };
+
+  let failData = null;
+  const mockResFail = new EventEmitter();
+  mockResFail.setHeader = () => {};
+  mockResFail.writeHead = () => {};
+  mockResFail.write = () => {};
+  mockResFail.end = (data) => {
+    mockResFail.writableEnded = true;
+    if (data) {
+      try { failData = JSON.parse(data); } catch { failData = data; }
+    }
+  };
+
+  await handleChatRoute(reqFail, mockResFail, url, { resolveConnection: mockResolve });
+  assert.equal(failData.status, 'error');
+  assert.match(failData.answer, /LLM provider timeout/);
+});

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

@@ -116,10 +116,10 @@ test('Security: Security response headers are applied (CSP, HSTS, X-Content-Type
   await withApiServer(async baseUrl => {
     const docsRes = await fetch(`${baseUrl}/api-docs`);
     assert.equal(docsRes.status, 200);
-    const contentSecurityPolicy = docsRes.headers.get('content-security-policy');
-    assert.ok(contentSecurityPolicy);
-    assert.match(contentSecurityPolicy, /font-src[^;]*'self'/);
-    assert.match(contentSecurityPolicy, /font-src[^;]*https:\/\/fonts\.gstatic\.com/);
+    const contentSecurityPolicy = docsRes.headers.get('content-security-policy');
+    assert.ok(contentSecurityPolicy);
+    assert.match(contentSecurityPolicy, /font-src[^;]*'self'/);
+    assert.match(contentSecurityPolicy, /font-src[^;]*https:\/\/fonts\.gstatic\.com/);
     assert.equal(docsRes.headers.get('x-content-type-options'), 'nosniff');
     assert.equal(docsRes.headers.get('x-frame-options'), 'DENY');
     assert.ok(docsRes.headers.get('permissions-policy'));

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

@@ -8,7 +8,7 @@ import { LLMClient } from '../llmClient.js';
 import { routeCommand } from '../commands.js';
 
 test('AgentSession records full conversation metadata, tools, reasoning, and exports', async () => {
-  const session = new AgentSession();
+  const session = new AgentSession({ persistence: false });
   
   const userMsg = session.createUserMessage('Who is Ju Jingyi?', { queryNumber: 1 });
   assert.equal(userMsg.role, 'user');
@@ -122,7 +122,7 @@ test('queryDetails parses session and granular query copy requests', () => {
   assert.equal(reqQ1Tool.view, 'tool');
   assert.equal(reqQ1Tool.toolIndex, 2);
 
-  const session = new AgentSession();
+  const session = new AgentSession({ persistence: false });
   session.createUserMessage('Test question');
   const asst = session.createAssistantMessage({ model: 'gemma-4' });
   session.addTextPart(asst, 'Test answer');
@@ -139,7 +139,7 @@ test('queryDetails parses session and granular query copy requests', () => {
 test('Commands /session export and /session clear execute cleanly', async () => {
   let ended = false;
   const mockAgent = {
-    session: new AgentSession(),
+    session: new AgentSession({ persistence: false }),
     endSession: async () => {
       ended = true;
       return true;
@@ -180,7 +180,7 @@ test('Commands /copy routes answer, thinking, tools, all, and session variants',
     status: 'complete',
   };
 
-  const session = new AgentSession();
+  const session = new AgentSession({ persistence: false });
   session.createUserMessage('Who is Ju Jingyi?');
   const asst = session.createAssistantMessage({ model: 'gemma-4' });
   session.addTextPart(asst, 'Ju Jingyi is a singer and actress.');
@@ -230,3 +230,38 @@ test('Commands /copy routes answer, thinking, tools, all, and session variants',
   assert.ok(copiedText.includes('# Kiku AI Agent — Session Transcript'));
   assert.ok(copiedText.includes('Who is Ju Jingyi?'));
 });
+
+test('AgentSession synchronizes totalToolCalls and /session info from message tool parts', async () => {
+  const session = new AgentSession({ persistence: false });
+  session.restoreFromSnapshot({
+    id: 'sess_test_sync',
+    createdAt: new Date(),
+    messages: [
+      { role: 'user', parts: [{ type: 'text', content: 'hello' }] },
+      {
+        role: 'assistant',
+        parts: [
+          { type: 'tool', name: 'search_works', args: { query: 'In Blossom' }, status: 'ok', durationMs: 40 },
+          { type: 'text', content: 'In Blossom info' }
+        ]
+      }
+    ],
+    stats: {
+      totalQueries: 1,
+      totalToolCalls: 0,
+      totalDurationMs: 0
+    }
+  });
+
+  assert.equal(session.stats.totalToolCalls, 1);
+  assert.equal(session.getTotalToolCalls(), 1);
+  assert.equal(session.stats.totalDurationMs, 40);
+
+  const toolStats = session.getToolStats();
+  assert.equal(toolStats.search_works.count, 1);
+
+  const mockAgent = { session };
+  const res = await routeCommand('/session info', { agent: mockAgent, sub: 'info', extra: '' });
+  assert.equal(res, 'HANDLED');
+});
+

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

@@ -84,6 +84,40 @@ test('jukebox derives sidebar and tab counts from the playlist', () => {
   assert.doesNotMatch(html, /ทั้งหมด \(44\)/);
 });
 
+test('quick-action-menu jukebox entry opens through a single-call wrapper', () => {
+  const html = getWebChatHtml();
+
+  assert.match(html, /function openMusicFromQuickActions\(\)/);
+  const wrapperStart = html.indexOf('function openMusicFromQuickActions()');
+  const wrapperBody = html.slice(wrapperStart, wrapperStart + 300);
+  assert.match(wrapperBody, /closeQuickActions\(\)/);
+  assert.match(wrapperBody, /openMusicModal\(\)/);
+  assert.ok(wrapperBody.indexOf('closeQuickActions()') < wrapperBody.indexOf('openMusicModal()'));
+
+  assert.match(html, /onclick="openMusicFromQuickActions\(\)"/);
+  assert.doesNotMatch(html, /onclick="openMusicModal\(\); closeQuickActions\(\)"/);
+});
+
+test('every static onclick handler in the chat shell is exposed on window', () => {
+  const html = getWebChatHtml();
+
+  for (const name of [
+    'openMusicModal',
+    'openMusicFromQuickActions',
+    'closeMusicModal',
+    'toggleAppSidebar',
+    'toggleQuickActions',
+    'closeQuickActions',
+    'openMiniPlayerFromCard',
+    'switchVoiceToDetectedLang',
+    'handleQuickChipClick',
+    'cycleSidebarAd'
+  ]) {
+    assert.match(html, new RegExp('function ' + name + '\\('), name + ' is defined');
+    assert.match(html, new RegExp('\\b' + name + ','), name + ' is exposed on window');
+  }
+});
+
 test('sidebar export downloads through the export API and reports failures', () => {
   const html = getWebChatHtml();
   const start = html.indexOf('async function exportChat()');

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

@@ -5,11 +5,18 @@ import path from 'node:path';
 import { mkdtemp, rm } from 'node:fs/promises';
 
 import { HierarchicalStore, parseAndValidatePath, computeContentHash } from '../memory/hierarchicalStore.js';
-import { ContextAllocator } from '../memory/contextAllocator.js';
+import { ContextAllocator, extractWordTokens } from '../memory/contextAllocator.js';
 import { ReflectionWorker } from '../memory/reflectionWorker.js';
 import { AgentMemory } from '../memory.js';
 import { executeTool } from '../tools.js';
 
+test('extractWordTokens segments Thai and CJK text without whitespace', () => {
+  const thaiTokens = extractWordTokens('จวีจิ้งอีผลงานเพลง');
+  const cjkTokens = extractWordTokens('鞠婧祎音乐作品');
+  assert.ok(thaiTokens.length >= 2, `expected Thai segmentation, got ${thaiTokens.join('|')}`);
+  assert.ok(cjkTokens.length >= 2, `expected CJK segmentation, got ${cjkTokens.join('|')}`);
+});
+
 test('parseAndValidatePath correctly parses valid hierarchical memory paths', () => {
   const p1 = parseAndValidatePath('kiku/runs/run_task_001/state');
   assert.equal(p1.section, 'runs');

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

@@ -124,3 +124,74 @@ test('systemDirectives callbacks are injected as system messages without touchin
     await rm(tempDir, { recursive: true, force: true });
   }
 });
+
+test('catalog tool returning not_found automatically escalates to external internet search and calls onToolRemove', async () => {
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-escalate-'));
+  const storageFile = path.join(tempDir, 'session.json');
+  const observedMessages = [];
+  const removedTools = [];
+  const startedTools = [];
+  let call = 0;
+
+  const client = {
+    provider: 'lmstudio',
+    providerName: 'LM Studio',
+    model: 'test-model',
+    async chat(options) {
+      call++;
+      observedMessages.push(options.messages.map(message => ({
+        role: message.role,
+        content: typeof message.content === 'string' ? message.content : null,
+        tool_calls: message.tool_calls || undefined,
+        tool_call_id: message.tool_call_id || undefined,
+        name: message.name || undefined
+      })));
+      if (call === 1) {
+        return {
+          role: 'assistant',
+          content: 'ขอตรวจสอบภาพในแค็ตตาล็อกก่อนค่ะ\n```json\n{"action": "get_gallery_photos", "parameters": {"query": "万花世界"}}\n```',
+        };
+      }
+      return { role: 'assistant', content: 'พบภาพจากแหล่งข่าวภายนอกแล้วค่ะ' };
+    },
+  };
+
+  const agent = new KikuAgent({
+    client,
+    memory: createMemoryStub(),
+    mcpManager: new McpClientManager({
+      autoLoad: false,
+      globalConfigPath: path.join(tempDir, 'mcp.json'),
+    }),
+    sessionId: 'escalate_test',
+    sessionStorageFile: storageFile,
+  });
+
+  try {
+    await agent.ready();
+    const answer = await agent.run('อยากเห็นภาพซีรีส์ 万花世界 (Wanhua Sin)', {
+      onToolStart: (name) => startedTools.push(name),
+      onToolRemove: (name) => removedTools.push(name),
+    });
+
+    assert.match(answer, /พบภาพจากแหล่งข่าวภายนอกแล้วค่ะ/);
+    assert.ok(startedTools.includes('get_gallery_photos'), 'get_gallery_photos must have started');
+    assert.ok(removedTools.includes('get_gallery_photos'), 'get_gallery_photos must have been removed from UI');
+    assert.ok(
+      startedTools.includes('search_web_images') || startedTools.includes('web_search'),
+      'external internet search tool must have been triggered'
+    );
+
+    const secondCall = observedMessages[1];
+    const toolMsg = secondCall.find(m => m.role === 'tool');
+    assert.ok(toolMsg, 'tool result message must be sent to model');
+    assert.ok(
+      toolMsg.name === 'search_web_images' || toolMsg.name === 'web_search',
+      'tool message name must be the external search tool'
+    );
+  } finally {
+    await agent.mcpManager.disconnectAll().catch(() => { });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+

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

@@ -137,3 +137,51 @@ test('static catalog tools are TTL-cached while the social feed stays fresh', as
   const feedSecond = await executeTool('get_social_feed', { limit: 1 });
   assert.notEqual(feedSecond, feedFirst);
 });
+
+test('text tool call parsing handles [TOOLCALL] syntax with <|"|> tokenizer delimiters and websearch alias', () => {
+  const agent = bareAgent();
+  const rawSnippet = [
+    '💖 โอ๊ย! เข้าใจเลยค่ะว่าอยากเห็นบรรยากาศของซีรีส์ก่อนดูจริง ๆ ใช่ไหมคะ? ✨',
+    'แต่ Concept Art ที่ระบุเจาะจงในฐานข้อมูลแกลเลอรีของเรายังไม่มีการบันทึกเข้ามาอย่างเป็นทางการค่ะ 🥺',
+    'ดิฉันจึงได้ทำการค้นหาภาพบรรยากาศล่าสุดจากแหล่งข่าวภายนอกมาให้คุณดู',
+    '',
+    '[TOOLCALL]',
+    'websearch{keywords:<|"|>万花世界 概念图 万花世界 剧照<|"|>,targetlanguage:<|"|>zh<|"|>}<toolcall|>',
+    '',
+    'พบปัยหาเเล้ว'
+  ].join('\n');
+
+  const { calls, malformed } = agent._extractTextToolCalls(rawSnippet);
+  assert.equal(malformed, 0);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].function.name, 'web_search');
+  const args = JSON.parse(calls[0].function.arguments);
+  assert.equal(args.keywords, '万花世界 概念图 万花世界 剧照');
+  assert.equal(args.target_language, 'zh');
+});
+
+test('stripToolCallBlocks and sanitizeResponse thoroughly strip [TOOLCALL] and synthetic tokens', async () => {
+  const { stripToolCallBlocks } = await import('../textToolProtocol.js');
+  const { sanitizeResponse } = await import('../sanitizer.js');
+
+  const rawSnippet = [
+    '💖 โอ๊ย! เข้าใจเลยค่ะ',
+    '[TOOLCALL]',
+    'websearch{keywords:<|"|>万花世界 概念图 万花世界 剧照<|"|>,targetlanguage:<|"|>zh<|"|>}<toolcall|>',
+    'ข้อความต่อมา'
+  ].join('\n');
+
+  const stripped = stripToolCallBlocks(rawSnippet);
+  assert.ok(!stripped.includes('[TOOLCALL]'));
+  assert.ok(!stripped.includes('<toolcall'));
+  assert.ok(!stripped.includes('<|"|>'));
+  assert.ok(!stripped.includes('websearch'));
+  assert.ok(stripped.includes('💖 โอ๊ย! เข้าใจเลยค่ะ'));
+  assert.ok(stripped.includes('ข้อความต่อมา'));
+
+  const sanitized = sanitizeResponse(rawSnippet);
+  assert.ok(!sanitized.includes('[TOOLCALL]'));
+  assert.ok(!sanitized.includes('<toolcall'));
+  assert.ok(!sanitized.includes('<|"|>'));
+});
+

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

@@ -44,6 +44,47 @@ test('profile queries no longer leak SYSTEM_SKILL tools via "file" inside "profi
   assert.ok(!intents.includes('SYSTEM_SKILL'), '"file" inside "profile" must not route SYSTEM_SKILL');
 });
 
+test('off-topic queries enforce internet tools and suppress all catalog tools', () => {
+  const router = new DynamicToolRouter();
+  const catalogTools = new Set([
+    'search_works', 'get_work_detail', 'search_discography', 'get_profile_and_fandom',
+    'get_awards', 'get_brand_endorsements', 'get_career_timeline', 'get_character_roles',
+    'get_gallery_photos', 'get_quotes', 'get_social_feed', 'global_search', 'get_media_links',
+  ]);
+  for (const q of [
+    'วิธีทำต้มยำกุ้งน้ำข้น',
+    'แนะนำเพลงสากลเพราะๆ หน่อย',
+    'หนัง Dune ภาคใหม่สนุกไหม',
+    'ประวัติศาสตร์อยุธยาตอนต้น',
+    'เขียนฟังก์ชันเรียงข้อมูลให้หน่อย',
+  ]) {
+    const names = router.routeToolsForQuery(q).map(t => t.function?.name);
+    assert.ok(names.includes('web_search'), `${q} must include web_search`);
+    for (const c of catalogTools) {
+      assert.ok(!names.includes(c), `${q} must not route catalog tool ${c}`);
+    }
+  }
+});
+
+test('off-topic enforcement keeps in-domain music routing intact', () => {
+  const router = new DynamicToolRouter();
+  const names = router.routeToolsForQuery('เพลง 0.2s ใครร้อง').map(t => t.function?.name);
+  assert.ok(names.includes('search_discography'), 'in-domain song query keeps search_discography');
+});
+
+test('explicit @mention pins survive off-topic enforcement', () => {
+  const router = new DynamicToolRouter();
+  const names = router.routeToolsForQuery('วิธีทำต้มยำกุ้ง @search_works').map(t => t.function?.name);
+  assert.ok(names.includes('search_works'), 'explicit user pin must survive enforcement');
+});
+
+test('ฟังก์ชัน no longer collides with the ฟัง music intent', () => {
+  const router = new DynamicToolRouter();
+  const types = router.detectIntents('เขียนฟังก์ชันเรียงข้อมูลให้หน่อย').map(p => p.type);
+  assert.ok(!types.includes('MEDIA'), 'ฟังก์ชัน must not route MEDIA');
+  assert.ok(router.detectIntents('ขอฟังเพลงก่อนนอนหน่อย').map(p => p.type).includes('MEDIA'), 'ฟังเพลง must still route MEDIA');
+});
+
 test('promotion intent no longer fires on generic words like "look" or "brand"', () => {
   assert.equal(detectPromotionIntent('What does she look like?'), false);
   assert.equal(detectPromotionIntent('a brand new song'), false);