kiku-agent 1.3.1 → 1.3.2

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

@@ -0,0 +1,139 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { extractTopLevelJsonObjects } from '../agentCore.js';
+import { KikuAgent } from '../agentCore.js';
+import { LLMClient } from '../llmClient.js';
+import { executeTool } from '../tools.js';
+
+function bareAgent() {
+  const agent = Object.create(KikuAgent.prototype);
+  agent.mcpManager = null;
+  agent.allowedToolNames = null;
+  return agent;
+}
+
+test('extractTopLevelJsonObjects handles nested objects and braces inside strings', () => {
+  const { objects, unbalanced } = extractTopLevelJsonObjects(
+    'prefix {"action": "web_search", "parameters": {"query": "In Blossom {花间令} 2024"}} suffix'
+  );
+
+  assert.equal(unbalanced, null);
+  assert.equal(objects.length, 1);
+  const parsed = JSON.parse(objects[0].raw);
+  assert.equal(parsed.action, 'web_search');
+  assert.equal(parsed.parameters.query, 'In Blossom {花间令} 2024');
+});
+
+test('extractTopLevelJsonObjects reports unterminated objects instead of truncating them', () => {
+  const { objects, unbalanced } = extractTopLevelJsonObjects('{"action": "web_search", "parameters": {"query": "truncated"');
+
+  assert.equal(objects.length, 0);
+  assert.ok(unbalanced.startsWith('{"action"'));
+});
+
+test('extractTopLevelJsonObjects finds multiple sibling objects', () => {
+  const { objects } = extractTopLevelJsonObjects('{"a": {"b": 1}} gap {"c": 2}');
+
+  assert.equal(objects.length, 2);
+  assert.deepEqual(JSON.parse(objects[1].raw), { c: 2 });
+});
+
+test('text tool call parsing accepts nested JSON in fenced blocks (previously cut in half)', () => {
+  const agent = bareAgent();
+  const content = [
+    'Let me check the catalog.',
+    '```json',
+    '{"action": "search_discography", "parameters": {"query": "FIND THE WAY", "type": "single"}}',
+    '```',
+  ].join('\n');
+
+  const { calls, malformed } = agent._extractTextToolCalls(content);
+  assert.equal(malformed, 0);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].function.name, 'search_discography');
+  assert.deepEqual(JSON.parse(calls[0].function.arguments), { query: 'FIND THE WAY', type: 'single' });
+});
+
+test('text tool call parsing still understands ReAct Action blocks with nested input', () => {
+  const agent = bareAgent();
+  const content = 'Action: get_work_detail\nAction Input: {"workIdOrTitle": "in-blossom", "options": {"withOst": true}}';
+
+  const { calls, malformed } = agent._extractTextToolCalls(content);
+  assert.equal(malformed, 0);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].function.name, 'get_work_detail');
+  const args = JSON.parse(calls[0].function.arguments);
+  assert.equal(args.workIdOrTitle, 'in-blossom');
+  assert.equal(args.options.withOst, true);
+});
+
+test('non-JSON Action Input is salvaged as a query argument, not marked malformed', () => {
+  const agent = bareAgent();
+  const { calls, malformed } = agent._extractTextToolCalls('Action: web_search\nAction Input: Ju Jingyi 2026 drama');
+
+  assert.equal(malformed, 0);
+  assert.equal(calls.length, 1);
+  assert.deepEqual(JSON.parse(calls[0].function.arguments), { query: 'Ju Jingyi 2026 drama' });
+});
+
+test('malformed tool-call blocks are counted so the loop can feed back instead of answering', () => {
+  const agent = bareAgent();
+
+  const truncated = agent._extractTextToolCalls(
+    '```json\n{"action": "web_search", "parameters": {"query": "unterminated\n```'
+  );
+  assert.equal(truncated.calls.length, 0);
+  assert.ok(truncated.malformed >= 1);
+
+  const trailingComma = agent._extractTextToolCalls(
+    '```json\n{"action": "web_search", "parameters": {"query": "x",}}\n```'
+  );
+  assert.equal(trailingComma.calls.length, 0);
+  assert.equal(trailingComma.malformed, 1);
+
+  const truncatedAction = agent._extractTextToolCalls(
+    'Action: web_search\nAction Input: {"query": "broken"'
+  );
+  assert.equal(truncatedAction.calls.length, 0);
+  assert.equal(truncatedAction.malformed, 1);
+});
+
+test('parseTextToolCalls keeps its historical return shape (calls only)', () => {
+  const agent = bareAgent();
+  const calls = agent.parseTextToolCalls(
+    '```json\n{"action": "get_awards", "parameters": {"year": 2024}}\n```'
+  );
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].function.name, 'get_awards');
+});
+
+test('unknown tool names in text blocks are ignored without breaking parsing', () => {
+  const agent = bareAgent();
+  const { calls, malformed } = agent._extractTextToolCalls(
+    '```json\n{"action": "not_a_real_tool", "parameters": {}}\n```\n```json\n{"action": "get_quotes", "parameters": {}}\n```'
+  );
+  assert.equal(malformed, 0);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].function.name, 'get_quotes');
+});
+
+test('reasoner-class models report that native tools will be omitted', () => {
+  const reasoner = Object.create(LLMClient.prototype);
+  reasoner.model = 'deepseek-reasoner';
+  const normal = Object.create(LLMClient.prototype);
+  normal.model = 'gpt-4o';
+
+  assert.equal(reasoner.toolsWillBeOmitted(), true);
+  assert.equal(normal.toolsWillBeOmitted(), false);
+});
+
+test('static catalog tools are TTL-cached while the social feed stays fresh', async () => {
+  const awardsFirst = await executeTool('get_awards', {});
+  const awardsSecond = await executeTool('get_awards', {});
+  assert.equal(awardsSecond, awardsFirst);
+
+  const feedFirst = await executeTool('get_social_feed', { limit: 1 });
+  const feedSecond = await executeTool('get_social_feed', { limit: 1 });
+  assert.notEqual(feedSecond, feedFirst);
+});

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

