fix(ai): Don't create duplicate tool parts when models call non-existent tools (#12774)

josh-williams · web-flow · commit 523048227963 · 2026-02-25T17:16:13.000-08:00
## Background When a model calls a tool that doesn't exist in the tools object (e.g. a hallucinated tool name), processUIMessageStream creates two message parts for the same toolCallId — one static (tool-{toolName}) and one dynamic (dynamic-tool). This causes downstream failures when the conversation is continued, since the model API rejects requests containing two tool results for the same tool call ID. ## Summary Fixes a bug in `processUIMessageStream` where a model calling a non-existent tool produces two UI message parts for the same `toolCallId` — one static (`tool-{toolName}`) and one dynamic (`dynamic-tool`). This happens because `tool-input-start` creates a static part (when `dynamic` is undefined for an unknown tool), but the subsequent `tool-input-error` arrives with `dynamic: true` and only searches for a `dynamic-tool` part, missing the existing static one and creating a duplicate. The fix checks for an existing part by `toolCallId` before branching on `chunk.dynamic`, so the error updates the existing part in place instead of creating a second one. ## Manual Verification Manually verified against my own application. After the fix, I got a single tool part like: ``` { "type": "tool-dashboard-page-create-dashboard", "state": "output-error", "rawInput": { "name": "Staging Monitoring" }, "errorText": "Model tried to call unavailable tool 'dashboard-page-create-dashboard'. Available tools: ....", "toolCallId": "toolu_015E6Kd6cwSMkw7SFpsa7w88", "callProviderMetadata": { "anthropic": { "caller": { "type": "direct" } } } }, ``` ## Checklist - [x] Tests have been added / updated (for bug fixes / features) - [ ] Documentation has been added / updated (for bug fixes / features) - [x] A _patch_ changeset for relevant packages has been added (for bug fixes / features - run `pnpm changeset` in the project root) - [x] I have reviewed this pull request (self-review) ## Related Issues Fixes #12772
diff --git a/.changeset/quiet-tables-relate.md b/.changeset/quiet-tables-relate.md
@@ -0,0 +1,5 @@
+---
+'ai': patch
+---
+
+fix(ai): Don't create duplicate tool parts when models call non-existent tools
diff --git a/packages/ai/src/ui/process-ui-message-stream.test.ts b/packages/ai/src/ui/process-ui-message-stream.test.ts
@@ -6433,6 +6433,108 @@ describe('processUIMessageStream', () => {
     });
   });
 
+  describe('tool input error with dynamic flag mismatch', () => {
+    // Regression: when tool-input-start creates a static part (dynamic is
+    // undefined because the tool isn't in the tools object) and tool-input-error
+    // arrives with dynamic: true (from parseToolCall's catch for NoSuchToolError),
+    // the error should update the existing static part instead of creating a
+    // second dynamic-tool part.
+    beforeEach(async () => {
+      const stream = createUIMessageStream([
+        {
+          type: 'start',
+        },
+        {
+          type: 'start-step',
+        },
+        {
+          toolCallId: 'call-1',
+          toolName: 'nonExistentTool',
+          type: 'tool-input-start',
+          // dynamic is NOT set (undefined) — this is what happens when the
+          // tool isn't in the tools object and the provider doesn't set it
+        },
+        {
+          inputTextDelta: '{ "foo": "bar" }',
+          toolCallId: 'call-1',
+          type: 'tool-input-delta',
+        },
+        {
+          errorText: "Model tried to call unavailable tool 'nonExistentTool'.",
+          input: '{ "foo": "bar" }',
+          toolCallId: 'call-1',
+          toolName: 'nonExistentTool',
+          type: 'tool-input-error',
+          // dynamic IS set to true — this is what parseToolCall returns for
+          // invalid tool calls (NoSuchToolError catch)
+          dynamic: true,
+        },
+        {
+          errorText: "Model tried to call unavailable tool 'nonExistentTool'.",
+          toolCallId: 'call-1',
+          type: 'tool-output-error',
+        },
+        {
+          type: 'finish-step',
+        },
+        {
+          type: 'finish',
+        },
+      ]);
+
+      state = createStreamingUIMessageState({
+        messageId: 'msg-123',
+        lastMessage: undefined,
+      });
+
+      await consumeStream({
+        stream: processUIMessageStream({
+          stream,
+          runUpdateMessageJob,
+          onError: error => {
+            throw error;
+          },
+        }),
+      });
+    });
+
+    it('should produce exactly one tool part (no duplicate)', async () => {
+      const toolParts = state!.message.parts.filter(
+        (p: any) => p.toolCallId === 'call-1',
+      );
+      expect(toolParts).toHaveLength(1);
+    });
+
+    it('should keep the static tool type from tool-input-start', async () => {
+      const toolPart = state!.message.parts.find(
+        (p: any) => p.toolCallId === 'call-1',
+      ) as any;
+      expect(toolPart.type).toBe('tool-nonExistentTool');
+    });
+
+    it('should have the correct final message state', async () => {
+      expect(state!.message.parts).toMatchInlineSnapshot(`
+        [
+          {
+            "type": "step-start",
+          },
+          {
+            "errorText": "Model tried to call unavailable tool 'nonExistentTool'.",
+            "input": undefined,
+            "output": undefined,
+            "preliminary": undefined,
+            "providerExecuted": undefined,
+            "rawInput": "{ "foo": "bar" }",
+            "state": "output-error",
+            "title": undefined,
+            "toolCallId": "call-1",
+            "type": "tool-nonExistentTool",
+          },
+        ]
+      `);
+    });
+  });
+
   describe('preliminary tool results', () => {
     beforeEach(async () => {
       const stream = createUIMessageStream([
diff --git a/packages/ai/src/ui/process-ui-message-stream.ts b/packages/ai/src/ui/process-ui-message-stream.ts
@@ -558,7 +558,18 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
             }
 
             case 'tool-input-error': {
-              if (chunk.dynamic) {
+              // When a part already exists for this toolCallId (e.g. from
+              // tool-input-start), honour its type so we update in place
+              // instead of creating a duplicate with a mismatched type.
+              const existingPart = state.message.parts
+                .filter(isToolUIPart)
+                .find(p => p.toolCallId === chunk.toolCallId);
+              const isDynamic =
+                existingPart != null
+                  ? existingPart.type === 'dynamic-tool'
+                  : !!chunk.dynamic;
+
+              if (isDynamic) {
                 updateDynamicToolPart({
                   toolCallId: chunk.toolCallId,
                   toolName: chunk.toolName,

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'ai': patch
 +---
++
 +fix(ai): Don't create duplicate tool parts when models call non-existent tools