fix(core): drop orphaned provider-executed tool calls on closed assistant turns

When a provider dropped a tool-result chunk (#15668) or a run aborted
mid-stream (#14148), the unresolved provider-executed tool call (e.g.
Anthropic web_search, Gemini code_execution) was replayed on every
subsequent request, deterministically bricking the thread.

sanitizeV5UIMessages now only preserves deferred input-available
provider-executed tool parts on the most recent assistant message and
only when no later user message has closed the turn. Orphans on earlier
assistant turns are dropped so outgoing history always satisfies the
tool-call/tool-result pairing invariant.

Fixes #15668

Co-Authored-By: Mastra Code (anthropic/claude-opus-4-7) <noreply@mastra.ai>

Author: roaminro

.changeset/puny-rats-talk.md

@@ -0,0 +1,7 @@
+---
+'@mastra/core': patch
+---
+
+Fixed a bug where orphaned provider-executed tool calls (e.g. Anthropic `web_search`, Gemini `code_execution`) could brick a thread. When a provider dropped the tool-result chunk ([#15668](https://github.com/mastra-ai/mastra/issues/15668)) or a run aborted mid-stream ([#14148](https://github.com/mastra-ai/mastra/issues/14148)), the unresolved call was replayed on every subsequent request — causing Gemini to return empty text and Anthropic to reject the tool-call/tool-result invariant.
+
+`sanitizeV5UIMessages` now only keeps an `input-available` provider-executed tool part on the most recent assistant message, and only when no user turn has followed it. Orphans on earlier assistant turns are dropped so the outgoing history always satisfies the tool-call/tool-result pairing required by provider APIs.

packages/core/src/agent/message-list/conversion/output-converter-provider-executed.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import type { AIV5Type } from '../types';
-import { addStartStepPartsForAIV5, sanitizeV5UIMessages } from './output-converter';
+import { addStartStepPartsForAIV5, aiV5UIMessagesToAIV5ModelMessages, sanitizeV5UIMessages } from './output-converter';
 
 /**
  * Tests for provider-executed tool handling in sanitizeV5UIMessages.
@@ -209,6 +209,202 @@ describe('sanitizeV5UIMessages — provider-executed tool handling', () => {
   });
 });
 
+/**
+ * Regression tests for https://github.com/mastra-ai/mastra/issues/15668
+ *
+ * Gemini `code_execution` (and `google_search`) on Vertex AI non-deterministically
+ * omits the paired `codeExecutionResult` after emitting `executableCode`. The AI SDK
+ * surfaces this as a `tool-call { providerExecuted: true }` chunk with no paired
+ * `tool-result`. Mastra currently persists that as
+ * `tool-invocation { state: 'call', providerExecuted: true }` with no result part.
+ *
+ * When the thread is replayed on the next turn, `sanitizeV5UIMessages` keeps the
+ * orphaned provider-executed call (line ~150 of output-converter.ts). The Google
+ * provider then serializes it as a bare `functionCall` in the `contents` array —
+ * with no paired `functionResponse`. Gemini returns `text: ""` for this turn and
+ * every subsequent turn on the thread (verified by the reporter: 5/5 empty STOP).
+ *
+ * The bricking is deterministic once the orphan lands. The contract that must
+ * hold is: after UI→Model conversion, there must NEVER be a `tool-call` content
+ * part without a corresponding `tool-result` somewhere in the outgoing messages.
+ * Whether the fix synthesizes a placeholder result or strips the call is an
+ * implementation detail — but one of the two must happen.
+ */
+describe('sanitizeV5UIMessages — orphaned provider-executed tool calls (issue #15668)', () => {
+  const makeToolPart = (
+    overrides: Partial<AIV5Type.ToolUIPart> & { type: string; toolCallId: string },
+  ): AIV5Type.ToolUIPart =>
+    ({
+      state: 'input-available' as const,
+      input: {},
+      ...overrides,
+    }) as AIV5Type.ToolUIPart;
+
+  it('drops or resolves an orphaned Gemini code_execution call so the next request is not an unpaired functionCall', () => {
+    // This is the exact shape Mastra persists after Vertex drops codeExecutionResult.
+    // It is NOT a legitimate deferred provider tool — Gemini code_execution does not
+    // defer across turns (unlike Anthropic web_search). Replaying this to the model
+    // deterministically produces empty text on every subsequent turn.
+    const user: AIV5Type.UIMessage = {
+      id: 'u1',
+      role: 'user',
+      parts: [{ type: 'text', text: 'Parse the attached spreadsheet and tell me the column names.' }],
+    };
+
+    const assistantWithOrphan: AIV5Type.UIMessage = {
+      id: 'a1',
+      role: 'assistant',
+      parts: [
+        { type: 'text', text: "I'll parse it with pandas via code_execution." },
+        makeToolPart({
+          type: 'tool-code_execution',
+          toolCallId: 'gem_tool_1',
+          state: 'input-available',
+          input: { code: "import pandas as pd; print(pd.read_excel('/tmp/x.xlsx').columns.tolist())" },
+          providerExecuted: true,
+        }),
+      ],
+    };
+
+    const followUp: AIV5Type.UIMessage = {
+      id: 'u2',
+      role: 'user',
+      parts: [{ type: 'text', text: 'what were the columns?' }],
+    };
+
+    const modelMessages = aiV5UIMessagesToAIV5ModelMessages(
+      [user, assistantWithOrphan, followUp],
+      [],
+      /* filterIncompleteToolCalls */ true,
+    );
+
+    // Walk all assistant content parts and collect tool-call / tool-result IDs.
+    const orphanCallIds: string[] = [];
+    const resultIds = new Set<string>();
+    for (const m of modelMessages) {
+      if (typeof m.content === 'string') continue;
+      for (const part of m.content) {
+        if (part.type === 'tool-call') {
+          orphanCallIds.push((part as any).toolCallId);
+        }
+        if (part.type === 'tool-result') {
+          resultIds.add((part as any).toolCallId);
+        }
+      }
+    }
+
+    // The invariant: every tool-call sent to the provider must have a matching
+    // tool-result. An orphaned `gem_tool_1` call without a result is exactly
+    // what bricks the thread.
+    const unpaired = orphanCallIds.filter(id => !resultIds.has(id));
+    expect(unpaired).toEqual([]);
+  });
+
+  it('drops or resolves an orphaned Anthropic web_search call stuck in state:"call" (same defect class)', () => {
+    // Same underlying issue as #14148 — once a provider-executed tool is persisted
+    // as state:"call" with no paired result, every subsequent turn replays it.
+    // The safeguard must be provider-agnostic.
+    const user: AIV5Type.UIMessage = {
+      id: 'u1',
+      role: 'user',
+      parts: [{ type: 'text', text: 'find me recent news on X' }],
+    };
+
+    const assistantWithOrphan: AIV5Type.UIMessage = {
+      id: 'a1',
+      role: 'assistant',
+      parts: [
+        makeToolPart({
+          type: 'tool-web_search_20250305',
+          toolCallId: 'srvtoolu_orphan1',
+          state: 'input-available',
+          input: { query: 'X' },
+          providerExecuted: true,
+        }),
+      ],
+    };
+
+    const followUp: AIV5Type.UIMessage = {
+      id: 'u2',
+      role: 'user',
+      parts: [{ type: 'text', text: 'you good?' }],
+    };
+
+    const modelMessages = aiV5UIMessagesToAIV5ModelMessages(
+      [user, assistantWithOrphan, followUp],
+      [],
+      /* filterIncompleteToolCalls */ true,
+    );
+
+    const orphanCallIds: string[] = [];
+    const resultIds = new Set<string>();
+    for (const m of modelMessages) {
+      if (typeof m.content === 'string') continue;
+      for (const part of m.content) {
+        if (part.type === 'tool-call') orphanCallIds.push((part as any).toolCallId);
+        if (part.type === 'tool-result') resultIds.add((part as any).toolCallId);
+      }
+    }
+
+    const unpaired = orphanCallIds.filter(id => !resultIds.has(id));
+    expect(unpaired).toEqual([]);
+  });
+
+  it('drops a stale deferred provider call on an EARLIER assistant message when a later assistant message exists', () => {
+    // Multi-assistant history shape — this guards against the class of bug #14192:
+    // a provider-executed tool left in `input-available` on an earlier assistant
+    // turn must not be replayed to the provider just because the final turn is
+    // also an assistant. Only the most recent assistant message may legitimately
+    // carry a deferred provider tool.
+    const user: AIV5Type.UIMessage = {
+      id: 'u1',
+      role: 'user',
+      parts: [{ type: 'text', text: 'search for recent news about X' }],
+    };
+
+    const earlierAssistantWithStaleProviderCall: AIV5Type.UIMessage = {
+      id: 'a1',
+      role: 'assistant',
+      parts: [
+        makeToolPart({
+          type: 'tool-web_search_20250305',
+          toolCallId: 'srvtoolu_stale',
+          state: 'input-available',
+          input: { query: 'X' },
+          providerExecuted: true,
+        }),
+      ],
+    };
+
+    const laterAssistant: AIV5Type.UIMessage = {
+      id: 'a2',
+      role: 'assistant',
+      parts: [{ type: 'text', text: 'Here is a summary based on what I found earlier.' }],
+    };
+
+    const modelMessages = aiV5UIMessagesToAIV5ModelMessages(
+      [user, earlierAssistantWithStaleProviderCall, laterAssistant],
+      [],
+      /* filterIncompleteToolCalls */ true,
+    );
+
+    const orphanCallIds: string[] = [];
+    const resultIds = new Set<string>();
+    for (const m of modelMessages) {
+      if (typeof m.content === 'string') continue;
+      for (const part of m.content) {
+        if (part.type === 'tool-call') orphanCallIds.push((part as any).toolCallId);
+        if (part.type === 'tool-result') resultIds.add((part as any).toolCallId);
+      }
+    }
+
+    const unpaired = orphanCallIds.filter(id => !resultIds.has(id));
+    expect(unpaired).toEqual([]);
+    // Belt-and-suspenders: the stale id must not have leaked through at all.
+    expect(orphanCallIds).not.toContain('srvtoolu_stale');
+  });
+});
+
 describe('addStartStepPartsForAIV5 — client/provider tool splitting', () => {
   const makeToolPart = (
     overrides: Partial<AIV5Type.ToolUIPart> & { type: string; toolCallId: string },

packages/core/src/agent/message-list/conversion/output-converter.ts

@@ -108,10 +108,32 @@ export function sanitizeV5UIMessages(
   messages: AIV5Type.UIMessage[],
   filterIncompleteToolCalls = false,
 ): AIV5Type.UIMessage[] {
+  // Precompute the index of the last user message AND the index of the last
+  // assistant message. A deferred provider-executed tool call (e.g. Anthropic
+  // non-deterministically defers web_search across steps N→N+1 within the same
+  // run) may legitimately carry `input-available` state ONLY on the most recent
+  // assistant message, AND only if no user turn has followed it. On any earlier
+  // assistant turn (or after a later user message) an unresolved provider-executed
+  // call is an orphan — provider dropped the result chunk (#15668), run aborted
+  // mid-stream (#14148), or a stale call from an earlier step (#14192) — and
+  // must be dropped to keep the tool-call/tool-result invariant.
+  let lastUserIdx = -1;
+  let lastAssistantIdx = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const role = messages[i]!.role;
+    if (role === 'user' && lastUserIdx === -1) lastUserIdx = i;
+    if (role === 'assistant' && lastAssistantIdx === -1) lastAssistantIdx = i;
+    if (lastUserIdx !== -1 && lastAssistantIdx !== -1) break;
+  }
+
   const msgs = messages
-    .map(m => {
+    .map((m, idx) => {
       if (m.parts.length === 0) return false;
 
+      // Deferred-provider-tool behavior is ONLY valid on the most recent assistant
+      // message AND only when no user turn has followed it.
+      const assistantTurnStillOpen = m.role === 'assistant' && idx === lastAssistantIdx && idx > lastUserIdx;
+
       // Filter out streaming states and optionally input-available (which aren't supported by convertToModelMessages)
       const safeParts = m.parts.filter(p => {
         // Filter out data-* parts (custom streaming data from writer.custom())
@@ -146,8 +168,11 @@ export function sanitizeV5UIMessages(
           if (p.state === 'output-available' || p.state === 'output-error') return true;
           // Provider-executed tools may be deferred by the provider (e.g. Anthropic non-deterministically
           // defers web_search when mixed with client tool calls). Keep these so the provider API sees
-          // the server_tool_use block on the next request.
-          if (p.state === 'input-available' && p.providerExecuted) return true;
+          // the server_tool_use block on the next request — but ONLY on the most recent assistant
+          // message. On any earlier assistant turn an unresolved provider-executed call is an orphan
+          // (provider dropped the result chunk, or the run aborted mid-stream) and must be dropped
+          // to keep the tool-call/tool-result invariant required by provider APIs. See #15668, #14148.
+          if (p.state === 'input-available' && p.providerExecuted && assistantTurnStillOpen) return true;
           return false;
         }