kiku-agent 1.3.1 → 1.3.3

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

@@ -0,0 +1,281 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  parseRssFeed,
+  parseBaikePage,
+  parseBaiduResults,
+  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';
+import { extractCitations } from '../citations.js';
+import { PUBLIC_REMOTE_TOOL_NAMES } from '../publicTools.js';
+import { getMcpToolNames } from '../../mcp/tools.js';
+
+const NEW_WEB_TOOLS = [
+  'search_news',
+  'fetch_rss',
+  'search_encyclopedia',
+  'search_music_platforms',
+  'search_chinese_web',
+  'search_bilibili',
+  'search_web_images',
+];
+
+test('new web source tools are registered in the schema, router cluster, and public surfaces', () => {
+  const schemaNames = new Set(toolsSchema.map(t => t.function?.name));
+  for (const name of NEW_WEB_TOOLS) {
+    assert.ok(schemaNames.has(name), `toolsSchema should contain ${name}`);
+    assert.ok(toolRouter.toolsByName.has(name), `router should know ${name}`);
+    assert.ok(PUBLIC_REMOTE_TOOL_NAMES.has(name), `web-chat public tools should include ${name}`);
+    assert.ok(typeof toolHandlers[name] === 'function', `toolHandlers should contain ${name}`);
+  }
+  const mcpNames = new Set(getMcpToolNames());
+  for (const name of ['search_news', 'fetch_rss', 'search_encyclopedia', 'search_music_platforms']) {
+    assert.ok(mcpNames.has(name), `MCP should expose ${name} publicly`);
+  }
+});
+
+test('parseRssFeed handles RSS 2.0 items with CDATA and source tags', () => {
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
+  <rss version="2.0"><channel><title>Feed Title</title>
+    <item>
+      <title><![CDATA[鞠婧祎新剧开播]]></title>
+      <link>https://news.example.com/a</link>
+      <pubDate>Mon, 01 Sep 2026 08:00:00 GMT</pubDate>
+      <description><![CDATA[<p>โพยละครเรื่องใหม่</p>]]></description>
+      <source url="https://ent.example.com">Example Ent</source>
+    </item>
+    <item>
+      <title>Second story</title>
+      <link>https://news.example.com/b</link>
+      <pubDate>Tue, 02 Sep 2026 09:00:00 GMT</pubDate>
+      <description>Plain snippet</description>
+    </item>
+  </channel></rss>`;
+
+  const items = parseRssFeed(xml);
+  assert.equal(items.length, 2);
+  assert.equal(items[0].title, '鞠婧祎新剧开播');
+  assert.equal(items[0].url, 'https://news.example.com/a');
+  assert.equal(items[0].source, 'Example Ent');
+  assert.match(items[0].snippet, /โพยละครเรื่องใหม่/);
+  assert.match(items[0].publishedAt, /Sep 2026/);
+  assert.equal(items[1].source, '');
+});
+
+test('parseRssFeed handles Atom entries with self-closing link tags', () => {
+  const xml = `<?xml version="1.0"?>
+  <feed xmlns="http://www.w3.org/2005/Atom">
+    <title>Atom Feed</title>
+    <entry>
+      <title>  Kiku releases new single </title>
+      <link rel="alternate" href="https://blog.example.com/entry-1"/>
+      <published>2026-08-30T10:00:00Z</published>
+      <summary>Short summary text</summary>
+    </entry>
+  </feed>`;
+
+  const items = parseRssFeed(xml);
+  assert.equal(items.length, 1);
+  assert.equal(items[0].title, 'Kiku releases new single');
+  assert.equal(items[0].url, 'https://blog.example.com/entry-1');
+  assert.equal(items[0].publishedAt, '2026-08-30T10:00:00Z');
+  assert.equal(items[0].snippet, 'Short summary text');
+});
+
+test('parseBaikePage extracts title, summary and paragraphs from a Baike-style page', () => {
+  const html = `<!DOCTYPE html><html><head>
+    <meta name="description" content="鞠婧祎，1994年6月18日出生于四川省遂宁市，中国内地影视女演员、流行乐歌手。">
+    </head><body>
+    <h1>鞠婧祎</h1>
+    <div class="lemma-summary"><div class="para">鞠婧祎1994年6月18日出生于四川省遂宁市。</div>
+    <div class="para">2013年以SNH48成员身份正式出道。</div></div>
+    <p>short</p>
+  </body></html>`;
+
+  const parsed = parseBaikePage(html);
+  assert.equal(parsed.title, '鞠婧祎');
+  assert.match(parsed.summary, /1994年6月18日出生于四川省遂宁市/);
+  assert.ok(parsed.paragraphs.length >= 2);
+  assert.ok(parsed.paragraphs.every(p => p.length > 10));
+});
+
+test('parseBaiduResults extracts title, redirect link and snippet', () => {
+  const html = `<!DOCTYPE html><html><body>
+    <div class="result c-container" srcid="1599">
+      <h3 class="c-title t t tts-title"><a href="http://www.baidu.com/link?url=abc123">鞠婧祎 最新消息 - 新浪娱乐</a></h3>
+      <span class="content-right_8Zs40">新浪娱乐讯 9月1日，鞠婧祎工作室发布最新声明。</span>
+    </div>
+    <div class="result c-container">
+      <h3 class="c-title"><a href="http://www.baidu.com/link?url=def456">第二條結果</a></h3>
+      <span class="content-right_8Zs40">另一段摘要文字，內容超過三十個字符以方便驗證截取邏輯是否正確。</span>
+    </div>
+  </body></html>`;
+
+  const results = parseBaiduResults(html, 8);
+  assert.equal(results.length, 2);
+  assert.equal(results[0].title, '鞠婧祎 最新消息 - 新浪娱乐');
+  assert.equal(results[0].url, 'http://www.baidu.com/link?url=abc123');
+  assert.match(results[0].snippet, /最新声明/);
+  assert.equal(results[0].source, 'Baidu');
+});
+
+test('detectLanguage routes Thai, Chinese, and English terms', () => {
+  assert.equal(detectLanguage('จวีจิ้งอี ล่าสุด'), 'th');
+  assert.equal(detectLanguage('鞠婧祎 最新'), 'zh');
+  assert.equal(detectLanguage('Ju Jingyi latest news'), 'en');
+});
+
+test('search_news requires a query', async () => {
+  const result = await toolHandlers.search_news({});
+  assert.equal(result.status, 'error');
+  assert.match(result.message, /query parameter is required/);
+});
+
+test('fetch_rss requires a valid URL', async () => {
+  const result = await toolHandlers.fetch_rss({ url: 'not-a-url' });
+  assert.equal(result.status, 'error');
+  assert.match(result.message, /HTTP|URL is required|Invalid URL/);
+});
+
+test('search_encyclopedia requires a term and rejects unknown languages', async () => {
+  const missing = await toolHandlers.search_encyclopedia({});
+  assert.equal(missing.status, 'error');
+
+  const badLang = await executeTool('search_encyclopedia', { term: '鞠婧祎', language: 'fr' });
+  assert.equal(badLang.status, 'error');
+  assert.match(badLang.message || JSON.stringify(badLang), /language/i);
+});
+
+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 {
+    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/);
+      }
+    }
+
+    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');
+    assert.match(missingKeyword.message, /keyword parameter is required/);
+    const missingImageQuery = await toolHandlers.search_web_images({});
+    assert.equal(missingImageQuery.status, 'error');
+    assert.match(missingImageQuery.message, /query parameter is required/);
+  } finally {
+    if (previous === undefined) delete process.env.KIKU_ENABLE_CN_WEB_TOOLS;
+    else process.env.KIKU_ENABLE_CN_WEB_TOOLS = previous;
+  }
+});
+
+test('executeTool validates the new tools through the standard pipeline', async () => {
+  const noArgs = await executeTool('search_music_platforms', {});
+  assert.equal(noArgs.status, 'error');
+
+  const prepared = prepareToolArguments('search_news', { query: 'Ju Jingyi', bogus: 1 });
+  assert.equal(prepared.safe, true);
+  assert.deepEqual(prepared.args, { query: 'Ju Jingyi' });
+  assert.match(prepared.warnings.join(' '), /Unknown argument "bogus"/);
+});
+
+test('router exposes news and encyclopedia tools on research-flavored queries', () => {
+  const routedTh = toolRouter.routeToolsForQuery('จวีจิ้งอีมีข่าวอะไรล่าสุดบ้าง');
+  const routedZh = toolRouter.routeToolsForQuery('鞠婧祎 最新新闻动态');
+  for (const routed of [routedTh, routedZh]) {
+    const names = new Set(routed.map(t => t.function?.name));
+    assert.ok(names.has('search_news'), 'search_news should be routed for news queries');
+    assert.ok(names.has('search_encyclopedia'), 'search_encyclopedia should be routed for research queries');
+  }
+});
+
+test('router exposes bilibili and music platform tools on media-flavored queries', () => {
+  const routed = toolRouter.routeToolsForQuery('ฟังเพลงล่าสุดของจวีจิ้งอี และดูคลิป bilibili');
+  const names = new Set(routed.map(t => t.function?.name));
+  assert.ok(names.has('search_bilibili'));
+  assert.ok(names.has('search_music_platforms'));
+});
+
+test('extractCitations works with recorded tool results (recordedTools regression)', () => {
+  const citations = extractCitations(
+    'Ju Jingyi news says a new drama is coming: https://example.com/a',
+    [{ name: 'web_search', result: { results: [{ title: 'Ju Jingyi new drama', url: 'https://example.com/a' }] } }]
+  );
+  assert.equal(citations.length, 1);
+  assert.equal(citations[0].id, 1);
+  assert.equal(citations[0].type, 'web');
+  assert.equal(citations[0].url, 'https://example.com/a');
+});
+
+test('checkUrlLiveness validates safe URLs and catches dead or invalid links', async () => {
+  const invalid = await checkUrlLiveness('not-a-url');
+  assert.equal(invalid.alive, false);
+
+  const empty = await checkUrlLiveness('');
+  assert.equal(empty.alive, false);
+
+  const doc = await checkUrlLiveness('https://example.com/some/article');
+  assert.equal(doc.alive, true);
+
+  const dead = await checkUrlLiveness('https://this-domain-definitely-does-not-exist-at-all-999.xyz/page', { timeoutMs: 500 });
+  assert.equal(dead.alive, false);
+});
+
+test('decodeBaiduUrl decodes Baidu encrypted objURL and fromURL into valid http urls', () => {
+  const encrypted = 'ippr_z2C$qAzdH3FAzdH3Fooo_z&e3Bktstktst_z&e3Bv54AzdH3Fet1j5AzdH3FBV8vv0zm5Ep6';
+  const decoded = decodeBaiduUrl(encrypted);
+  assert.equal(decoded, 'http://www.bilibili.com/video/BV1cc7z6oEtr');
+
+  assert.equal(decodeBaiduUrl('https://example.com/pic.jpg'), 'https://example.com/pic.jpg');
+  assert.equal(decodeBaiduUrl(''), '');
+  assert.equal(decodeBaiduUrl(null), '');
+});
+
+
+
+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');
+});

package/server/agent/textToolProtocol.js

@@ -80,8 +80,69 @@ export function sanitizeToolArguments(toolName, rawArgs = {}, toolsSchema = [])
   return cleanArgs;
 }
 
+export const TOOL_NAME_ALIASES = Object.freeze({
+  websearch: 'web_search',
+  searchweb: 'web_search',
+  search_web: 'web_search',
+  google_search: 'web_search',
+  bing_search: 'web_search',
+  webimages: 'search_web_images',
+  web_images: 'search_web_images',
+  search_images: 'search_web_images',
+  search_image: 'search_web_images',
+  image_search: 'search_web_images',
+  works: 'search_works',
+  search_works: 'search_works',
+  dramas: 'search_works',
+  get_works: 'search_works',
+  songs: 'search_discography',
+  discography: 'search_discography',
+  search_discography: 'search_discography',
+  brands: 'get_brand_endorsements',
+  get_brand_endorsements: 'get_brand_endorsements',
+  news: 'search_news',
+  search_news: 'search_news',
+  timeline: 'get_career_timeline',
+  get_timeline: 'get_career_timeline',
+  awards: 'get_awards',
+  get_awards: 'get_awards',
+  profile: 'get_artist_profile',
+  get_profile: 'get_artist_profile',
+  gallery: 'get_gallery_photos',
+  get_photos: 'get_gallery_photos',
+  photos: 'get_gallery_photos',
+});
+
+export function resolveCanonicalToolName(rawName) {
+  if (!rawName) return null;
+  const cleaned = String(rawName).trim().replace(/^call:/i, '').toLowerCase();
+  return TOOL_NAME_ALIASES[cleaned] || String(rawName).trim().replace(/^call:/i, '');
+}
+
+export function parseCustomToolArgs(rawArgs) {
+  if (!rawArgs) return {};
+  let clean = String(rawArgs).replace(/<\|["']\|>/g, '"').trim();
+  if (clean.startsWith('{') && clean.endsWith('}')) {
+    try {
+      const parsed = JSON.parse(clean);
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed;
+    } catch {}
+  }
+
+  const args = {};
+  const kvRegex = /([a-zA-Z0-9_]+)\s*:\s*(?:"([^"]*)"|'([^']*)'|([^,}\s]+))/g;
+  for (const m of clean.matchAll(kvRegex)) {
+    let key = m[1].trim();
+    if (key === 'targetlanguage') key = 'target_language';
+    if (key === 'domainfilter') key = 'domain_filter';
+    const val = m[2] !== undefined ? m[2] : (m[3] !== undefined ? m[3] : m[4]);
+    args[key] = val;
+  }
+  return args;
+}
+
 /**
- * Parse text-emitted tool calls (fenced JSON or ReAct "Action:" blocks).
+ * Parse text-emitted tool calls (fenced JSON, ReAct "Action:" blocks, or [TOOLCALL] tags).
  * Returns { calls, malformed } — malformed counts blocks that LOOK like tool
  * calls but could not be parsed, so the caller can feed that back to the model
  * instead of silently treating the message as the final answer.
@@ -92,63 +153,124 @@ export function parseTextToolCallsFromContent(content, toolsSchema) {
   const allTools = toolsSchema || [];
   const isValidTool = (name) => allTools.some(t => t.function?.name === name);
 
-  const pushCall = (prefix, toolName, args) => {
-    const cleanArgs = sanitizeToolArguments(toolName, args, allTools);
+  const pushCall = (prefix, rawToolName, args) => {
+    const canonicalName = resolveCanonicalToolName(rawToolName);
+    if (!canonicalName || !isValidTool(canonicalName)) return false;
+    const cleanArgs = sanitizeToolArguments(canonicalName, args, allTools);
     result.calls.push({
       id: `${prefix}_${Date.now()}_${result.calls.length}`,
-      function: { name: toolName, arguments: JSON.stringify(cleanArgs) }
+      function: { name: canonicalName, arguments: JSON.stringify(cleanArgs) }
     });
+    return true;
   };
 
-  const fenceRegex = /```(?:json)?\s*([\s\S]*?)```/g;
-  for (const match of content.matchAll(fenceRegex)) {
-    const body = match[1];
-    if (!body.includes('{')) continue;
-    const { objects, unbalanced } = extractTopLevelJsonObjects(body);
-    if (unbalanced) result.malformed++;
-    for (const obj of objects) {
-      let parsed = null;
+  // 1. [TOOLCALL] or <tool_call> with toolName{...}
+  const inlineToolCallRegex = /(?:\[TOOLCALL\]|<tool_call>|<toolcall>|<\|tool_call\|>)\s*(?:call:)?([a-zA-Z0-9_]+)\s*\{([\s\S]*?)\}\s*(?:<toolcall\|?>|<\/tool_call>|<\/toolcall>|\[\/TOOLCALL\]|$)/gi;
+  for (const match of content.matchAll(inlineToolCallRegex)) {
+    const toolName = match[1];
+    const args = parseCustomToolArgs(match[2]);
+    pushCall('call_tc', toolName, args);
+  }
+
+  // 2. <tool_call> or [TOOLCALL] containing JSON object
+  if (result.calls.length === 0) {
+    const tagJsonRegex = /(?:<tool_call>|\[TOOLCALL\]|<\|tool_call\|>)\s*(\{[\s\S]*?\})\s*(?:<\/tool_call>|<toolcall\|?>|\[\/TOOLCALL\]|$)/gi;
+    for (const match of content.matchAll(tagJsonRegex)) {
       try {
-        parsed = JSON.parse(obj.raw);
-      } catch {
-        parsed = null;
-      }
-      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        result.malformed++;
-        continue;
-      }
-      const toolName = parsed.action || parsed.tool || parsed.name || parsed.function;
-      if (!toolName) continue;
-      let toolArgs = parsed.action_input ?? parsed.parameters ?? parsed.arguments ?? parsed.args ?? {};
-      if (toolArgs && typeof toolArgs === 'string') {
-        try { toolArgs = JSON.parse(toolArgs); } catch { toolArgs = { query: toolArgs }; }
-      }
-      if (!toolArgs || typeof toolArgs !== 'object' || Array.isArray(toolArgs)) toolArgs = {};
-      if (isValidTool(String(toolName))) {
+        const obj = JSON.parse(match[1].replace(/<\|["']\|>/g, '"'));
+        const toolName = obj.name || obj.action || obj.tool || obj.function;
+        let args = obj.arguments || obj.parameters || obj.action_input || obj.args || {};
+        if (typeof args === 'string') {
+          try { args = JSON.parse(args); } catch {}
+        }
+        if (toolName) pushCall('call_tag_json', toolName, args);
+      } catch {}
+    }
+  }
+
+  // 3. [TOOL_CALLS] array format
+  if (result.calls.length === 0) {
+    const arrayRegex = /\[TOOL_CALLS\]\s*(\[[\s\S]*?\])/gi;
+    for (const match of content.matchAll(arrayRegex)) {
+      try {
+        const arr = JSON.parse(match[1].replace(/<\|["']\|>/g, '"'));
+        if (Array.isArray(arr)) {
+          for (const item of arr) {
+            const toolName = item.name || item.function?.name || item.action;
+            let args = item.arguments || item.parameters || item.function?.arguments || {};
+            if (typeof args === 'string') {
+              try { args = JSON.parse(args); } catch {}
+            }
+            if (toolName) pushCall('call_arr', toolName, args);
+          }
+        }
+      } catch {}
+    }
+  }
+
+  // 4. Standalone tool_name{...}<toolcall|>
+  if (result.calls.length === 0) {
+    const standaloneRegex = /(?:^|\n)(?:call:)?([a-zA-Z0-9_]+)\s*\{([\s\S]*?)\}\s*<toolcall\|?>/gi;
+    for (const match of content.matchAll(standaloneRegex)) {
+      const toolName = match[1];
+      const args = parseCustomToolArgs(match[2]);
+      pushCall('call_standalone', toolName, args);
+    }
+  }
+
+  // 5. Fenced JSON: ```json ... ```
+  if (result.calls.length === 0) {
+    const fenceRegex = /```(?:json)?\s*([\s\S]*?)```/g;
+    for (const match of content.matchAll(fenceRegex)) {
+      const body = match[1];
+      if (!body.includes('{')) continue;
+      const { objects, unbalanced } = extractTopLevelJsonObjects(body);
+      if (unbalanced) result.malformed++;
+      for (const obj of objects) {
+        let parsed = null;
+        try {
+          parsed = JSON.parse(obj.raw);
+        } catch {
+          parsed = null;
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+          result.malformed++;
+          continue;
+        }
+        const toolName = parsed.action || parsed.tool || parsed.name || parsed.function;
+        if (!toolName) continue;
+        let toolArgs = parsed.action_input ?? parsed.parameters ?? parsed.arguments ?? parsed.args ?? {};
+        if (toolArgs && typeof toolArgs === 'string') {
+          try { toolArgs = JSON.parse(toolArgs); } catch { toolArgs = { query: toolArgs }; }
+        }
+        if (!toolArgs || typeof toolArgs !== 'object' || Array.isArray(toolArgs)) toolArgs = {};
         pushCall('call_txt', String(toolName), toolArgs);
       }
     }
   }
 
-  const actionRegex = /Action:\s*([a-zA-Z0-9_]+)\s*\nAction Input:\s*([\s\S]*?)(?=\nAction:|\nObservation:|$)/g;
-  for (const match of content.matchAll(actionRegex)) {
-    const toolName = match[1].trim();
-    const rawInput = match[2].trim();
-    if (!isValidTool(toolName)) continue;
-    if (rawInput.startsWith('{')) {
-      const { objects, unbalanced } = extractTopLevelJsonObjects(rawInput);
-      const candidate = objects.length > 0 ? objects[0].raw : unbalanced;
-      let parsed = null;
-      if (candidate) {
-        try { parsed = JSON.parse(candidate); } catch { parsed = null; }
-      }
-      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        result.malformed++;
-        continue;
+  // 6. Action: ... \n Action Input: ...
+  if (result.calls.length === 0) {
+    const actionRegex = /Action:\s*([a-zA-Z0-9_]+)\s*\nAction Input:\s*([\s\S]*?)(?=\nAction:|\nObservation:|$)/g;
+    for (const match of content.matchAll(actionRegex)) {
+      const toolName = match[1].trim();
+      const rawInput = match[2].trim();
+      if (!isValidTool(resolveCanonicalToolName(toolName))) continue;
+      if (rawInput.startsWith('{')) {
+        const { objects, unbalanced } = extractTopLevelJsonObjects(rawInput);
+        const candidate = objects.length > 0 ? objects[0].raw : unbalanced;
+        let parsed = null;
+        if (candidate) {
+          try { parsed = JSON.parse(candidate); } catch { parsed = null; }
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+          result.malformed++;
+          continue;
+        }
+        pushCall('call_act', toolName, parsed);
+      } else {
+        pushCall('call_act', toolName, { query: rawInput });
       }
-      pushCall('call_act', toolName, parsed);
-    } else {
-      pushCall('call_act', toolName, { query: rawInput });
     }
   }
 
@@ -186,5 +308,10 @@ export function stripToolCallBlocks(content) {
   let cleaned = String(content || '');
   cleaned = cleaned.replace(/```(?:json)?\s*[\s\S]*?```/g, '');
   cleaned = cleaned.replace(/Action:\s*[a-zA-Z0-9_]+\s*\nAction Input:[\s\S]*?(?=\nAction:|\nObservation:|$)/g, '');
+  cleaned = cleaned.replace(/(?:\[TOOLCALL\]|<tool_call>|<toolcall>|<\|tool_call\|>)\s*(?:call:)?[a-zA-Z0-9_]+\s*\{[\s\S]*?\}\s*(?:<toolcall\|?>|<\/tool_call>|<\/toolcall>|\[\/TOOLCALL\]|$)/gi, '');
+  cleaned = cleaned.replace(/(?:<tool_call>|\[TOOLCALL\]|<\|tool_call\|>)\s*\{[\s\S]*?\}\s*(?:<\/tool_call>|<toolcall\|?>|\[\/TOOLCALL\]|$)/gi, '');
+  cleaned = cleaned.replace(/\[TOOL_CALLS\]\s*\[[\s\S]*?\]/gi, '');
+  cleaned = cleaned.replace(/(?:^|\n)(?:call:)?[a-zA-Z0-9_]+\s*\{[\s\S]*?\}\s*<toolcall\|?>/gi, '');
+  cleaned = cleaned.replace(/<\|?toolcall\|?>|<\/?tool_call>|<\/?toolcall>|\[\/?TOOLCALL\]|\[TOOL_CALLS\]|<\|["']\|>/gi, '');
   return cleaned.trim();
 }