@@ -0,0 +1,26 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { C } from '../ui.js';
+import { THEME_NAMES, getThemeName, getThemePalette, setTheme } from '../theme.js';
+
+test('theme catalog exposes several distinct choices', () => {
+  assert.deepEqual(THEME_NAMES, ['sakura', 'midnight', 'ocean', 'forest', 'sunset', 'monochrome']);
+  assert.equal(new Set(THEME_NAMES.map(name => getThemePalette(name).panel)).size, THEME_NAMES.length);
+  assert.equal(new Set(THEME_NAMES.map(name => getThemePalette(name).text)).size, THEME_NAMES.length);
+});
+
+test('changing theme updates shared ANSI colors without restarting', () => {
+  const original = getThemeName();
+  const originalPrimary = C.sakura;
+
+  setTheme(original === 'midnight' ? 'forest' : 'midnight', { persist: false });
+  assert.notEqual(C.sakura, originalPrimary);
+  assert.match(C.bgPanel, /^\x1b\[48;2;/);
+
+  setTheme(original, { persist: false });
+});
+
+test('unknown theme names are rejected', () => {
+  assert.equal(setTheme('not-a-theme', { persist: false }), null);
+});

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

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { toolsSchema, toolHandlers } from '../tools.js';
+import { TOOL_CLUSTERS } from '../toolRouter.js';
+import { DEFAULT_RESEARCH_TOOLS } from '../subagent.js';
+import { CATALOG_TOOLS, WEB_TOOLS, VERIFY_TOOLS } from '../research.js';
+import { PUBLIC_REMOTE_TOOL_NAMES } from '../publicTools.js';
+import { toolDefinitions } from '../../mcp/tools.js';
+
+
+const KNOWN_MCP_ALIASES = new Set(['get_profile', 'get_timeline', 'search_gallery']);
+
+test('every schema tool has a handler and vice versa', () => {
+  const schemaNames = new Set(toolsSchema.map(t => t.function.name));
+  const handlerNames = new Set(Object.keys(toolHandlers));
+
+  const orphans = [...schemaNames].filter(n => !handlerNames.has(n));
+  const ghosts = [...handlerNames].filter(n => !schemaNames.has(n));
+  assert.deepEqual(orphans, [], 'schema entries without handlers');
+  assert.deepEqual(ghosts, [], 'handlers without schema entries');
+});
+
+test('every hardcoded tool-name list references real tools', () => {
+  const schemaNames = new Set(toolsSchema.map(t => t.function.name));
+  const problems = [];
+
+  const checkList = (label, names) => {
+    for (const name of names) {
+      if (!schemaNames.has(name)) problems.push(`${label} -> unknown tool "${name}"`);
+    }
+  };
+
+  for (const [cluster, names] of Object.entries(TOOL_CLUSTERS)) {
+    checkList(`TOOL_CLUSTERS.${cluster}`, names);
+  }
+  checkList('DEFAULT_RESEARCH_TOOLS', DEFAULT_RESEARCH_TOOLS);
+  checkList('research CATALOG_TOOLS', CATALOG_TOOLS);
+  checkList('research WEB_TOOLS', WEB_TOOLS);
+  checkList('research VERIFY_TOOLS', VERIFY_TOOLS);
+  checkList('PUBLIC_REMOTE_TOOL_NAMES', PUBLIC_REMOTE_TOOL_NAMES);
+
+  assert.deepEqual(problems, [], 'stale tool names in hardcoded lists');
+});
+
+test('mcp tool definitions reference real tools (plus the documented aliases)', () => {
+  const schemaNames = new Set(toolsSchema.map(t => t.function.name));
+  const unknown = toolDefinitions
+    .map(t => t.name)
+    .filter(name => !schemaNames.has(name) && !KNOWN_MCP_ALIASES.has(name));
+
+  assert.deepEqual(unknown, [], 'mcp definitions referencing non-existent tools');
+});

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

@@ -0,0 +1,119 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DynamicToolRouter } from '../toolRouter.js';
+import { resolveQueryEntities, buildCatalogIndex, detectPromotionIntent } from '../catalogEntityResolver.js';
+import { createCatalogMatcher, executeTool } from '../tools.js';
+import { KikuAgent } from '../agentCore.js';
+import { McpClientManager } from '../mcpClient.js';
+
+const MULTI_INTENT_QUERY = 'เปิดเพลงล่าสุดของจวีจิ้งอี และดูคลิปละครใหม่หน่อย ล่าสุดมีข่าวไหม';
+
+test('router keeps playback tools visible when multiple intents share the 15-tool cap', () => {
+  const router = new DynamicToolRouter();
+  const routed = router.routeToolsForQuery(MULTI_INTENT_QUERY, { includeMcp: true });
+  const names = new Set(routed.map(t => t.function?.name));
+
+  assert.ok(routed.length <= 15, `Expected cap of 15, got ${routed.length}`);
+  assert.ok(names.has('play_music'), 'play_music must survive the cap on a play request');
+  assert.ok(names.has('search_discography'), 'search_discography must survive the cap');
+  assert.ok(names.has('search_works'), 'second intent essentials must follow the first intent before generic tools');
+  assert.ok(names.has('get_character_roles'), 'WORKS essentials must be included before the cap cuts them');
+});
+
+test('router no longer routes PROFILE intent on substring collisions', () => {
+  const router = new DynamicToolRouter();
+
+  const winter = router.detectIntents('Tell me about her winter concert');
+  const winterTypes = winter.map(p => p.type);
+  assert.ok(winterTypes.includes('MEDIA'), 'concert should route MEDIA');
+  assert.ok(!winterTypes.includes('PROFILE_AWARDS_BRANDS'), '"win" inside "winter" must not route PROFILE');
+
+  const superlative = router.detectIntents('เพลงที่ยอดวิวสูงสุดของเธอคือเพลงไหน');
+  const superlativeTypes = superlative.map(p => p.type);
+  assert.ok(superlativeTypes.includes('MEDIA'));
+  assert.ok(!superlativeTypes.includes('PROFILE_AWARDS_BRANDS'), 'สูงสุด must not route PROFILE');
+
+  const happen = router.detectIntents('มีอะไรเกิดขึ้นกับงานนี้');
+  assert.ok(!happen.map(p => p.type).includes('PROFILE_AWARDS_BRANDS'), 'เกิดขึ้น must not route PROFILE');
+});
+
+test('profile queries no longer leak SYSTEM_SKILL tools via "file" inside "profile"', () => {
+  const router = new DynamicToolRouter();
+  const intents = router.detectIntents('Show me her profile and fandom details').map(p => p.type);
+  assert.ok(intents.includes('PROFILE_AWARDS_BRANDS'));
+  assert.ok(!intents.includes('SYSTEM_SKILL'), '"file" inside "profile" must not route SYSTEM_SKILL');
+});
+
+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);
+  assert.equal(detectPromotionIntent('her fashion ambassador campaign'), true);
+  assert.equal(detectPromotionIntent('รับโปรโมทแบรนด์'), true);
+
+  const lookRes = resolveQueryEntities('What does she look like?');
+  assert.equal(lookRes.isPromotion, false);
+  assert.equal(lookRes.hasBrand, false);
+});
+
+test('brand entities have no Thai name fallback polluted by category strings', () => {
+  const index = buildCatalogIndex();
+  const prsr = index.find(e => e.id === 'prsr');
+  assert.ok(prsr, 'prsr entity must exist');
+  assert.equal(prsr.nameTh, '');
+});
+
+test('get_awards returns not_found instead of the full list when the query matches nothing', async () => {
+  const empty = await executeTool('get_awards', { query: 'quantum oscars 2099' });
+  assert.equal(empty.status, 'not_found');
+  assert.equal(empty.count, 0);
+  assert.deepEqual(empty.awards, []);
+
+  const all = await executeTool('get_awards', {});
+  assert.equal(all.status, 'success');
+  assert.ok(all.count > 0);
+});
+
+test('get_gallery_photos returns not_found instead of the full list when the query matches nothing', async () => {
+  const empty = await executeTool('get_gallery_photos', { query: 'quantum oscars 2099' });
+  assert.equal(empty.status, 'not_found');
+  assert.equal(empty.count, 0);
+  assert.deepEqual(empty.photos, []);
+});
+
+test('stopword-only catalog queries are flagged as broad matches with an explicit note', () => {
+  const matcher = createCatalogMatcher('MV จวีจิ้งอี');
+  assert.equal(matcher.broad, true, 'stopword-only query must set the broad flag');
+  assert.equal(createCatalogMatcher('In Blossom').broad, undefined, 'real-term queries must not set the broad flag');
+  assert.equal(createCatalogMatcher('').broad, undefined, 'empty query is an intentional full listing, not broad');
+});
+
+test('search_works appends a broad-query note so the model does not present latest entries as matches', async () => {
+  const broad = await executeTool('search_works', { query: 'MV จวีจิ้งอี' });
+  assert.equal(broad.status, 'success');
+  assert.ok(broad.message, 'broad query must attach an explanatory message');
+  assert.match(broad.message, /Broad query/);
+
+  const exact = await executeTool('search_works', { query: 'In Blossom' });
+  assert.equal(exact.status, 'success');
+  assert.equal(exact.message, undefined);
+});
+
+test('text tool protocol parses against the active tool set, not the full schema', () => {
+  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 content = 'Action: get_awards\nAction Input: {"query": "Oscar"}';
+  const unrestricted = agent._extractTextToolCalls(content);
+  assert.ok(unrestricted.calls.length === 1, 'without routing, the full schema applies');
+
+  agent._activeToolSchema = agent.getAllToolsSchema().filter(t => t.function.name === 'search_works');
+  const restricted = agent._extractTextToolCalls(content);
+  assert.equal(restricted.calls.length, 0, 'tools hidden by the router must not be callable via text protocol');
+});

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

