kiku-agent 1.3.2 → 1.3.4

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();
 }