@ai-sdk/anthropic 3.0.123 → 3.0.125

package/docs/05-anthropic.mdx

@@ -189,9 +189,10 @@ const result = streamText({
 });
 ```
 
-For `claude-opus-5-5` and `claude-fable-5-1`, the default `"auto"` mode uses
-native structured outputs through `output_config.format`. These models reject
-forced tool use, so the `"jsonTool"` mode cannot be used with them. If you
+For `claude-sonnet-5-5`, `claude-opus-5-5`, and `claude-fable-5-1`, the
+default `"auto"` mode uses native structured outputs through
+`output_config.format`. These models reject forced tool use, so the
+`"jsonTool"` mode cannot be used with them. If you
 request `"jsonTool"` anyway, the provider falls back to `"outputFormat"` and
 emits a warning. Likewise, a `required` or named `toolChoice` is downgraded to
 `auto` with a warning; instruct the model to use the tool in your prompt and
@@ -199,7 +200,7 @@ verify that a tool call was made.
 
 ### Effort
 
-Anthropic introduced an `effort` option with `claude-opus-4-5` that affects thinking, text responses, and function calls. Effort defaults to `high` and you can set it to `medium` or `low` to save tokens and to lower time-to-last-token latency (TTLT). `claude-opus-4-7`, `claude-opus-4-8`, `claude-opus-5`, `claude-opus-5-5`, `claude-fable-5`, `claude-fable-5-1`, and `claude-sonnet-5` additionally support `xhigh` for maximum reasoning effort.
+Anthropic introduced an `effort` option with `claude-opus-4-5` that affects thinking, text responses, and function calls. Effort defaults to `high` and you can set it to `medium` or `low` to save tokens and to lower time-to-last-token latency (TTLT). `claude-opus-4-7`, `claude-opus-4-8`, `claude-opus-5`, `claude-opus-5-5`, `claude-fable-5`, `claude-fable-5-1`, `claude-sonnet-5`, and `claude-sonnet-5-5` additionally support `xhigh` for maximum reasoning effort.
 
 On `claude-opus-5`, thinking can only be disabled at effort levels up to and including `high`. When you combine `thinking: { type: 'disabled' }` with `effort: 'xhigh'` or `effort: 'max'`, the AI SDK lowers the effort to `high` and emits a warning instead of sending a request that the API would reject.
 
@@ -210,6 +211,16 @@ carrying over the setting you used on `claude-opus-5`. Set `maxOutputTokens`
 with room for thinking as well as the reply; thinking counts toward the limit
 even when its content is not returned.
 
+On `claude-sonnet-5-5`, thinking cannot be turned off either, and the API
+default effort is `high`. Its effort levels are not equivalent to those of
+`claude-sonnet-5`, so test several levels rather than carrying over your
+current setting. For agentic coding and other multi-step tool use, start at
+`medium` for well-specified tasks and move to `high` for harder ones. The
+lowest thinking setting, [`between_tools`](#between-tools-thinking), is only
+accepted at `low`, `medium`, and `high` effort. When you combine it with
+`effort: 'xhigh'` or `effort: 'max'`, the AI SDK lowers the effort to `high`
+and emits a warning.
+
 ```ts highlight="8-10"
 import { anthropic, AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
 import { generateText } from 'ai';
@@ -314,6 +325,8 @@ The `inferenceGeo` option accepts `'us'` (US-only infrastructure) or `'global'`
 
 Claude Fable 5 has safeguards that limit its performance in certain areas like cybersecurity, biology, and chemistry, and automated safety checks are run on every request.
 
+Claude Sonnet 5.5 also has safety classifiers enabled, including for cybersecurity, biology, and reasoning extraction. Requests that ask the model to reproduce its internal reasoning in the response text can be declined with the `reasoning_extraction` category; use `thinking: { type: 'adaptive', display: 'summarized' }` and read the reasoning parts instead.
+
 When one of these checks blocks a request, the API does not answer it. Instead it returns a classifier block: a `200` response with a `refusal` stop reason and an optional `stop_details` object describing the category that triggered the block. The AI SDK surfaces this as a `content-filter` finish reason, with the details available on `providerMetadata.anthropic.stopDetails`.
 
 A classifier block looks like this:
@@ -431,14 +444,20 @@ const { text } = await generateText({
 
 ##### Adaptive-Only Models
 
-`claude-opus-5-5`, `claude-fable-5`, and `claude-fable-5-1` always run adaptive
-thinking. The API rejects `thinking: { type: 'disabled' }` and budget-based
-`thinking: { type: 'enabled' }` for these models. To keep existing code working,
-the provider:
+`claude-sonnet-5-5`, `claude-opus-5-5`, `claude-fable-5`, and
+`claude-fable-5-1` always run adaptive thinking. The API rejects
+`thinking: { type: 'disabled' }` and budget-based
+`thinking: { type: 'enabled' }` for these models. To keep existing code
+working, the provider:
 
 - removes `thinking: { type: 'disabled' }` and emits a warning,
 - converts `thinking: { type: 'enabled', budgetTokens }` to `{ type: 'adaptive' }` and emits a warning.
 
+On `claude-sonnet-5-5`, which supports
+[`between_tools` thinking](#between-tools-thinking), the provider instead
+replaces `thinking: { type: 'disabled' }` with `thinking: { type: 'between_tools' }`
+and emits a warning.
+
 Use `effort` to control how much these models think. On `claude-opus-5-5`, set
 `effort: 'low'` when time to first token matters, and move to `medium` if
 quality drops:
@@ -463,6 +482,42 @@ const { text } = await generateText({
   setting, thinking blocks are returned with empty text.
 </Note>
 
+##### Between-Tools Thinking
+
+`claude-sonnet-5-5` supports `thinking: { type: 'between_tools' }`, its lowest
+thinking setting. The model does no upfront thinking, but the short progress
+notes it writes between tool calls are still returned as thinking blocks, each
+with a short summary. They are available as reasoning parts and are sent back
+unchanged on the next step. `between_tools` accepts no other thinking options
+(such as `display` or `blockBinding`) and is only accepted at `low`, `medium`,
+and `high` effort. Per-message effort changes via
+[mid-conversation system messages](#mid-conversation-system-controls) are not
+supported with `between_tools`.
+
+```ts highlight="16-17"
+import { anthropic, AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
+import { generateText, stepCountIs, tool } from 'ai';
+import { z } from 'zod';
+
+const { text, steps } = await generateText({
+  model: anthropic('claude-sonnet-5-5'),
+  stopWhen: stepCountIs(5),
+  tools: {
+    weather: tool({
+      inputSchema: z.object({ city: z.string() }),
+      execute: async ({ city }) => ({ city, temperature: 72 }),
+    }),
+  },
+  providerOptions: {
+    anthropic: {
+      thinking: { type: 'between_tools' },
+      effort: 'low',
+    } satisfies AnthropicLanguageModelOptions,
+  },
+  prompt: 'Compare the weather in San Francisco and New York.',
+});
+```
+
 ##### Thinking Display (Opus 4.7+)
 
 Starting with `claude-opus-4-7`, thinking content is omitted from the response by default — thinking blocks are present in the stream but their text is empty. To receive reasoning output, set `display: 'summarized'`:
@@ -490,11 +545,11 @@ console.log(text);
 
 ##### Thinking Updates
 
-Use `display: 'updates'` with `claude-opus-5-5` or `claude-fable-5-1` to stream
-thinking summaries between tool calls. These models return progress notes
-between tool calls as thinking blocks rather than text, so without this setting
-a long tool-calling turn can look silent. The provider adds the required
-`thinking-display-updates-2026-08-18` beta header automatically:
+Use `display: 'updates'` with `claude-sonnet-5-5`, `claude-opus-5-5`, or
+`claude-fable-5-1` to stream thinking summaries between tool calls. These models
+return progress notes between tool calls as thinking blocks rather than text, so
+without this setting a long tool-calling turn can look silent. The provider adds
+the required `thinking-display-updates-2026-08-18` beta header automatically:
 
 ```ts highlight="12-16"
 import { anthropic, AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
@@ -519,11 +574,13 @@ const result = streamText({
 
 ##### Thinking Block Binding
 
-Fable 5.1 can recover from a thinking-block prefix mismatch by dropping the
-mismatched block. Set `blockBinding.prefixMismatchBehavior` to `drop_block`, or
-set it to `error` to reject the request. You can provide block binding by itself
-to preserve the model's default thinking mode, or combine it with adaptive
-thinking.
+Fable 5.1, Opus 5.5, and Sonnet 5.5 can recover from a thinking-block prefix
+mismatch by dropping the mismatched block. Set
+`blockBinding.prefixMismatchBehavior` to `drop_block`, or set it to `error` to
+reject the request. You can provide block binding by itself to preserve the
+model's default thinking mode, or combine it with adaptive thinking. Block
+binding is not available with `between_tools` thinking; keep the message
+history append-only instead.
 
 ```ts highlight="7-11"
 const result = await generateText({
@@ -1038,19 +1095,20 @@ const computerTool = anthropic.tools.computer_20251124({
 ```
 
 <Note>
-  Use `computerToolset_20260801` for Claude Opus 5.5 (required), Opus 5, Sonnet
-  5, Fable 5, Fable 5.1, and Opus 4.8. Use `computer_20251124` for Claude Opus
-  4.5 through Opus 4.7, which support the zoom action. Use `computer_20250124`
-  for Claude Sonnet 4.5, Haiku 4.5, Opus 4.1, Sonnet 4, Opus 4, and Sonnet 3.7.
+  Use `computerToolset_20260801` for Claude Sonnet 5.5 and Opus 5.5 (required),
+  Opus 5, Sonnet 5, Fable 5, Fable 5.1, and Opus 4.8. Use `computer_20251124`
+  for Claude Opus 4.5 through Opus 4.7, which support the zoom action. Use
+  `computer_20250124` for Claude Sonnet 4.5, Haiku 4.5, Opus 4.1, Sonnet 4, Opus
+  4, and Sonnet 3.7.
 </Note>
 
 #### Computer Toolset
 
 Newer models use the computer toolset instead of a versioned computer tool.
-`claude-opus-5-5` accepts computer use only through the toolset and rejects the
-older `computer_*` tool types with a 400. The toolset does not require a beta
-header and has no display size parameters: coordinates are always in the pixel
-space of the screenshots you return. Zoom is enabled by default, and Claude can
+`claude-sonnet-5-5` and `claude-opus-5-5` accept computer use only through the
+toolset and reject the older `computer_*` tool types with a 400. The toolset
+does not require a beta header and has no display size parameters: coordinates
+are always in the pixel space of the screenshots you return. Zoom is enabled by default, and Claude can
 return several actions in one turn, each as its own tool call.
 
 The API returns each action as a separate `tool_use` block with
@@ -1376,10 +1434,10 @@ This sends `tool_reference` blocks to Anthropic, which loads the corresponding d
 
 ### Mid-Conversation System Controls
 
-With `claude-opus-5-5` and `claude-fable-5-1`, use an empty system message to
-change effort from the next user turn. A separate system message containing text
-can provide a turn-scoped reminder with `clearAt: 'next_user_message'`: its text
-applies until the next user message. Keep the reminder after a user turn and
+With `claude-sonnet-5-5`, `claude-opus-5-5`, and `claude-fable-5-1`, use an
+empty system message to change effort from the next user turn. A separate
+system message containing text can provide a turn-scoped reminder with
+`clearAt: 'next_user_message'`: its text applies until the next user message. Keep the reminder after a user turn and
 before an assistant turn, or at the end of the messages array.
 The provider adds the required
 `mid-conversation-system-clear-at-2026-08-21` and
@@ -1742,6 +1800,18 @@ In this flow:
   `code_execution_20260120` or `code_execution_20250825` tool.
 </Note>
 
+#### Pruning Programmatic Tool History
+
+When pruning removes a code execution call but keeps a tool call that references
+it through `caller.toolId`, the provider omits the dangling caller metadata from
+history before a subsequent user message and emits a warning. The retained tool
+calls and results are still sent to Anthropic; the removed code execution history
+is not restored.
+
+Tool-result messages do not end a turn. Caller metadata in an active tool
+continuation is preserved, so keep the source code execution call when returning
+programmatic tool results.
+
 #### Container Persistence
 
 When using programmatic tool calling across multiple steps, you need to preserve the container ID between steps using `prepareStep`. You can use the `forwardAnthropicContainerIdFromLastStep` helper function to do this automatically. The container ID is available in `providerMetadata.anthropic.container.id` after each step completes.
@@ -1889,6 +1959,7 @@ and the `mediaType` should be set to `'application/pdf'`.
 | `claude-fable-5-1`  | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `claude-opus-5-5`   | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `claude-opus-5`     | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
+| `claude-sonnet-5-5` | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `claude-sonnet-5`   | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `claude-fable-5`    | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `claude-opus-4-8`   | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/anthropic",
-  "version": "3.0.123",
+  "version": "3.0.125",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "3.0.18",
-    "@ai-sdk/provider-utils": "4.0.55"
+    "@ai-sdk/provider-utils": "4.0.56"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/anthropic-messages-language-model.ts

@@ -341,6 +341,7 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       rejectsThinkingDisabledAboveHighEffort,
       rejectsThinkingDisabled,
       rejectsForcedToolUse,
+      supportsBetweenToolsThinking,
       isKnownModel,
     } = getModelCapabilities(this.modelId);
 
@@ -495,7 +496,16 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       const requestedType =
         'type' in requestedThinking ? requestedThinking.type : undefined;
 
-      if (requestedType === 'disabled') {
+      if (requestedType === 'disabled' && supportsBetweenToolsThinking) {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'providerOptions.anthropic.thinking',
+          details:
+            `thinking cannot be disabled for ${this.modelId}. ` +
+            `Using 'between_tools' thinking, the lowest thinking setting, instead.`,
+        });
+        anthropicOptions.thinking = { type: 'between_tools' };
+      } else if (requestedType === 'disabled') {
         warnings.push({
           type: 'unsupported',
           feature: 'providerOptions.anthropic.thinking',
@@ -539,8 +549,27 @@ export class AnthropicMessagesLanguageModel implements LanguageModelV3 {
       anthropicOptions.effort = 'high';
     }
 
+    // `between_tools` thinking is only accepted at `low`, `medium`, and
+    // `high` effort. Lower the effort to `high` to keep the minimal thinking
+    // setting instead of sending a request that the API would reject.
+    if (
+      thinkingType === 'between_tools' &&
+      (anthropicOptions.effort === 'xhigh' || anthropicOptions.effort === 'max')
+    ) {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'providerOptions.anthropic.effort',
+        details:
+          `effort '${anthropicOptions.effort}' is not supported with 'between_tools' thinking. ` +
+          `The effort has been lowered to 'high'.`,
+      });
+      anthropicOptions.effort = 'high';
+    }
+
     const isThinking =
-      thinkingType === 'enabled' || thinkingType === 'adaptive';
+      thinkingType === 'enabled' ||
+      thinkingType === 'adaptive' ||
+      thinkingType === 'between_tools';
     // `disabled` must still be forwarded to the API: some models (e.g. Sonnet 5)
     // default thinking on, so omitting it would leave thinking enabled and
     // consume the max_tokens budget.
@@ -2917,9 +2946,25 @@ export function getModelCapabilities(modelId: string): {
    * Forced tool use (`tool_choice` `any` or a named tool) is rejected with a 400.
    */
   rejectsForcedToolUse: boolean;
+  /**
+   * Supports `thinking.type` `between_tools`, the lowest thinking setting on
+   * models that reject disabled thinking.
+   */
+  supportsBetweenToolsThinking: boolean;
   isKnownModel: boolean;
 } {
-  if (modelId.includes('claude-opus-5-5')) {
+  if (modelId.includes('claude-sonnet-5-5')) {
+    return {
+      maxOutputTokens: 128000,
+      supportsStructuredOutput: true,
+      rejectsSamplingParameters: true,
+      rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: true,
+      rejectsForcedToolUse: true,
+      supportsBetweenToolsThinking: true,
+      isKnownModel: true,
+    };
+  } else if (modelId.includes('claude-opus-5-5')) {
     return {
       maxOutputTokens: 128000,
       supportsStructuredOutput: true,
@@ -2927,6 +2972,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: true,
       rejectsThinkingDisabled: true,
       rejectsForcedToolUse: true,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-opus-5')) {
@@ -2937,6 +2983,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: true,
       rejectsThinkingDisabled: false,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-fable-5-1')) {
@@ -2947,6 +2994,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: true,
       rejectsForcedToolUse: true,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-fable-5')) {
@@ -2957,6 +3005,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: true,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
   } else if (
@@ -2971,6 +3020,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
   } else if (
@@ -2984,6 +3034,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
   } else if (
@@ -2998,6 +3049,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-opus-4-1')) {
@@ -3008,6 +3060,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-sonnet-4-')) {
@@ -3018,6 +3071,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-opus-4-')) {
@@ -3028,6 +3082,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
   } else if (modelId.includes('claude-3-haiku')) {
@@ -3038,6 +3093,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true,
     };
   } else if (
@@ -3050,6 +3106,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: false,
     };
   } else if (modelId.includes('claude-')) {
@@ -3063,6 +3120,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: true,
       rejectsThinkingDisabled: false,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: false,
     };
   } else {
@@ -3075,6 +3133,7 @@ export function getModelCapabilities(modelId: string): {
       rejectsThinkingDisabledAboveHighEffort: false,
       rejectsThinkingDisabled: false,
       rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: false,
     };
   }

package/src/anthropic-messages-options.ts

@@ -24,6 +24,7 @@ export type AnthropicMessagesModelId =
   | 'claude-fable-5'
   | 'claude-fable-5-1'
   | 'claude-sonnet-5'
+  | 'claude-sonnet-5-5'
   | (string & {});
 
 /**
@@ -147,6 +148,9 @@ export const anthropicLanguageModelOptions = z.object({
    * `claude-fable-5-1`) reject `enabled` and `disabled`. For those models the
    * provider drops the unsupported setting, emits a warning, and sends an
    * adaptive thinking request. Use `effort` to control how much they think.
+   *
+   * `claude-sonnet-5-5` supports `between_tools`, its lowest thinking setting,
+   * and the provider uses it in place of `disabled` for that model.
    */
   thinking: z
     .union([
@@ -177,6 +181,14 @@ export const anthropicLanguageModelOptions = z.object({
         z.object({
           type: z.literal('disabled'),
         }),
+        z.object({
+          /**
+           * for `claude-sonnet-5-5`: no upfront thinking, but progress notes
+           * between tool calls are returned as summarized thinking blocks.
+           * Only supported at `low`, `medium`, and `high` effort.
+           */
+          type: z.literal('between_tools'),
+        }),
       ]),
       /**
        * Configures prefix mismatch recovery without changing the model's

package/src/convert-to-anthropic-messages-prompt.ts

@@ -139,6 +139,7 @@ export async function convertToAnthropicMessagesPrompt({
 
   let system: AnthropicMessagesPrompt['system'] = undefined;
   const messages: AnthropicMessagesPrompt['messages'] = [];
+  let lastUserMessageIndex = -1;
 
   async function shouldEnableCitations(
     providerMetadata: SharedV3ProviderMetadata | undefined,
@@ -300,6 +301,10 @@ export async function convertToAnthropicMessagesPrompt({
           const { role, content } = message;
           switch (role) {
             case 'user': {
+              if (content.length > 0) {
+                lastUserMessageIndex = messages.length;
+              }
+
               for (let j = 0; j < content.length; j++) {
                 const part = content[j];
 
@@ -1313,6 +1318,55 @@ export async function convertToAnthropicMessagesPrompt({
     }
   }
 
+  // Pruning can remove a code execution call while retaining tool calls that
+  // reference it. Check the converted blocks, since unsupported source calls
+  // may also have been omitted during conversion.
+  const codeExecutionToolCallIds = new Set<string>();
+  for (const message of messages) {
+    if (message.role !== 'assistant') {
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type === 'server_tool_use' && part.name === 'code_execution') {
+        codeExecutionToolCallIds.add(part.id);
+      }
+    }
+  }
+
+  // Only normalize history before a subsequent user message. Tool-result
+  // messages do not end a turn: their caller metadata must remain intact so
+  // Anthropic can resume an active code execution.
+  const warnedToolCallIds = new Set<string>();
+  for (let i = 0; i < lastUserMessageIndex; i++) {
+    const message = messages[i];
+    if (message.role !== 'assistant') {
+      continue;
+    }
+    for (const part of message.content) {
+      if (!('caller' in part)) {
+        continue;
+      }
+      const caller = part.caller;
+      if (
+        caller == null ||
+        caller.type === 'direct' ||
+        codeExecutionToolCallIds.has(caller.tool_id)
+      ) {
+        continue;
+      }
+
+      const toolCallId = 'id' in part ? part.id : part.tool_use_id;
+      delete part.caller;
+      if (!warnedToolCallIds.has(toolCallId)) {
+        warnedToolCallIds.add(toolCallId);
+        warnings.push({
+          type: 'other',
+          message: `Omitted caller metadata for tool ${toolCallId} because source code execution tool ${caller.tool_id} is missing from the conversation history.`,
+        });
+      }
+    }
+  }
+
   return {
     prompt: { system, messages },
     betas,