@@ -0,0 +1,259 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { executeTool, formatCatalogTitle, prepareToolArguments, toolHandlers } from '../tools.js';
+
+test('catalog titles do not repeat an alternate title already present', () => {
+  assert.equal(formatCatalogTitle('รักกลางสายฝน (Yu Ai / 雨爱)', '雨爱'), 'รักกลางสายฝน (Yu Ai / 雨爱)');
+  assert.equal(formatCatalogTitle('In Blossom', '花间令'), 'In Blossom (花间令)');
+});
+
+test('discography search reports an empty result as not found', async () => {
+  const result = await toolHandlers.search_discography({
+    query: 'no-such-kiku-track-xyz',
+    type: 'ost',
+  });
+
+  assert.equal(result.status, 'not_found');
+  assert.equal(result.count, 0);
+});
+
+test('supported drama OST example returns catalog entries', async () => {
+  const result = await toolHandlers.search_discography({
+    query: 'The Blooms at Ruyi Pavilion',
+    type: 'ost',
+  });
+
+  assert.equal(result.status, 'success');
+  assert.ok(result.count >= 1);
+});
+
+test('global search ignores generic OST wording and still finds the drama', async () => {
+  const result = await toolHandlers.global_search({ query: 'In Blossom OST songs' });
+
+  assert.equal(result.status, 'success');
+  assert.ok(result.results.works.some(work => work.title.includes('In Blossom')));
+});
+
+test('tool runtime rejects malformed JSON instead of inventing a query argument', () => {
+  const prepared = prepareToolArguments('global_search', '{query: broken json}');
+  assert.equal(prepared.safe, false);
+  assert.match(prepared.error, /Invalid JSON arguments/);
+});
+
+test('tool runtime validates required arguments and removes unknown keys', () => {
+  assert.equal(prepareToolArguments('global_search', {}).safe, false);
+  const prepared = prepareToolArguments('global_search', { query: 'In Blossom', unexpected: true });
+  assert.equal(prepared.safe, true);
+  assert.deepEqual(prepared.args, { query: 'In Blossom' });
+  assert.match(prepared.warnings.join(' '), /unexpected/);
+});
+
+test('tool runtime normalizes empty successful collections to not_found', async () => {
+  const result = await executeTool('search_works', { year: '1900' });
+  assert.equal(result.status, 'not_found');
+  assert.equal(result.count, 0);
+  assert.match(result.validationWarnings.join(' '), /converted to number/);
+});
+
+test('search_works maps category synonyms onto real catalog values (no false not_found)', async () => {
+ 
+  const series = await executeTool('search_works', { category: 'series', featuredOnly: true }, { noCache: true });
+  assert.equal(series.status, 'success');
+  assert.ok(series.count > 0);
+  assert.ok(series.works.every(w => ['historical-drama', 'modern-drama'].includes(w.category)));
+
+  const movie = await executeTool('search_works', { category: 'movie' }, { noCache: true });
+  assert.equal(movie.status, 'success');
+  assert.ok(movie.count >= 1);
+  assert.ok(movie.works.every(w => w.category === 'movie'));
+
+
+  const junk = await executeTool('search_works', { category: 'documentary' }, { noCache: true });
+  assert.equal(junk.status, 'not_found');
+});
+
+test('manage_skill tool executes learn, list, disable, and remove actions', async () => {
+  const memory = {
+    preferences: { skillsEnabled: true, userSkills: [] },
+    addUserSkill(inst) {
+      const s = { id: 'sk_test', instruction: inst };
+      this.preferences.userSkills.push(s);
+      return s;
+    },
+    removeUserSkill(id) {
+      const idx = this.preferences.userSkills.findIndex(s => s.id === id);
+      if (idx >= 0) {
+        this.preferences.userSkills.splice(idx, 1);
+        return true;
+      }
+      return false;
+    },
+    clearUserSkills() { this.preferences.userSkills = []; },
+    setPreference(k, v) { this.preferences[k] = v; },
+  };
+
+  const learnRes = await executeTool('manage_skill', { action: 'learn', instruction: 'ตอบสั้นกระชับ' }, { memory });
+  assert.equal(learnRes.status, 'success');
+  assert.equal(learnRes.skill.instruction, 'ตอบสั้นกระชับ');
+
+  const listRes = await executeTool('manage_skill', { action: 'list' }, { memory });
+  assert.equal(listRes.status, 'success');
+  assert.equal(listRes.skills.length, 1);
+
+  const disableRes = await executeTool('manage_skill', { action: 'disable' }, { memory });
+  assert.equal(disableRes.status, 'success');
+  assert.equal(memory.preferences.skillsEnabled, false);
+
+  const removeRes = await executeTool('manage_skill', { action: 'remove', skillId: 'sk_test' }, { memory });
+  assert.equal(removeRes.status, 'success');
+  assert.equal(memory.preferences.userSkills.length, 0);
+});
+
+test('run_subagent tool routes through agent context when available', async () => {
+  const mockAgent = {
+    async runSubagent(task) {
+      return { answer: `Report for ${task}`, toolCalls: [{ name: 'search_works' }], iterations: 1 };
+    }
+  };
+
+  const res = await executeTool('run_subagent', { task: 'Verify 2026 drama' }, { agent: mockAgent });
+  assert.equal(res.status, 'success');
+  assert.equal(res.task, 'Verify 2026 drama');
+  assert.match(res.answer, /Report for/);
+  assert.equal(res.toolCalls.length, 1);
+});
+
+test('run_deep_research and verify_claim route through agent research orchestrator', async () => {
+  let verifyModeCalled = false;
+  const mockAgent = {
+    async runResearch(query, options = {}) {
+      if (options.mode === 'verify') verifyModeCalled = true;
+      return { answer: `Synthesized for ${query}`, sources: ['https://example.com/source1'], reports: [] };
+    }
+  };
+
+  const researchRes = await executeTool('run_deep_research', { question: 'All 2026 plans' }, { agent: mockAgent });
+  assert.equal(researchRes.status, 'success');
+  assert.equal(researchRes.sources.length, 1);
+
+  const verifyRes = await executeTool('verify_claim', { claim: 'Is Qian Xiang releasing in 2026' }, { agent: mockAgent });
+  assert.equal(verifyRes.status, 'success');
+  assert.equal(verifyModeCalled, true);
+});
+
+test('globalToolCache stores and returns cached tool execution results', async () => {
+  const { globalToolCache, ToolCache } = await import('../tools.js');
+  const cache = new ToolCache(10, 5000);
+  cache.set('test_key', { data: 123 });
+  assert.deepEqual(cache.get('test_key'), { data: 123 });
+  assert.equal(cache.get('non_existent'), null);
+
+  const firstCall = await executeTool('get_awards', {});
+  assert.equal(firstCall.status, 'success');
+
+  const secondCall = await executeTool('get_awards', {});
+  assert.equal(secondCall.status, 'success');
+  assert.deepEqual(firstCall.awards, secondCall.awards);
+});
+
+test('get_brand_endorsements finds Versace and global brand ambassador roles', async () => {
+  const versaceRes = await executeTool('get_brand_endorsements', { query: 'Versace', isGlobal: true });
+  assert.equal(versaceRes.status, 'success');
+  assert.ok(versaceRes.count >= 1);
+  assert.ok(versaceRes.brands.some(b => b.brand.toLowerCase().includes('versace')));
+
+  const prsrRes = await executeTool('get_brand_endorsements', { query: 'PRSR' });
+  assert.equal(prsrRes.status, 'success');
+  assert.ok(prsrRes.count >= 1);
+  assert.ok(prsrRes.brands.some(b => b.brand.includes('PRSR')));
+});
+
+
+test('createCatalogMatcher uses scoring fuzzy matching for multi-word and misspelled queries', async () => {
+  const { createCatalogMatcher } = await import('../tools.js');
+  const matcher = createCatalogMatcher('เพลง Ost Ju Jingyi 2024 Yunxi');
+  assert.equal(matcher('ตำนานหยุนซี Legend of Yunxi', 'Yunxi'), true);
+
+  const res = await executeTool('search_works', { query: 'เพลง Ost Ju Jingyi 2024 Yunxi' });
+  assert.equal(res.status, 'success');
+  assert.ok(res.count > 0);
+  assert.ok(res.works.some(w => (w.titleTh || '').includes('หยุนซี') || (w.titleEn || '').toLowerCase().includes('yunxi')));
+});
+
+test('empty or not_found tool results are not stored in globalToolCache', async () => {
+  const { globalToolCache } = await import('../tools.js');
+  const query = 'totally_fake_drama_xyz_never_exists_123';
+  const notFound = await executeTool('search_works', { query });
+  assert.equal(notFound.status, 'not_found');
+
+  const cacheKey = `search_works:${JSON.stringify({ query })}`;
+  assert.equal(globalToolCache.get(cacheKey), null);
+});
+
+test('get_system_stats returns dynamically computed activeYears and metadata', async () => {
+  const statsRes = await executeTool('get_system_stats', {});
+  assert.equal(statsRes.status, 'success');
+  assert.equal(statsRes.sourceType, 'local_database');
+  assert.ok(statsRes.dataFreshness);
+  assert.match(statsRes.stats.activeYears, /2013 - Present/);
+  assert.ok(Array.isArray(statsRes.stats.featured2026Works));
+  assert.ok(statsRes.stats.featured2026Works.length > 0);
+});
+
+test('tool results distinguish direct links from search URLs with isDirectLink', async () => {
+  const worksRes = await executeTool('search_works', { query: 'In Blossom' });
+  assert.equal(worksRes.status, 'success');
+  const work = worksRes.works[0];
+  assert.equal(work.youtubeTrailerIsDirectLink, false);
+  if (work.themeSong) {
+    assert.equal(typeof work.themeSong.isDirectLink, 'boolean');
+  }
+
+  const discoRes = await executeTool('search_discography', { query: 'In Blossom' });
+  assert.equal(discoRes.status, 'success');
+  assert.equal(typeof discoRes.songs[0].isDirectLink, 'boolean');
+});
+
+test('generic artist-name queries return catalog data instead of false not_found', async () => {
+  for (const tool of ['search_works', 'search_discography', 'get_character_roles', 'get_music_videos', 'get_brand_endorsements', 'global_search']) {
+    const res = await executeTool(tool, { query: 'Ju Jingyi' }, { noCache: true });
+    assert.equal(res.status, 'success', `${tool} should not not_found a generic artist query`);
+    assert.ok((res.count ?? 0) > 0, `${tool} should return items for a generic artist query`);
+  }
+  const gallery = await executeTool('get_gallery_photos', { query: 'Ju Jingyi' }, { noCache: true });
+  assert.equal(gallery.status, 'success');
+  assert.ok(gallery.count > 0);
+});
+
+test('latest-intent queries fall back to the newest-first catalog list', async () => {
+  const works = await executeTool('search_works', { query: 'เรื่องล่าสุด' }, { noCache: true });
+  assert.equal(works.status, 'success');
+  assert.ok(works.count > 0);
+
+  const songs = await executeTool('search_discography', { query: 'เพลงล่าสุด' }, { noCache: true });
+  assert.equal(songs.status, 'success');
+  assert.ok(songs.count > 0);
+});
+
+test('get_social_feed aggregates douyin and weibo cards', async () => {
+  const res = await executeTool('get_social_feed', { limit: 4 }, { noCache: true });
+  assert.equal(res.status, 'success');
+  assert.ok(res.count > 0);
+  assert.ok(res.posts.every(p => p.platform === 'douyin' || p.platform === 'weibo'));
+  assert.ok(res.posts[0].content && res.posts[0].content.length > 10);
+
+  const weibo = await executeTool('get_social_feed', { platform: 'weibo', limit: 2 }, { noCache: true });
+  assert.equal(weibo.status, 'success');
+  assert.ok(weibo.posts.every(p => p.platform === 'weibo'));
+});
+
+test('get_work_detail resolves dash/underscore/space id variants and fuzzy titles', async () => {
+  for (const variant of ['in-blossom', 'in_blossom', 'in blossom']) {
+    const res = await executeTool('get_work_detail', { workIdOrTitle: variant }, { noCache: true });
+    assert.equal(res.status, 'success', `id variant "${variant}" should resolve`);
+    assert.match(res.work.id, /in-blossom/);
+  }
+  const missing = await executeTool('get_work_detail', { workIdOrTitle: 'no-such-work-xyz' }, { noCache: true });
+  assert.equal(missing.status, 'not_found');
+});