fix: filter undefined historical tools

Author: caigee-cmd

worker/src/plaintext.mjs

@@ -210,40 +210,46 @@ function normalizeTools(tools) {
     .filter((t) => t && t.function?.name);
 }
 
-function historicalToolNames(messages) {
-  const names = new Set();
+export function filterUnknownToolHistory(messages = [], tools = []) {
+  const normalizedTools = normalizeTools(tools);
+  const definedNames = new Set(normalizedTools.map((tool) => tool.function.name));
+  const droppedToolCallIds = new Set();
+  const droppedToolNames = new Set();
+  const filtered = [];
+
   for (const message of Array.isArray(messages) ? messages : []) {
-    if (message?.role !== "assistant" || !Array.isArray(message.tool_calls)) continue;
-    for (const toolCall of message.tool_calls) {
-      const fn = toolCall?.function && typeof toolCall.function === "object" ? toolCall.function : {};
-      const name = String(fn.name || toolCall?.name || "").trim();
-      if (name) names.add(name);
+    if (message?.role === "assistant" && Array.isArray(message.tool_calls)) {
+      const retainedCalls = [];
+      for (const toolCall of message.tool_calls) {
+        const fn = toolCall?.function && typeof toolCall.function === "object" ? toolCall.function : {};
+        const name = String(fn.name || toolCall?.name || "").trim();
+        if (name && definedNames.has(name)) {
+          retainedCalls.push(toolCall);
+          continue;
+        }
+        if (typeof toolCall?.id === "string" && toolCall.id.trim()) {
+          droppedToolCallIds.add(toolCall.id.trim());
+        }
+        if (name) droppedToolNames.add(name);
+      }
+      if (!retainedCalls.length) {
+        if (contentToString(message.content)) filtered.push({ ...message, tool_calls: undefined });
+        continue;
+      }
+      filtered.push({ ...message, tool_calls: retainedCalls });
+      continue;
+    }
+    if (message?.role === "tool" && typeof message.tool_call_id === "string" && droppedToolCallIds.has(message.tool_call_id.trim())) {
+      continue;
     }
+    filtered.push(message);
   }
-  return names;
-}
 
-export function addHistoricalToolDefinitions(tools = [], messages = []) {
-  const normalized = normalizeTools(tools);
-  const defined = new Set(normalized.map((tool) => tool.function.name));
-  const added = [];
-  for (const name of historicalToolNames(messages)) {
-    if (defined.has(name)) continue;
-    normalized.push({
-      type: "function",
-      function: {
-        name,
-        description: "Compatibility definition for a tool call preserved in conversation history.",
-        parameters: {
-          type: "object",
-          additionalProperties: true,
-        },
-      },
-    });
-    defined.add(name);
-    added.push(name);
-  }
-  return { tools: normalized, added };
+  return {
+    messages: filtered,
+    droppedToolCallIds: [...droppedToolCallIds],
+    droppedToolNames: [...droppedToolNames],
+  };
 }
 
 function normalizeToolCall(toolCall, messageIndex, callIndex, usedIds, sourceIds) {
@@ -442,8 +448,8 @@ export function buildPlainChatBody({
   const sessionId = crypto.randomUUID();
   const mapped = mapModel(model);
 
-  const openaiMessages = normalizeMessagesForUpstream(messages || []);
-  const compatibleTools = addHistoricalToolDefinitions(tools, messages || []);
+  const filteredHistory = filterUnknownToolHistory(messages || [], tools);
+  const openaiMessages = normalizeMessagesForUpstream(filteredHistory.messages);
 
   // Chat-API mode:
   // - Do NOT inherit capture-template Qoder agent system/tools (they explode multiturn).
@@ -535,7 +541,7 @@ export function buildPlainChatBody({
       ? [...systemMessages, ...(nonSystem.length ? nonSystem : [{ role: "user", content: "ping" }])]
       : [{ role: "user", content: "ping" }],
     // Pass through caller tools (OpenAI function tools). Do NOT inherit capture-template tools.
-    tools: compatibleTools.tools,
+    tools: normalizeTools(tools),
     parameters,
     business: {
       product: "cli",

worker/test/plaintext.test.mjs

@@ -8,7 +8,7 @@ import {
   estimateTokens,
   normalizeMessagesForUpstream,
   diagnoseOpenAIToolHistory,
-  addHistoricalToolDefinitions,
+  filterUnknownToolHistory,
 } from "../src/plaintext.mjs";
 
 test("maps known display names to upstream keys", () => {
@@ -125,20 +125,24 @@ test("normalizes OpenAI tool history and repairs missing tool ids", () => {
   assert.equal("name" in messages[3], false);
 });
 
-test("adds compatibility definitions for tools preserved in history", () => {
-  const result = addHistoricalToolDefinitions(
-    [{ type: "function", function: { name: "Read", parameters: {} } }],
-    [{
-      role: "assistant",
-      tool_calls: [
+test("filters unknown historical tool calls and matching results", () => {
+  const result = filterUnknownToolHistory(
+    [
+      { role: "assistant", content: null, tool_calls: [
         { id: "call_task", function: { name: "TaskCreate", arguments: "{}" } },
         { id: "call_read", function: { name: "Read", arguments: "{}" } },
-      ],
-    }],
+      ] },
+      { role: "tool", tool_call_id: "call_task", content: "task result" },
+      { role: "tool", tool_call_id: "call_read", content: "read result" },
+    ],
+    [{ type: "function", function: { name: "Read", parameters: {} } }],
   );
-  assert.deepEqual(result.added, ["TaskCreate"]);
-  assert.deepEqual(result.tools.map((tool) => tool.function.name), ["Read", "TaskCreate"]);
-  assert.equal(result.tools[1].function.parameters.additionalProperties, true);
+  assert.deepEqual(result.droppedToolCallIds, ["call_task"]);
+  assert.deepEqual(result.droppedToolNames, ["TaskCreate"]);
+  assert.equal(result.messages.length, 2);
+  assert.equal(result.messages[0].tool_calls.length, 1);
+  assert.equal(result.messages[0].tool_calls[0].function.name, "Read");
+  assert.equal(result.messages[1].tool_call_id, "call_read");
 });
 
 test("keeps distinct existing tool ids across multiple assistant turns", () => {