kiku-agent 1.3.2 → 1.3.3

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

@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
+import { readFileSync } from 'node:fs';
 import { getWebChatHtml } from '../../webChatHtml.js';
 import { executeDirectCatalogKnowledge, makeInspectableToolPayload } from '../../webChatServer.js';
 
@@ -12,9 +13,9 @@ test('web chat tool payloads redact secrets and bound large values', () => {
   }, { maxArrayItems: 2 });
 
   assert.equal(payload.query, 'In Blossom');
-  assert.equal(payload.apiKey, '[redacted]');
-  assert.equal(payload.nested.token, '[redacted]');
-  assert.deepEqual(payload.values, [0, 1, '… [ตัดอีก 3 รายการ]']);
+  assert.equal(payload.apiKey, '···');
+  assert.equal(payload.nested.token, '···');
+  assert.deepEqual(payload.values, [0, 1, '… ย่ออีก 3 รายการ']);
 });
 
 test('direct catalog fallback retains inspectable tool input and result', async () => {
@@ -27,6 +28,169 @@ test('direct catalog fallback retains inspectable tool input and result', async
   assert.ok(Number.isFinite(tool.durationMs));
 });
 
+test('agent bare URLs render as clickable _blank links without double-wrapping', () => {
+  const src = readFileSync(new URL('../../web-chat/ui/scripts/client.js', import.meta.url), 'utf8');
+  const start = src.indexOf('function linkifyBareUrls(segment)');
+  assert.ok(start >= 0);
+  let depth = 0;
+  let end = -1;
+  for (let i = src.indexOf('{', start); i < src.length; i++) {
+    if (src[i] === '{') depth++;
+    else if (src[i] === '}') {
+      depth--;
+      if (depth === 0) {
+        end = i + 1;
+        break;
+      }
+    }
+  }
+  assert.ok(end > start);
+  const escapeHtml = (s) => String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+  const linkifyBareUrls = new Function('escapeHtml', src.slice(start, end) + '; return linkifyBareUrls;')(escapeHtml);
+
+  const linked = linkifyBareUrls('ชมได้ที่ https://www.youtube.com/watch?v=OMLpNyp8T7Q จบ.');
+  assert.match(linked, /<a href="https:\/\/www\.youtube\.com\/watch\?v=OMLpNyp8T7Q" target="_blank" rel="noopener noreferrer" class="md-link">/);
+
+  const intact = linkifyBareUrls('<a href="https://a.test">https://a.test</a>');
+  assert.equal((intact.match(/<a /g) || []).length, 1);
+
+  assert.equal(linkifyBareUrls('no link here'), 'no link here');
+});
+
+test('web chat loads KaTeX assets for math typesetting', () => {
+  const html = getWebChatHtml();
+  assert.match(html, /katex@0\.16\.11\/dist\/katex\.min\.css/);
+  assert.match(html, /katex@0\.16\.11\/dist\/katex\.min\.js/);
+  assert.match(html, /contrib\/auto-render\.min\.js/);
+  assert.match(html, /function typesetMathInBubble\(/);
+  assert.match(html, /renderMathInElement/);
+  assert.match(html, /KIKU_CLIENT_BUILD/);
+});
+
+test('math segments are shielded from markdown and restored as KaTeX targets', () => {
+  const src = readFileSync(new URL('../../web-chat/ui/scripts/client.js', import.meta.url), 'utf8');
+  const loadFn = (name) => {
+    const start = src.indexOf('function ' + name + '(');
+    assert.ok(start >= 0, name + ' must exist');
+    let depth = 0;
+    let end = -1;
+    for (let i = src.indexOf('{', start); i < src.length; i++) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') {
+        depth--;
+        if (depth === 0) {
+          end = i + 1;
+          break;
+        }
+      }
+    }
+    assert.ok(end > start);
+    return new Function(src.slice(start, end) + '; return ' + name + ';')();
+  };
+  const extractMathSegments = loadFn('extractMathSegments');
+  const restoreMathSegments = loadFn('restoreMathSegments');
+
+  const store = [];
+  const shielded = extractMathSegments('โจทย์ $\\lim_{x \\to 0} a * b$ และ $$x^2$$ จบ ส่วน `$y$` ในโค้ดไม่แตะ', store);
+  assert.equal(store.length, 2);
+  assert.ok(shielded.includes('§§§MATH0§§§'));
+  assert.ok(shielded.includes('§§§MATH1§§§'));
+  assert.ok(shielded.includes('`$y$`'), 'math inside inline code must stay untouched');
+  assert.ok(!shielded.includes('\\lim'), 'raw math must not leak into markdown processing');
+
+  const restored = restoreMathSegments(shielded, store);
+  assert.match(restored, /<span class="math-inline">\$\\lim/);
+  assert.match(restored, /<div class="math-display">\$\$x\^2\$\$<\/div>/);
+
+  assert.equal(extractMathSegments('ราคา $100 บาท', []), 'ราคา $100 บาท');
+  assert.equal(extractMathSegments('no math here', []).includes('§§§MATH'), false);
+});
+
+test('latexToUnicode fallback covers calculus symbols without KaTeX', () => {
+  const src = readFileSync(new URL('../../web-chat/ui/scripts/client.js', import.meta.url), 'utf8');
+  const loadBlock = (prefix) => {
+    const start = src.indexOf(prefix);
+    assert.ok(start >= 0, prefix + ' must exist');
+    let depth = 0;
+    let end = -1;
+    for (let i = src.indexOf('{', start); i < src.length; i++) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') {
+        depth--;
+        if (depth === 0) {
+          end = i + 1;
+          break;
+        }
+      }
+    }
+    assert.ok(end > start);
+    return src.slice(start, end);
+  };
+  const sandbox = loadBlock('const LATEX_SYMBOL_MAP =') + '\n' +
+    loadBlock('const LATEX_SUP_MAP =') + '\n' +
+    loadBlock('const LATEX_SUB_MAP =') + '\n' +
+    src.slice(src.indexOf('function latexReadBrace('), src.indexOf('function latexMapChars(')) + '\n' +
+    src.slice(src.indexOf('function latexMapChars('), src.indexOf('function latexToUnicode(')) + '\n' +
+    src.slice(src.indexOf('function latexToUnicode('), src.indexOf('window.latexToUnicode')) +
+    '\nreturn latexToUnicode;';
+  const latexToUnicode = new Function(sandbox)();
+  assert.equal(latexToUnicode('\\frac{1}{2}'), '(1)/(2)');
+  assert.equal(latexToUnicode('L = \\frac{1}{\\sqrt{e}}'), 'L = (1)/(√(e))');
+  assert.equal(latexToUnicode('1^\\infty'), '1^∞');
+  assert.equal(latexToUnicode('\\lim_{x \\to 0} \\cos x'), 'lim_(x → 0) cos x');
+  assert.equal(latexToUnicode('x_0 + x_{10}'), 'x₀ + x₁₀');
+  assert.match(readFileSync(new URL('../../web-chat/ui/scripts/client.js', import.meta.url), 'utf8'), /fallbackTypesetMath\(bubble\)/);
+});
+
+test('latexToUnicode fallback covers advanced math: matrices, accents, aliases', () => {
+  const src = readFileSync(new URL('../../web-chat/ui/scripts/client.js', import.meta.url), 'utf8');
+  const sandbox = src.slice(src.indexOf('const LATEX_SYMBOL_MAP ='), src.indexOf('window.latexToUnicode')) +
+    '\nreturn latexToUnicode;';
+  const latexToUnicode = new Function(sandbox)();
+  assert.equal(latexToUnicode('\\begin{matrix}a&b\\\\c&d\\end{matrix}'), 'a b c d');
+  assert.equal(latexToUnicode('\\binom{n}{k}'), '(n choose k)');
+  assert.equal(latexToUnicode('\\hat{\\theta}+\\vec{v}+\\bar{z}+\\dot{x}'), 'θ+v+z+x');
+  assert.equal(latexToUnicode('x\\le 0, y\\ge 1, a\\ne b'), 'x≤ 0, y≥ 1, a≠ b');
+  assert.equal(latexToUnicode('\\tag{1} x=1'), '(1) x=1');
+  assert.equal(latexToUnicode('\\sqrt{\\frac{1}{2}}'), '√((1)/(2))');
+  assert.equal(latexToUnicode('\\dfrac{a}{b}'), '(a)/(b)');
+  assert.equal(latexToUnicode('\\boxed{42} + \\cancel{x}'), '[42] + x');
+  assert.equal(latexToUnicode('\\text{อนันต์} + \\mathrm{d}x'), 'อนันต์ + dx');
+  assert.equal(latexToUnicode('x \\in \\mathbb{R}^n'), 'x ∈ ℝⁿ');
+  const noRaw = (s) => !/[\\][a-zA-Z]+/.test(s) && !/[{}]/.test(s);
+  for (const tex of [
+    '\\sum_{n=1}^{\\infty} n + \\prod_{i=1}^n i + \\int_0^1 x\\,dx',
+    '\\forall x \\exists y: x \\subset y \\cup z \\approx w',
+    '\\alpha\\beta\\gamma\\Delta\\Omega + \\clubsuit\\sharp\\flat',
+    '\\left( \\frac{a}{b} \\right) + \\big| x \\big| + A \\overset{!}{=} B',
+  ]) {
+    assert.ok(noRaw(latexToUnicode(tex)), 'raw latex left in: ' + latexToUnicode(tex));
+  }
+});
+
+test('math extractor shields bare display environments and auto-render knows them', () => {
+  const src = readFileSync(new URL('../../web-chat/ui/scripts/client.js', import.meta.url), 'utf8');
+  const loadFn = (name) => {
+    const start = src.indexOf('function ' + name + '(');
+    assert.ok(start >= 0, name + ' must exist');
+    const endMarker = name === 'extractMathSegments' ? 'function restoreMathSegments(' : 'const LATEX_SYMBOL_MAP =';
+    return new Function(src.slice(start, src.indexOf(endMarker)) + '; return ' + name + ';')();
+  };
+  const extractMathSegments = loadFn('extractMathSegments');
+  const restoreMathSegments = loadFn('restoreMathSegments');
+  const store = [];
+  const shielded = extractMathSegments('ผลคือ\n\\begin{align}x &= 1 \\\\ y &= 2\\end{align}\nจบ', store);
+  assert.equal(store.length, 1);
+  assert.equal(store[0].display, true);
+  assert.ok(shielded.includes('§§§MATH0§§§'));
+  const restored = restoreMathSegments(shielded, store);
+  assert.match(restored, /<div class="math-display">\\begin\{align\}/);
+  const html = getWebChatHtml();
+  for (const env of ['equation', 'align', 'gather', 'multline']) {
+    assert.ok(html.includes('\\\\begin{' + env + '}'), 'auto-render must know ' + env);
+  }
+});
+
 test('web chat HTML isolates answer text and renders expandable tool details', () => {
   const html = getWebChatHtml();
 
@@ -106,6 +270,8 @@ test('renderFollowUpSuggestions creates intelligent contextual follow-up topic c
   const html = getWebChatHtml();
   assert.match(html, /function renderFollowUpSuggestions\(botGroup, answerText, userQuery, serverSuggestions\)/);
   assert.match(html, /follow-up-suggestions/);
+  assert.match(html, /typesetMathInBubble\(chip\)/, 'renderFollowUpSuggestions must typeset math in chips');
+  assert.match(html, /detectSpecializedOpenDomainFollowUps/, 'client must have specialized open-domain follow-up detector');
   assert.match(html, /💎 บทบาท Versace/);
   assert.match(html, /👗 แบรนด์อื่นๆ ทั้งหมด/);
   assert.match(html, /🌸 ตัวตนกับรูปลักษณ์/);
@@ -230,11 +396,19 @@ test('user bubble renders dedicated renderUserContent with high contrast white t
   assert.match(html, /color:\s*#ffffff\s*!important/);
 });
 
+test('user bubble renders math formulas with typesetMathInBubble and dedicated KaTeX styles', () => {
+  const html = getWebChatHtml();
+  assert.match(html, /renderUserContent\(bubble,\s*text,\s*details\s*=\s*\{\}\)\s*\{[\s\S]*?typesetMathInBubble\(bubble\)/);
+  assert.match(html, /\.user-content-body\s*\.katex\s*,\s*\.bubble-user\s*\.katex/);
+  assert.match(html, /\.bubble-user\s*\.math-inline/);
+  assert.match(html, /\.bubble-user\s*\.math-display/);
+});
+
 test('clarifying questions and interactive question cards are stably pinned without stream flickering', () => {
   const html = getWebChatHtml();
   assert.match(html, /\.clarify-slot/);
   assert.match(html, /clarifySlot\.className = 'clarify-slot'/);
-  assert.match(html, /msgGroup\.insertBefore\(clarifySlot,\s*botBubble\)/);
+  assert.match(html, /msgGroup\.insertBefore\(clarifySlot,\s*botBubble(?:\.nextSibling)?\)/);
   assert.match(html, /dismissAgentInteractiveQuestion/);
   assert.match(html, /dismissedAgentQuestions/);
   assert.match(html, /!details\.isStreaming/);
@@ -253,7 +427,7 @@ test('subagent progress renders a dedicated live card with evidence report', ()
   assert.match(html, /subagent-report/);
   assert.match(html, /\.subagent-card\s*\{/);
   assert.match(html, /subagent-pulse/);
-  assert.match(html, /run_deep_research: '🔍/);
+  assert.match(html, /run_deep_research: '▸/);
 });
 
 test('error handling renders dedicated retry error card and interactive retry badge', () => {
@@ -298,3 +472,80 @@ test('input box enhancements: slash commands menu, model chip, relocated attachm
   assert.match(html, /updateSendButtonState/);
   assert.match(html, /drag-over/);
 });
+
+test('file upload system: attachments are validated, sent to /api/chat, and rendered with lightbox preview', () => {
+  const html = getWebChatHtml();
+  assert.match(html, /function safeRasterDataUrl\(/);
+  assert.match(html, /function addAttachmentFile\(/);
+  assert.match(html, /function renderAttachmentTray\(/);
+  assert.match(html, /function handleImageUpload\(/);
+  assert.match(html, /chat-attached-images-wrap/);
+  assert.match(html, /chat-attached-image/);
+  assert.match(html, /openImageLightbox/);
+  assert.match(html, /attachments:\s*attachmentsToSend/);
+  assert.match(html, /svg\+xml/);
+  assert.match(html, /avif/);
+});
+
+test('welcome hero gallery image picker and drag-and-drop system exist and are wired', () => {
+  const html = getWebChatHtml();
+  assert.match(html, /id="gallery-picker-modal"/);
+  assert.match(html, /id="gallery-picker-grid"/);
+  assert.match(html, /id="gallery-picker-search"/);
+  assert.match(html, /data-hero-slot="primary"/);
+  assert.match(html, /data-hero-slot="secondary"/);
+  assert.match(html, /data-hero-slot="poster"/);
+  assert.match(html, /function openHeroGalleryPicker\(/);
+  assert.match(html, /function closeHeroGalleryPicker\(/);
+  assert.match(html, /function filterGalleryPickerCategory\(/);
+  assert.match(html, /function handleGallerySearchInput\(/);
+  assert.match(html, /function applyHeroImage\(/);
+  assert.match(html, /function resetHeroImages\(/);
+  assert.match(html, /function scoreGalleryItem\(/);
+  assert.match(html, /function initWelcomeHeroGallery\(/);
+  assert.match(html, /kiku_hero_images/);
+  assert.match(html, /application\/x-kiku-hero-img/);
+  assert.match(html, /\.gallery-picker-dialog/);
+  assert.match(html, /\.gallery-picker-grid/);
+  assert.match(html, /\.hero-media-frame \.hero-slot-action/);
+});
+
+test('all gallery images exist on disk and staticRoute serves them without 404', async () => {
+  const { handleApiRequest } = await import('../../apiRouter.js');
+  const { handleStaticRoute } = await import('../../web-chat/routes/staticRoute.js');
+  const stream = await import('node:stream');
+
+  let body = '';
+  const req = {
+    method: 'GET',
+    url: '/api/v1/gallery?scope=all&limit=200',
+    headers: { host: 'localhost:3000' }
+  };
+  const res = {
+    writeHead: () => {},
+    end: (chunk) => { if (chunk) body += chunk; },
+    setHeader: () => {}
+  };
+  await handleApiRequest(req, res);
+  const json = JSON.parse(body);
+  assert.ok(Array.isArray(json.data) && json.data.length >= 70);
+
+  for (const item of json.data) {
+    const encodedUrl = encodeURI(item.image);
+    const mockReq = { url: encodedUrl };
+    let handledCode = 0;
+    const mockRes = new stream.Writable({
+      write(chunk, encoding, callback) { callback(); }
+    });
+    mockRes.writeHead = (code) => { handledCode = code; };
+    const u = new URL(mockReq.url, 'http://localhost:3002');
+    const handled = handleStaticRoute(mockReq, mockRes, u.pathname, 3002);
+    assert.strictEqual(handled, true, `Route must handle image ${item.image}`);
+    assert.strictEqual(handledCode, 200, `Image must return 200 OK for ${item.image}`);
+  }
+
+  const html = getWebChatHtml();
+  assert.match(html, /onerror="this\.onerror=null;const it=this\.closest/);
+});
+
+

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

@@ -0,0 +1,94 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import { handleWebChatRequest } from '../../web-chat/router.js';
+
+test('Web Chat MCP: GET /mcp returns protocol discovery JSON', async () => {
+  const server = http.createServer(async (req, res) => {
+    await handleWebChatRequest(req, res, { port: 3002 });
+  });
+
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/mcp`);
+    assert.equal(res.status, 200);
+    const data = await res.json();
+    assert.equal(data.protocol, 'mcp');
+    assert.equal(data.name, 'kiku');
+    assert.ok(data.capabilities?.toolsCount > 0);
+  } finally {
+    server.close();
+  }
+});
+
+test('Web Chat MCP: GET /api/mcp/status returns tools ecosystem and configs', async () => {
+  const server = http.createServer(async (req, res) => {
+    await handleWebChatRequest(req, res, { port: 3002 });
+  });
+
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/mcp/status`);
+    assert.equal(res.status, 200);
+    const data = await res.json();
+    assert.equal(data.status, 'ok');
+    assert.equal(data.mcpServer?.protocolVersion, '2025-11-25');
+    assert.ok(data.mcpServer?.supportedProtocolVersions?.includes('2024-11-05'));
+    assert.ok(data.mcpServer?.toolsCount >= 60);
+    assert.ok(data.totalTools >= 68);
+    assert.ok(data.categories?.ALL >= 68);
+    assert.ok(data.categories?.CATALOG > 0);
+    assert.ok(data.categories?.RESEARCH > 0);
+    assert.ok(Array.isArray(data.tools));
+    assert.ok(data.tools.length >= 68);
+    assert.ok(data.mcpServer?.clientConfigs?.claudeDesktop);
+    assert.ok(data.mcpServer?.clientConfigs?.cursor);
+    assert.ok(data.mcpServer?.clientConfigs?.windsurf);
+    assert.ok(data.mcpServer?.clientConfigs?.vscode);
+    assert.ok(data.mcpServer?.clientConfigs?.antigravity);
+    assert.ok(data.mcpServer?.clientConfigs?.cline);
+    assert.ok(data.mcpServer?.clientConfigs?.claudeCode);
+    assert.ok(data.mcpServer?.clientConfigs?.geminiCli);
+    assert.ok(data.mcpServer?.clientConfigs?.librechat);
+    assert.ok(data.mcpServer?.clientConfigs?.opencode);
+
+    
+    assert.ok(data.mcpServer.clientConfigs.antigravity.http?.mcpServers?.kiku?.url);
+    assert.ok(data.mcpServer.clientConfigs.antigravity.stdio?.mcpServers?.kiku?.command);
+    assert.ok(data.mcpServer.clientConfigs.vscode.http?.servers?.kiku?.url);
+    assert.ok(data.mcpServer.clientConfigs.librechat.httpYaml?.includes('streamable-http'));
+    assert.ok(data.mcpServer.clientConfigs.opencode.http?.$schema);
+
+    const profileTool = data.tools.find(t => t.name === 'get_profile_and_fandom');
+    assert.ok(profileTool);
+    assert.equal(profileTool.category, 'CATALOG');
+    assert.equal(profileTool.isMcpExposed, true);
+  } finally {
+    server.close();
+  }
+});
+
+test('Web Chat MCP: GET /api/status includes mcp server capability', async () => {
+  const server = http.createServer(async (req, res) => {
+    await handleWebChatRequest(req, res, { port: 3002 });
+  });
+
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/status?light=1`);
+    assert.equal(res.status, 200);
+    const data = await res.json();
+    assert.equal(data.status, 'ok');
+    assert.ok(data.mcp);
+    assert.equal(data.mcp.endpoint, '/mcp');
+    assert.equal(data.mcp.online, true);
+  } finally {
+    server.close();
+  }
+});

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

@@ -16,6 +16,7 @@ import {
   tokenizeForMatch,
   truncateByWords,
 } from '../websearch/extract.js';
+import { buildPageResult } from '../webSearch.js';
 
 const ARTICLE_FIXTURE = `<!DOCTYPE html>
 <html lang="th">
@@ -160,6 +161,28 @@ test('extractMainContent flags thin single-page-app shells', async () => {
   assert.ok(result.quality.htmlChars > 15_000);
 });
 
+test('buildPageResult reports login-walled/JS-shell pages as actionable errors, not hollow success', () => {
+  const empty = buildPageResult(
+    { markdown: '   ', meta: {}, engine: 'cheerio-readability', quality: { isThin: true, textChars: 0 } },
+    { finalUrl: 'https://weibo.com/u/3669102477', maxLength: 8000, query: '', cached: false }
+  );
+  assert.equal(empty.status, 'error');
+  assert.equal(empty.contentLength, 0);
+  assert.equal(empty.extraction.mode, 'no_content');
+  assert.match(empty.message, /m\.weibo\.cn/);
+  assert.match(empty.message, /search_chinese_web/);
+  assert.match(empty.message, /search_news/);
+  assert.match(empty.message, /Do NOT present this as the final answer/);
+  assert.ok(!('content' in empty) || empty.content === undefined, 'no dead-end sentence for the model to parrot');
+
+  const ok = buildPageResult(
+    { markdown: 'Hello world', meta: {}, engine: 'cheerio-readability', quality: { isThin: false } },
+    { finalUrl: 'https://example.com/a', maxLength: 8000, query: '', cached: false }
+  );
+  assert.equal(ok.status, 'success');
+  assert.equal(ok.content, 'Hello world');
+});
+
 test('splitIntoPassages bounds sections by headings and size', () => {
   const markdown = [
     '## Section one',

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

@@ -8,6 +8,10 @@ import {
   detectLanguage,
   checkUrlLiveness,
   decodeBaiduUrl,
+  buildImageSearchQuery,
+  titleMentionsArtist,
+  isLowValueImageUrl,
+  imageHostKey,
 } from '../webSearch.js';
 import { executeTool, prepareToolArguments, toolHandlers, toolsSchema } from '../tools.js';
 import { dynamicToolRouter as toolRouter } from '../toolRouter.js';
@@ -151,24 +155,27 @@ test('search_encyclopedia requires a term and rejects unknown languages', async
   assert.match(badLang.message || JSON.stringify(badLang), /language/i);
 });
 
-test('chinese web tools are gated behind KIKU_ENABLE_CN_WEB_TOOLS', async () => {
+test('chinese web tools are enabled by default and KIKU_ENABLE_CN_WEB_TOOLS=false gates them', async () => {
   const previous = process.env.KIKU_ENABLE_CN_WEB_TOOLS;
   try {
-    delete process.env.KIKU_ENABLE_CN_WEB_TOOLS;
-    for (const [handler, args] of [
-      [toolHandlers.search_chinese_web, { query: '鞠婧祎' }],
-      [toolHandlers.search_bilibili, { keyword: '鞠婧祎' }],
-      [toolHandlers.search_web_images, { query: '鞠婧祎' }],
-    ]) {
-      const gated = await handler(args);
-      assert.equal(gated.status, 'error');
-      assert.equal(gated.gated, true);
-      assert.match(gated.message, /KIKU_ENABLE_CN_WEB_TOOLS/);
+    for (const disableValue of ['false', '0']) {
+      process.env.KIKU_ENABLE_CN_WEB_TOOLS = disableValue;
+      for (const [handler, args] of [
+        [toolHandlers.search_chinese_web, { query: '鞠婧祎' }],
+        [toolHandlers.search_bilibili, { keyword: '鞠婧祎' }],
+        [toolHandlers.search_web_images, { query: '鞠婧祎' }],
+      ]) {
+        const gated = await handler(args);
+        assert.equal(gated.status, 'error');
+        assert.equal(gated.gated, true);
+        assert.match(gated.message, /KIKU_ENABLE_CN_WEB_TOOLS/);
+      }
     }
 
-    process.env.KIKU_ENABLE_CN_WEB_TOOLS = 'true';
+    delete process.env.KIKU_ENABLE_CN_WEB_TOOLS;
     const missingQuery = await toolHandlers.search_chinese_web({});
     assert.equal(missingQuery.status, 'error');
+    assert.equal(missingQuery.gated, undefined);
     assert.match(missingQuery.message, /query parameter is required/);
     const missingKeyword = await toolHandlers.search_bilibili({});
     assert.equal(missingKeyword.status, 'error');
@@ -245,3 +252,30 @@ test('decodeBaiduUrl decodes Baidu encrypted objURL and fromURL into valid http
 });
 
 
+
+test('buildImageSearchQuery always targets the artist for image searches', () => {
+  assert.match(buildImageSearchQuery('งานแฟนมีตล่าสุด'), /鞠婧祎/);
+  assert.match(buildImageSearchQuery('Ju Jingyi red carpet'), /鞠婧祎/);
+  const direct = buildImageSearchQuery('鞠婧祎 代言');
+  assert.match(direct, /鞠婧祎 代言/);
+});
+
+test('titleMentionsArtist separates artist results from keyword collisions', () => {
+  assert.equal(titleMentionsArtist('觅橘品牌代言人鞠婧祎'), true);
+  assert.equal(titleMentionsArtist('จวีจิ้งอี งานแฟนมีต'), true);
+  assert.equal(titleMentionsArtist('Ju Jingyi vogue gala red carpet'), true);
+  assert.equal(titleMentionsArtist('romand# red carpet 这支是什么神仙草莓色？'), false);
+  assert.equal(titleMentionsArtist('สุดหวานงานแฟนมีต “คิมม่อน”'), false);
+  assert.equal(titleMentionsArtist(''), false);
+});
+
+test('isLowValueImageUrl and imageHostKey guard junk sources', () => {
+  assert.equal(isLowValueImageUrl('data:image/png;base64,AAA'), true);
+  assert.equal(isLowValueImageUrl('https://cdn.example.com/icon.svg'), true);
+  assert.equal(isLowValueImageUrl('https://cdn.example.com/static/logo.png'), true);
+  assert.equal(isLowValueImageUrl('https://img0.baidu.com/it/u=1,2;3?fm=253'), false);
+  assert.equal(isLowValueImageUrl(''), true);
+
+  assert.equal(imageHostKey('https://img0.baidu.com/it/u=1?x=1'), 'img0.baidu.com/it/u=1');
+  assert.equal(imageHostKey('not a url'), 'not a url');
+});