@tanstack/ai-anthropic 0.15.13 → 0.16.1

package/dist/esm/text/text-provider-options.d.ts

@@ -131,6 +131,65 @@ export interface AnthropicAdaptiveThinkingOptions {
         type: 'disabled';
     };
 }
+/**
+ * Thinking configuration for models where thinking is always on
+ * (e.g. Claude Fable 5).
+ *
+ * On these models the only accepted explicit configuration is
+ * `{type: 'adaptive'}` — both `{type: 'disabled'}` and
+ * `{type: 'enabled', budget_tokens}` are rejected with a 400. Omitting the
+ * `thinking` field entirely also runs adaptive thinking.
+ */
+export interface AnthropicAdaptiveOnlyThinkingOptions {
+    thinking?: {
+        type: 'adaptive';
+        /**
+         * Controls what (if any) thinking content is streamed back.
+         *
+         * - `'summarized'`: stream summarized thinking via `thinking_delta`
+         *   events (the user-visible reasoning text).
+         * - `'omitted'` (default): stream the thinking block's
+         *   `signature_delta` only (no reasoning text reaches the client).
+         */
+        display?: 'summarized' | 'omitted';
+    };
+}
+/**
+ * Thinking configuration for models that accept adaptive thinking or an
+ * explicit opt-out, but no manual token budget (e.g. Claude Sonnet 5,
+ * Claude Opus 4.7/4.8).
+ *
+ * `{type: 'enabled', budget_tokens}` is rejected with a 400 on these
+ * models. On Claude Sonnet 5, omitting the `thinking` field runs adaptive
+ * thinking by default; on Opus 4.7/4.8 it runs without thinking — set
+ * `{type: 'adaptive'}` explicitly there.
+ */
+export interface AnthropicAdaptiveOrDisabledThinkingOptions {
+    thinking?: {
+        type: 'adaptive';
+        /**
+         * Controls what (if any) thinking content is streamed back.
+         * Defaults to `'omitted'` — set `'summarized'` to receive the
+         * reasoning text.
+         */
+        display?: 'summarized' | 'omitted';
+    } | {
+        type: 'disabled';
+    };
+}
+/**
+ * `max_tokens` on its own, for models that reject the sampling parameters
+ * (`temperature`, `top_p`, `top_k`) — e.g. Claude Fable 5 and Claude Opus
+ * 4.7/4.8 reject them outright, and Claude Sonnet 5 returns a 400 when a
+ * non-default sampling value is sent.
+ */
+export interface AnthropicMaxTokensOptions {
+    /**
+     * The maximum number of tokens to generate before stopping. This parameter only specifies the absolute maximum number of tokens to generate. Required by the API; the adapter defaults to 1024 when omitted.
+     * Range x >= 1.
+     */
+    max_tokens?: number;
+}
 export interface AnthropicEffortOptions {
     /**
      * Controls the thinking depth for adaptive thinking mode (Opus 4.6+).
@@ -158,7 +217,11 @@ export interface AnthropicOutputConfigOptions {
      * preserved when the engine adds `format`.
      */
     output_config?: {
-        effort?: 'low' | 'medium' | 'high' | 'max' | null;
+        /**
+         * `'xhigh'` is accepted on Claude Opus 4.7+, Claude Sonnet 5, and
+         * Claude Fable 5; older models support `'low'`–`'max'` only.
+         */
+        effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max' | null;
     };
 }
 export interface AnthropicToolChoiceOptions {
@@ -233,7 +296,7 @@ export interface InternalTextProviderOptions extends ExternalTextProviderOptions
      * cast.
      */
     output_config?: {
-        effort?: 'low' | 'medium' | 'high' | 'max' | null;
+        effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max' | null;
         format?: {
             type: 'json_schema';
             schema: Record<string, unknown>;

package/dist/esm/text/text-provider-options.js.map

@@ -1 +1 @@
-{"version":3,"file":"text-provider-options.js","sources":["../../../src/text/text-provider-options.ts"],"sourcesContent":["import type {\n  BetaContextManagementConfig,\n  BetaToolChoiceAny,\n  BetaToolChoiceAuto,\n  BetaToolChoiceTool,\n} from '@anthropic-ai/sdk/resources/beta/messages/messages'\nimport type { CacheControlEphemeral } from '@anthropic-ai/sdk/resources'\nimport type { AnthropicContainerSkill, AnthropicTool } from '../tools'\nimport type {\n  MessageParam,\n  TextBlockParam,\n} from '@anthropic-ai/sdk/resources/messages'\n\n/**\n * Per-prompt metadata Anthropic understands on `systemPrompts` entries.\n *\n * Used via the structured form of `systemPrompts`:\n *\n * @example\n *   import type { AnthropicSystemPromptMetadata } from '@tanstack/ai-anthropic'\n *\n *   chat({\n *     adapter: anthropicText(),\n *     model: 'claude-sonnet-4-6',\n *     systemPrompts: [\n *       {\n *         content: 'Stable instructions — cache me.',\n *         metadata: { cache_control: { type: 'ephemeral' } } satisfies AnthropicSystemPromptMetadata,\n *       },\n *       'Volatile per-request instruction.',\n *     ],\n *   })\n */\nexport interface AnthropicSystemPromptMetadata {\n  /**\n   * Anthropic prompt-caching control applied to this system prompt's\n   * `TextBlockParam`.\n   *\n   * @see https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching\n   */\n  cache_control?: CacheControlEphemeral\n}\n\nexport interface AnthropicContainerOptions {\n  /**\n   * Container identifier for reuse across requests.\n   * Container parameters with skills to be loaded.\n   */\n  container?: {\n    id: string | null\n    /**\n     * List of skills to load into the container.\n     *\n     * @deprecated Configure skills on the `code_execution` tool instead:\n     * `codeExecutionTool(config, { skills })`. The adapter lifts those into\n     * `container.skills` and attaches the required beta headers. Setting\n     * skills here bypasses the beta-header wiring and may stop working.\n     */\n    skills: Array<AnthropicContainerSkill> | null\n  } | null\n}\n\nexport interface AnthropicContextManagementOptions {\n  /**\n   * Context management configuration.\n\nThis allows you to control how Claude manages context across multiple requests, such as whether to clear function results or not.\n   */\n  context_management?: BetaContextManagementConfig | null\n}\n\nexport interface AnthropicMCPOptions {\n  /**\n   * MCP servers to be utilized in this request\n   * Maximum of 20 servers\n   */\n  mcp_servers?: Array<MCPServer>\n}\n\nexport interface AnthropicServiceTierOptions {\n  /**\n   * Determines whether to use priority capacity (if available) or standard capacity for this request.\n   */\n  service_tier?: 'auto' | 'standard_only'\n}\n\nexport interface AnthropicStopSequencesOptions {\n  /**\n   * Custom text sequences that will cause the model to stop generating.\n\nAnthropic models will normally stop when they have naturally completed their turn, which will result in a response stop_reason of \"end_turn\".\n\nIf you want the model to stop generating when it encounters custom strings of text, you can use the stop_sequences parameter. If the model encounters one of the custom sequences, the response stop_reason value will be \"stop_sequence\" and the response stop_sequence value will contain the matched stop sequence.\n   */\n  stop_sequences?: Array<string>\n}\n\nexport interface AnthropicThinkingOptions {\n  /**\n     * Configuration for enabling Claude's extended thinking.\n\nWhen enabled, responses include thinking content blocks showing Claude's thinking process before the final answer. Requires a minimum budget of 1,024 tokens and counts towards your max_tokens limit.\n     */\n  thinking?:\n    | {\n        /**\n* Determines how many tokens Claude can use for its internal reasoning process. Larger budgets can enable more thorough analysis for complex problems, improving response quality.\n\nMust be ≥1024 and less than max_tokens\n*/\n        budget_tokens: number\n\n        type: 'enabled'\n      }\n    | {\n        type: 'disabled'\n      }\n}\n\nexport interface AnthropicAdaptiveThinkingOptions {\n  /**\n   * Configuration for Claude's adaptive thinking (Opus 4.6+).\n   *\n   * In adaptive mode, Claude dynamically decides when and how much to think.\n   * Use the effort parameter to control thinking depth.\n   * `thinking: {type: \"enabled\"}` with `budget_tokens` is deprecated on Opus 4.6.\n   */\n  thinking?:\n    | {\n        type: 'adaptive'\n        /**\n         * Controls what (if any) thinking content is streamed back.\n         *\n         * - `'summarized'`: stream summarized thinking via `thinking_delta`\n         *   events (the user-visible reasoning text).\n         * - `'omitted'`: stream the thinking block's `signature_delta` only\n         *   (no reasoning text reaches the client).\n         *\n         * On Claude Opus 4.6 the default is `'summarized'`. On\n         * Claude Opus 4.7 the default flipped to `'omitted'` — callers\n         * must set `'summarized'` explicitly to get the reasoning text.\n         */\n        display?: 'summarized' | 'omitted'\n      }\n    | {\n        /**\n         * @deprecated Use `type: 'adaptive'` with the effort parameter on Opus 4.6+.\n         */\n        budget_tokens: number\n        type: 'enabled'\n      }\n    | {\n        type: 'disabled'\n      }\n}\n\nexport interface AnthropicEffortOptions {\n  /**\n   * Controls the thinking depth for adaptive thinking mode (Opus 4.6+).\n   *\n   * - `max`: Absolute highest capability\n   * - `high`: Default - Claude will almost always think\n   * - `medium`: Balanced cost-quality\n   * - `low`: May skip thinking for simpler problems\n   */\n  effort?: 'max' | 'high' | 'medium' | 'low'\n}\n\nexport interface AnthropicOutputConfigOptions {\n  /**\n   * Output configuration for the model's response.\n   *\n   * On Claude 4.7+ the top-level `effort` field was relocated under\n   * `output_config.effort`, and `thinking: { type: 'enabled', budget_tokens }`\n   * was replaced by `thinking: { type: 'adaptive' }` paired with\n   * `output_config.effort`. Earlier models continue to accept the legacy\n   * top-level `effort` / `thinking.type: 'enabled'` shape.\n   *\n   * The engine also writes `output_config.format` here when the caller\n   * passes `outputSchema` to a Claude 4.5+ adapter (issue #605 native\n   * combined mode). Both fields coexist: user-supplied `effort` is\n   * preserved when the engine adds `format`.\n   */\n  output_config?: {\n    effort?: 'low' | 'medium' | 'high' | 'max' | null\n  }\n}\n\nexport interface AnthropicToolChoiceOptions {\n  tool_choice?: BetaToolChoiceAny | BetaToolChoiceTool | BetaToolChoiceAuto\n}\n\nexport interface AnthropicSamplingOptions {\n  /**\n   * Only sample from the top K options for each subsequent token.\n\nUsed to remove \"long tail\" low probability responses.\nRecommended for advanced use cases only. You usually only need to use temperature.\n\nRequired range: x >= 0\n   */\n  top_k?: number\n  /**\n   * Amount of randomness injected into the response.\n   * Either use this or top_p, but not both.\n   * Defaults to 1.0. Ranges from 0.0 to 1.0. Use temperature closer to 0.0 for analytical / multiple choice, and closer to 1.0 for creative and generative tasks.\n   * @default 1.0\n   */\n  temperature?: number\n  /**\n   * Use nucleus sampling.\n   *\n   * In nucleus sampling, we compute the cumulative distribution over all the options for each subsequent token in decreasing probability order and cut it off once it reaches a particular probability specified by top_p. You should either alter temperature or top_p, but not both.\n   */\n  top_p?: number\n  /**\n   * The maximum number of tokens to generate before stopping. This parameter only specifies the absolute maximum number of tokens to generate. Required by the API; the adapter defaults to 1024 when omitted.\n   * Range x >= 1.\n   */\n  max_tokens?: number\n}\n\nexport type ExternalTextProviderOptions = AnthropicContainerOptions &\n  AnthropicContextManagementOptions &\n  AnthropicMCPOptions &\n  AnthropicServiceTierOptions &\n  AnthropicStopSequencesOptions &\n  AnthropicThinkingOptions &\n  AnthropicToolChoiceOptions &\n  AnthropicSamplingOptions &\n  Partial<AnthropicAdaptiveThinkingOptions> &\n  Partial<AnthropicEffortOptions> &\n  Partial<AnthropicOutputConfigOptions>\n\nexport interface InternalTextProviderOptions extends ExternalTextProviderOptions {\n  model: string\n\n  messages: Array<MessageParam>\n\n  /**\n   * The maximum number of tokens to generate before stopping.  This parameter only specifies the absolute maximum number of tokens to generate.\n   * Range x >= 1.\n   */\n  max_tokens: number\n  /**\n   * Whether to incrementally stream the response using server-sent events.\n   */\n  stream?: boolean\n  /**\n   * System prompt — built by the adapter from the user-facing\n   * `systemPrompts: Array<string>` on the chat call. This field is internal:\n   * users should pass system prompts via `systemPrompts`, not via\n   * `modelOptions`.\n   *\n   * A system prompt is a way of providing context and instructions to Claude,\n   * such as specifying a particular goal or role.\n   */\n  system?: string | Array<TextBlockParam>\n\n  tools?: Array<AnthropicTool>\n\n  /**\n   * Schema-constrained final answer in a single Messages request (issue\n   * #605). Set by the engine when the adapter declared\n   * `supportsCombinedToolsAndSchema` and a caller passed `outputSchema`\n   * to `chat()`. The model emits tool calls during the agent loop and a\n   * schema-matching JSON message on the natural final turn — no separate\n   * finalization round-trip needed.\n   *\n   * The SDK type (`BetaOutputConfig`) currently exposes only `effort`;\n   * `format` is accepted at runtime per the deprecation notice on the\n   * older `output_format` field\n   * (https://platform.claude.com/docs/en/build-with-claude/structured-outputs).\n   * We type it explicitly here so the adapter call site doesn't need a\n   * cast.\n   */\n  output_config?: {\n    effort?: 'low' | 'medium' | 'high' | 'max' | null\n    format?: {\n      type: 'json_schema'\n      schema: Record<string, unknown>\n    }\n  }\n}\n\nconst validateTopPandTemperature = (options: InternalTextProviderOptions) => {\n  if (options.top_p !== undefined && options.temperature !== undefined) {\n    throw new Error('You should either set top_p or temperature, but not both.')\n  }\n}\n\nexport interface CacheControl {\n  type: 'ephemeral'\n  ttl: '5m' | '1h'\n}\n\nconst validateThinking = (options: InternalTextProviderOptions) => {\n  const thinking = options.thinking\n  if (thinking && thinking.type === 'enabled') {\n    if (thinking.budget_tokens < 1024) {\n      throw new Error('thinking.budget_tokens must be at least 1024.')\n    }\n    if (thinking.budget_tokens >= options.max_tokens) {\n      throw new Error('thinking.budget_tokens must be less than max_tokens.')\n    }\n  }\n}\n\ninterface MCPServer {\n  name: string\n  url: string\n  type: 'url'\n  authorization_token?: string | null\n  tool_configuration: {\n    allowed_tools?: Array<string> | null\n    enabled?: boolean | null\n  } | null\n}\n\nconst validateMaxTokens = (options: InternalTextProviderOptions) => {\n  if (options.max_tokens < 1) {\n    throw new Error('max_tokens must be at least 1.')\n  }\n}\n\nexport const validateTextProviderOptions = (\n  options: InternalTextProviderOptions,\n) => {\n  validateTopPandTemperature(options)\n  validateThinking(options)\n  validateMaxTokens(options)\n}\n"],"names":[],"mappings":"AA6RA,MAAM,6BAA6B,CAAC,YAAyC;AAC3E,MAAI,QAAQ,UAAU,UAAa,QAAQ,gBAAgB,QAAW;AACpE,UAAM,IAAI,MAAM,2DAA2D;AAAA,EAC7E;AACF;AAOA,MAAM,mBAAmB,CAAC,YAAyC;AACjE,QAAM,WAAW,QAAQ;AACzB,MAAI,YAAY,SAAS,SAAS,WAAW;AAC3C,QAAI,SAAS,gBAAgB,MAAM;AACjC,YAAM,IAAI,MAAM,+CAA+C;AAAA,IACjE;AACA,QAAI,SAAS,iBAAiB,QAAQ,YAAY;AAChD,YAAM,IAAI,MAAM,sDAAsD;AAAA,IACxE;AAAA,EACF;AACF;AAaA,MAAM,oBAAoB,CAAC,YAAyC;AAClE,MAAI,QAAQ,aAAa,GAAG;AAC1B,UAAM,IAAI,MAAM,gCAAgC;AAAA,EAClD;AACF;AAEO,MAAM,8BAA8B,CACzC,YACG;AACH,6BAA2B,OAAO;AAClC,mBAAiB,OAAO;AACxB,oBAAkB,OAAO;AAC3B;"}
+{"version":3,"file":"text-provider-options.js","sources":["../../../src/text/text-provider-options.ts"],"sourcesContent":["import type {\n  BetaContextManagementConfig,\n  BetaToolChoiceAny,\n  BetaToolChoiceAuto,\n  BetaToolChoiceTool,\n} from '@anthropic-ai/sdk/resources/beta/messages/messages'\nimport type { CacheControlEphemeral } from '@anthropic-ai/sdk/resources'\nimport type { AnthropicContainerSkill, AnthropicTool } from '../tools'\nimport type {\n  MessageParam,\n  TextBlockParam,\n} from '@anthropic-ai/sdk/resources/messages'\n\n/**\n * Per-prompt metadata Anthropic understands on `systemPrompts` entries.\n *\n * Used via the structured form of `systemPrompts`:\n *\n * @example\n *   import type { AnthropicSystemPromptMetadata } from '@tanstack/ai-anthropic'\n *\n *   chat({\n *     adapter: anthropicText(),\n *     model: 'claude-sonnet-4-6',\n *     systemPrompts: [\n *       {\n *         content: 'Stable instructions — cache me.',\n *         metadata: { cache_control: { type: 'ephemeral' } } satisfies AnthropicSystemPromptMetadata,\n *       },\n *       'Volatile per-request instruction.',\n *     ],\n *   })\n */\nexport interface AnthropicSystemPromptMetadata {\n  /**\n   * Anthropic prompt-caching control applied to this system prompt's\n   * `TextBlockParam`.\n   *\n   * @see https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching\n   */\n  cache_control?: CacheControlEphemeral\n}\n\nexport interface AnthropicContainerOptions {\n  /**\n   * Container identifier for reuse across requests.\n   * Container parameters with skills to be loaded.\n   */\n  container?: {\n    id: string | null\n    /**\n     * List of skills to load into the container.\n     *\n     * @deprecated Configure skills on the `code_execution` tool instead:\n     * `codeExecutionTool(config, { skills })`. The adapter lifts those into\n     * `container.skills` and attaches the required beta headers. Setting\n     * skills here bypasses the beta-header wiring and may stop working.\n     */\n    skills: Array<AnthropicContainerSkill> | null\n  } | null\n}\n\nexport interface AnthropicContextManagementOptions {\n  /**\n   * Context management configuration.\n\nThis allows you to control how Claude manages context across multiple requests, such as whether to clear function results or not.\n   */\n  context_management?: BetaContextManagementConfig | null\n}\n\nexport interface AnthropicMCPOptions {\n  /**\n   * MCP servers to be utilized in this request\n   * Maximum of 20 servers\n   */\n  mcp_servers?: Array<MCPServer>\n}\n\nexport interface AnthropicServiceTierOptions {\n  /**\n   * Determines whether to use priority capacity (if available) or standard capacity for this request.\n   */\n  service_tier?: 'auto' | 'standard_only'\n}\n\nexport interface AnthropicStopSequencesOptions {\n  /**\n   * Custom text sequences that will cause the model to stop generating.\n\nAnthropic models will normally stop when they have naturally completed their turn, which will result in a response stop_reason of \"end_turn\".\n\nIf you want the model to stop generating when it encounters custom strings of text, you can use the stop_sequences parameter. If the model encounters one of the custom sequences, the response stop_reason value will be \"stop_sequence\" and the response stop_sequence value will contain the matched stop sequence.\n   */\n  stop_sequences?: Array<string>\n}\n\nexport interface AnthropicThinkingOptions {\n  /**\n     * Configuration for enabling Claude's extended thinking.\n\nWhen enabled, responses include thinking content blocks showing Claude's thinking process before the final answer. Requires a minimum budget of 1,024 tokens and counts towards your max_tokens limit.\n     */\n  thinking?:\n    | {\n        /**\n* Determines how many tokens Claude can use for its internal reasoning process. Larger budgets can enable more thorough analysis for complex problems, improving response quality.\n\nMust be ≥1024 and less than max_tokens\n*/\n        budget_tokens: number\n\n        type: 'enabled'\n      }\n    | {\n        type: 'disabled'\n      }\n}\n\nexport interface AnthropicAdaptiveThinkingOptions {\n  /**\n   * Configuration for Claude's adaptive thinking (Opus 4.6+).\n   *\n   * In adaptive mode, Claude dynamically decides when and how much to think.\n   * Use the effort parameter to control thinking depth.\n   * `thinking: {type: \"enabled\"}` with `budget_tokens` is deprecated on Opus 4.6.\n   */\n  thinking?:\n    | {\n        type: 'adaptive'\n        /**\n         * Controls what (if any) thinking content is streamed back.\n         *\n         * - `'summarized'`: stream summarized thinking via `thinking_delta`\n         *   events (the user-visible reasoning text).\n         * - `'omitted'`: stream the thinking block's `signature_delta` only\n         *   (no reasoning text reaches the client).\n         *\n         * On Claude Opus 4.6 the default is `'summarized'`. On\n         * Claude Opus 4.7 the default flipped to `'omitted'` — callers\n         * must set `'summarized'` explicitly to get the reasoning text.\n         */\n        display?: 'summarized' | 'omitted'\n      }\n    | {\n        /**\n         * @deprecated Use `type: 'adaptive'` with the effort parameter on Opus 4.6+.\n         */\n        budget_tokens: number\n        type: 'enabled'\n      }\n    | {\n        type: 'disabled'\n      }\n}\n\n/**\n * Thinking configuration for models where thinking is always on\n * (e.g. Claude Fable 5).\n *\n * On these models the only accepted explicit configuration is\n * `{type: 'adaptive'}` — both `{type: 'disabled'}` and\n * `{type: 'enabled', budget_tokens}` are rejected with a 400. Omitting the\n * `thinking` field entirely also runs adaptive thinking.\n */\nexport interface AnthropicAdaptiveOnlyThinkingOptions {\n  thinking?: {\n    type: 'adaptive'\n    /**\n     * Controls what (if any) thinking content is streamed back.\n     *\n     * - `'summarized'`: stream summarized thinking via `thinking_delta`\n     *   events (the user-visible reasoning text).\n     * - `'omitted'` (default): stream the thinking block's\n     *   `signature_delta` only (no reasoning text reaches the client).\n     */\n    display?: 'summarized' | 'omitted'\n  }\n}\n\n/**\n * Thinking configuration for models that accept adaptive thinking or an\n * explicit opt-out, but no manual token budget (e.g. Claude Sonnet 5,\n * Claude Opus 4.7/4.8).\n *\n * `{type: 'enabled', budget_tokens}` is rejected with a 400 on these\n * models. On Claude Sonnet 5, omitting the `thinking` field runs adaptive\n * thinking by default; on Opus 4.7/4.8 it runs without thinking — set\n * `{type: 'adaptive'}` explicitly there.\n */\nexport interface AnthropicAdaptiveOrDisabledThinkingOptions {\n  thinking?:\n    | {\n        type: 'adaptive'\n        /**\n         * Controls what (if any) thinking content is streamed back.\n         * Defaults to `'omitted'` — set `'summarized'` to receive the\n         * reasoning text.\n         */\n        display?: 'summarized' | 'omitted'\n      }\n    | {\n        type: 'disabled'\n      }\n}\n\n/**\n * `max_tokens` on its own, for models that reject the sampling parameters\n * (`temperature`, `top_p`, `top_k`) — e.g. Claude Fable 5 and Claude Opus\n * 4.7/4.8 reject them outright, and Claude Sonnet 5 returns a 400 when a\n * non-default sampling value is sent.\n */\nexport interface AnthropicMaxTokensOptions {\n  /**\n   * The maximum number of tokens to generate before stopping. This parameter only specifies the absolute maximum number of tokens to generate. Required by the API; the adapter defaults to 1024 when omitted.\n   * Range x >= 1.\n   */\n  max_tokens?: number\n}\n\nexport interface AnthropicEffortOptions {\n  /**\n   * Controls the thinking depth for adaptive thinking mode (Opus 4.6+).\n   *\n   * - `max`: Absolute highest capability\n   * - `high`: Default - Claude will almost always think\n   * - `medium`: Balanced cost-quality\n   * - `low`: May skip thinking for simpler problems\n   */\n  effort?: 'max' | 'high' | 'medium' | 'low'\n}\n\nexport interface AnthropicOutputConfigOptions {\n  /**\n   * Output configuration for the model's response.\n   *\n   * On Claude 4.7+ the top-level `effort` field was relocated under\n   * `output_config.effort`, and `thinking: { type: 'enabled', budget_tokens }`\n   * was replaced by `thinking: { type: 'adaptive' }` paired with\n   * `output_config.effort`. Earlier models continue to accept the legacy\n   * top-level `effort` / `thinking.type: 'enabled'` shape.\n   *\n   * The engine also writes `output_config.format` here when the caller\n   * passes `outputSchema` to a Claude 4.5+ adapter (issue #605 native\n   * combined mode). Both fields coexist: user-supplied `effort` is\n   * preserved when the engine adds `format`.\n   */\n  output_config?: {\n    /**\n     * `'xhigh'` is accepted on Claude Opus 4.7+, Claude Sonnet 5, and\n     * Claude Fable 5; older models support `'low'`–`'max'` only.\n     */\n    effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max' | null\n  }\n}\n\nexport interface AnthropicToolChoiceOptions {\n  tool_choice?: BetaToolChoiceAny | BetaToolChoiceTool | BetaToolChoiceAuto\n}\n\nexport interface AnthropicSamplingOptions {\n  /**\n   * Only sample from the top K options for each subsequent token.\n\nUsed to remove \"long tail\" low probability responses.\nRecommended for advanced use cases only. You usually only need to use temperature.\n\nRequired range: x >= 0\n   */\n  top_k?: number\n  /**\n   * Amount of randomness injected into the response.\n   * Either use this or top_p, but not both.\n   * Defaults to 1.0. Ranges from 0.0 to 1.0. Use temperature closer to 0.0 for analytical / multiple choice, and closer to 1.0 for creative and generative tasks.\n   * @default 1.0\n   */\n  temperature?: number\n  /**\n   * Use nucleus sampling.\n   *\n   * In nucleus sampling, we compute the cumulative distribution over all the options for each subsequent token in decreasing probability order and cut it off once it reaches a particular probability specified by top_p. You should either alter temperature or top_p, but not both.\n   */\n  top_p?: number\n  /**\n   * The maximum number of tokens to generate before stopping. This parameter only specifies the absolute maximum number of tokens to generate. Required by the API; the adapter defaults to 1024 when omitted.\n   * Range x >= 1.\n   */\n  max_tokens?: number\n}\n\nexport type ExternalTextProviderOptions = AnthropicContainerOptions &\n  AnthropicContextManagementOptions &\n  AnthropicMCPOptions &\n  AnthropicServiceTierOptions &\n  AnthropicStopSequencesOptions &\n  AnthropicThinkingOptions &\n  AnthropicToolChoiceOptions &\n  AnthropicSamplingOptions &\n  Partial<AnthropicAdaptiveThinkingOptions> &\n  Partial<AnthropicEffortOptions> &\n  Partial<AnthropicOutputConfigOptions>\n\nexport interface InternalTextProviderOptions extends ExternalTextProviderOptions {\n  model: string\n\n  messages: Array<MessageParam>\n\n  /**\n   * The maximum number of tokens to generate before stopping.  This parameter only specifies the absolute maximum number of tokens to generate.\n   * Range x >= 1.\n   */\n  max_tokens: number\n  /**\n   * Whether to incrementally stream the response using server-sent events.\n   */\n  stream?: boolean\n  /**\n   * System prompt — built by the adapter from the user-facing\n   * `systemPrompts: Array<string>` on the chat call. This field is internal:\n   * users should pass system prompts via `systemPrompts`, not via\n   * `modelOptions`.\n   *\n   * A system prompt is a way of providing context and instructions to Claude,\n   * such as specifying a particular goal or role.\n   */\n  system?: string | Array<TextBlockParam>\n\n  tools?: Array<AnthropicTool>\n\n  /**\n   * Schema-constrained final answer in a single Messages request (issue\n   * #605). Set by the engine when the adapter declared\n   * `supportsCombinedToolsAndSchema` and a caller passed `outputSchema`\n   * to `chat()`. The model emits tool calls during the agent loop and a\n   * schema-matching JSON message on the natural final turn — no separate\n   * finalization round-trip needed.\n   *\n   * The SDK type (`BetaOutputConfig`) currently exposes only `effort`;\n   * `format` is accepted at runtime per the deprecation notice on the\n   * older `output_format` field\n   * (https://platform.claude.com/docs/en/build-with-claude/structured-outputs).\n   * We type it explicitly here so the adapter call site doesn't need a\n   * cast.\n   */\n  output_config?: {\n    effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max' | null\n    format?: {\n      type: 'json_schema'\n      schema: Record<string, unknown>\n    }\n  }\n}\n\nconst validateTopPandTemperature = (options: InternalTextProviderOptions) => {\n  if (options.top_p !== undefined && options.temperature !== undefined) {\n    throw new Error('You should either set top_p or temperature, but not both.')\n  }\n}\n\nexport interface CacheControl {\n  type: 'ephemeral'\n  ttl: '5m' | '1h'\n}\n\nconst validateThinking = (options: InternalTextProviderOptions) => {\n  const thinking = options.thinking\n  if (thinking && thinking.type === 'enabled') {\n    if (thinking.budget_tokens < 1024) {\n      throw new Error('thinking.budget_tokens must be at least 1024.')\n    }\n    if (thinking.budget_tokens >= options.max_tokens) {\n      throw new Error('thinking.budget_tokens must be less than max_tokens.')\n    }\n  }\n}\n\ninterface MCPServer {\n  name: string\n  url: string\n  type: 'url'\n  authorization_token?: string | null\n  tool_configuration: {\n    allowed_tools?: Array<string> | null\n    enabled?: boolean | null\n  } | null\n}\n\nconst validateMaxTokens = (options: InternalTextProviderOptions) => {\n  if (options.max_tokens < 1) {\n    throw new Error('max_tokens must be at least 1.')\n  }\n}\n\nexport const validateTextProviderOptions = (\n  options: InternalTextProviderOptions,\n) => {\n  validateTopPandTemperature(options)\n  validateThinking(options)\n  validateMaxTokens(options)\n}\n"],"names":[],"mappings":"AAiWA,MAAM,6BAA6B,CAAC,YAAyC;AAC3E,MAAI,QAAQ,UAAU,UAAa,QAAQ,gBAAgB,QAAW;AACpE,UAAM,IAAI,MAAM,2DAA2D;AAAA,EAC7E;AACF;AAOA,MAAM,mBAAmB,CAAC,YAAyC;AACjE,QAAM,WAAW,QAAQ;AACzB,MAAI,YAAY,SAAS,SAAS,WAAW;AAC3C,QAAI,SAAS,gBAAgB,MAAM;AACjC,YAAM,IAAI,MAAM,+CAA+C;AAAA,IACjE;AACA,QAAI,SAAS,iBAAiB,QAAQ,YAAY;AAChD,YAAM,IAAI,MAAM,sDAAsD;AAAA,IACxE;AAAA,EACF;AACF;AAaA,MAAM,oBAAoB,CAAC,YAAyC;AAClE,MAAI,QAAQ,aAAa,GAAG;AAC1B,UAAM,IAAI,MAAM,gCAAgC;AAAA,EAClD;AACF;AAEO,MAAM,8BAA8B,CACzC,YACG;AACH,6BAA2B,OAAO;AAClC,mBAAiB,OAAO;AACxB,oBAAkB,OAAO;AAC3B;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai-anthropic",
-  "version": "0.15.13",
+  "version": "0.16.1",
   "description": "Anthropic Claude adapter for TanStack AI chat, tool calling, thinking, and structured outputs.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -53,12 +53,12 @@
   },
   "peerDependencies": {
     "zod": "^4.0.0",
-    "@tanstack/ai": "^0.39.0"
+    "@tanstack/ai": "^0.40.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.14",
     "zod": "^4.2.0",
-    "@tanstack/ai": "0.39.0"
+    "@tanstack/ai": "0.40.0"
   },
   "scripts": {
     "build": "vite build",

package/src/adapters/summarize.ts

@@ -17,7 +17,7 @@ export type AnthropicSummarizeModel = (typeof ANTHROPIC_MODELS)[number]
  * Creates an Anthropic summarize adapter with explicit API key.
  * Type resolution happens here at the call site.
  *
- * @param model - The model name (e.g., 'claude-sonnet-4-5', 'claude-3-5-haiku-latest')
+ * @param model - The model name (e.g., 'claude-sonnet-5', 'claude-haiku-4-5')
  * @param apiKey - Your Anthropic API key
  * @param config - Optional additional configuration
  * @returns Configured Anthropic summarize adapter instance with resolved types
@@ -48,7 +48,7 @@ export function createAnthropicSummarize<
  * Creates an Anthropic summarize adapter with automatic API key detection.
  * Type resolution happens here at the call site.
  *
- * @param model - The model name (e.g., 'claude-sonnet-4-5', 'claude-3-5-haiku-latest')
+ * @param model - The model name (e.g., 'claude-sonnet-5', 'claude-haiku-4-5')
  * @param config - Optional configuration (excluding apiKey which is auto-detected)
  * @returns Configured Anthropic summarize adapter instance with resolved types
  *

package/src/adapters/text.ts

@@ -10,7 +10,10 @@ import {
   generateId,
   getAnthropicApiKeyFromEnv,
 } from '../utils'
-import { ANTHROPIC_COMBINED_TOOLS_AND_SCHEMA_MODELS } from '../model-meta'
+import {
+  ANTHROPIC_COMBINED_TOOLS_AND_SCHEMA_MODELS,
+  getAnthropicDefaultMaxTokens,
+} from '../model-meta'
 import type {
   ANTHROPIC_MODELS,
   AnthropicChatModelProviderOptionsByName,
@@ -28,11 +31,14 @@ import type {
   ContentBlockParam,
   DocumentBlockParam,
   ImageBlockParam,
+  ServerToolUseBlockParam,
   TextBlockParam,
   ThinkingBlockParam,
   ToolUseBlockParam,
   URLImageSource,
   URLPDFSource,
+  WebFetchToolResultBlockParam,
+  WebSearchToolResultBlockParam,
 } from '@anthropic-ai/sdk/resources/messages'
 import type Anthropic_SDK from '@anthropic-ai/sdk'
 import type { AnthropicBeta } from '@anthropic-ai/sdk/resources/beta/beta'
@@ -57,6 +63,83 @@ import type {
 } from '../message-types'
 import type { AnthropicClientConfig } from '../utils'
 
+/**
+ * The block type carried by an Anthropic provider-executed (server) tool's
+ * stored result. Mirrors the `*_tool_result` block emitted by the streaming
+ * API so it can be replayed verbatim into a later turn.
+ */
+type AnthropicServerToolResultBlockType =
+  | 'web_search_tool_result'
+  | 'web_fetch_tool_result'
+
+/**
+ * Anthropic payload stashed on a provider-executed tool call's `metadata`
+ * (under the `anthropic` key, alongside `providerExecuted: true`). Holds enough
+ * to reconstruct the original `server_tool_use` + `*_tool_result` blocks so the
+ * model still sees prior `web_search` / `web_fetch` evidence on the next turn.
+ */
+interface AnthropicServerToolMetadata {
+  serverToolType: ServerToolUseBlockParam['name']
+  resultBlockType: AnthropicServerToolResultBlockType
+  /** Raw result block content, preserved verbatim from the stream. */
+  result: unknown
+}
+
+/**
+ * Narrow an opaque tool-call `metadata` to {@link AnthropicServerToolMetadata}
+ * when it follows the provider-executed convention, else `null`.
+ */
+function readAnthropicServerToolMetadata(
+  metadata: unknown,
+): AnthropicServerToolMetadata | null {
+  if (typeof metadata !== 'object' || metadata === null) return null
+  const outer = metadata as { providerExecuted?: unknown; anthropic?: unknown }
+  if (outer.providerExecuted !== true) return null
+  const inner = outer.anthropic
+  if (typeof inner !== 'object' || inner === null) return null
+  const { serverToolType, resultBlockType, result } = inner as {
+    serverToolType?: unknown
+    resultBlockType?: unknown
+    result?: unknown
+  }
+  if (
+    typeof serverToolType !== 'string' ||
+    (resultBlockType !== 'web_search_tool_result' &&
+      resultBlockType !== 'web_fetch_tool_result')
+  ) {
+    return null
+  }
+  return {
+    // Validated as a string above; widen back to the SDK's tool-name union.
+    serverToolType: serverToolType as ServerToolUseBlockParam['name'],
+    resultBlockType,
+    result,
+  }
+}
+
+/**
+ * Reconstruct the `*_tool_result` block param from stored server-tool metadata.
+ * The `result` content is opaque round-trip data, asserted to the SDK's param
+ * content type at this single boundary.
+ */
+function buildServerToolResultBlock(
+  toolUseId: string,
+  meta: AnthropicServerToolMetadata,
+): WebSearchToolResultBlockParam | WebFetchToolResultBlockParam {
+  if (meta.resultBlockType === 'web_search_tool_result') {
+    return {
+      type: 'web_search_tool_result',
+      tool_use_id: toolUseId,
+      content: meta.result as WebSearchToolResultBlockParam['content'],
+    }
+  }
+  return {
+    type: 'web_fetch_tool_result',
+    tool_use_id: toolUseId,
+    content: meta.result as WebFetchToolResultBlockParam['content'],
+  }
+}
+
 /**
  * Computes the `betas` array for a Messages request. Unions:
  * - `interleaved-thinking-2025-05-14` when interleaved thinking is enabled,
@@ -263,7 +346,12 @@ export class AnthropicTextAdapter<
     const { chatOptions, outputSchema } = options
     const { logger } = chatOptions
 
-    const requestParams = this.mapCommonOptionsToAnthropic(chatOptions)
+    // `structuredOutput()` issues a non-streaming `messages.create({ stream:
+    // false })` below, so the defaulted `max_tokens` must stay under the SDK's
+    // non-streaming 10-minute guard (issue #849) — pass `stream: false`.
+    const requestParams = this.mapCommonOptionsToAnthropic(chatOptions, {
+      stream: false,
+    })
 
     // Create a tool that will capture the structured output
     // Anthropic's SDK requires input_schema with type: 'object' literal
@@ -352,6 +440,7 @@ export class AnthropicTextAdapter<
 
   private mapCommonOptionsToAnthropic(
     options: TextOptions<AnthropicTextProviderOptions>,
+    { stream = true }: { stream?: boolean } = {},
   ) {
     const modelOptions = options.modelOptions
 
@@ -420,7 +509,18 @@ export class AnthropicTextAdapter<
       validProviderOptions.thinking?.type === 'enabled'
         ? validProviderOptions.thinking.budget_tokens
         : undefined
-    const defaultMaxTokens = modelOptions?.max_tokens ?? 1024
+    // Anthropic's Messages API *requires* `max_tokens`, so we must always send a
+    // value. When the caller doesn't specify one, default to the resolved
+    // model's real output ceiling (from model-meta) rather than a low constant
+    // that silently truncates long responses with `stop_reason: "max_tokens"`
+    // (issue #849). `max_tokens` is a ceiling, not a reservation — billing is on
+    // tokens actually generated, so a higher default costs nothing extra.
+    // For non-streaming requests (the `structuredOutput()` path) the default is
+    // clamped to the SDK's non-streaming-safe limit so it doesn't trip the
+    // "streaming required" 10-minute guard — see getAnthropicDefaultMaxTokens.
+    const defaultMaxTokens =
+      modelOptions?.max_tokens ??
+      getAnthropicDefaultMaxTokens(this.model, { stream })
     const maxTokens =
       thinkingBudget && thinkingBudget >= defaultMaxTokens
         ? thinkingBudget + 1
@@ -636,6 +736,25 @@ export class AnthropicTextAdapter<
             parsedInput = toolCall.function.arguments
           }
 
+          // Provider-executed server tools (e.g. web_search) replay as the
+          // original `server_tool_use` + result blocks so the model still sees
+          // the prior evidence. Their result was captured verbatim during
+          // streaming (see processAnthropicStream).
+          const serverMeta = readAnthropicServerToolMetadata(toolCall.metadata)
+          if (serverMeta) {
+            const serverToolUseBlock: ServerToolUseBlockParam = {
+              type: 'server_tool_use',
+              id: toolCall.id,
+              name: serverMeta.serverToolType,
+              input: parsedInput,
+            }
+            contentBlocks.push(serverToolUseBlock)
+            contentBlocks.push(
+              buildServerToolResultBlock(toolCall.id, serverMeta),
+            )
+            continue
+          }
+
           const toolUseBlock: ToolUseBlockParam = {
             type: 'tool_use',
             id: toolCall.id,
@@ -806,6 +925,14 @@ export class AnthropicTextAdapter<
     // input.
     let currentServerTool: { id: string; name: string; input: string } | null =
       null
+    // Completed server tools awaiting their matching result block. Anthropic
+    // emits `server_tool_use` then a separate `*_tool_result` block; we hold
+    // the call here (keyed by id) until the result arrives so we can emit a
+    // single provider-executed tool call carrying the raw result for round-trip.
+    const completedServerTools = new Map<
+      string,
+      { id: string; name: string; input: string }
+    >()
 
     // AG-UI lifecycle tracking
     const runId = options.runId ?? genId()
@@ -881,6 +1008,61 @@ export class AnthropicTextAdapter<
                 },
               )
             }
+
+            // Emit the server tool as a single provider-executed tool call,
+            // carrying its raw result so the evidence (e.g. web_search sources)
+            // round-trips into the next turn's request. The agent loop skips
+            // provider-executed calls, so this never triggers client execution.
+            const serverTool = completedServerTools.get(
+              event.content_block.tool_use_id,
+            )
+            if (serverTool) {
+              completedServerTools.delete(serverTool.id)
+
+              let parsedInput: unknown = {}
+              try {
+                const parsed = serverTool.input
+                  ? JSON.parse(serverTool.input)
+                  : {}
+                parsedInput = parsed && typeof parsed === 'object' ? parsed : {}
+              } catch {
+                parsedInput = {}
+              }
+
+              const serverToolMetadata = {
+                providerExecuted: true,
+                anthropic: {
+                  serverToolType: serverTool.name,
+                  resultBlockType: event.content_block.type,
+                  result: content,
+                },
+              }
+
+              currentToolIndex++
+              yield {
+                type: EventType.TOOL_CALL_START,
+                toolCallId: serverTool.id,
+                toolCallName: serverTool.name,
+                toolName: serverTool.name,
+                parentMessageId: messageId,
+                model,
+                timestamp: Date.now(),
+                index: currentToolIndex,
+                metadata: serverToolMetadata,
+              }
+              yield {
+                type: EventType.TOOL_CALL_END,
+                toolCallId: serverTool.id,
+                toolCallName: serverTool.name,
+                toolName: serverTool.name,
+                model,
+                timestamp: Date.now(),
+                input: parsedInput,
+              }
+
+              // Text after the server tool starts a fresh message segment.
+              hasEmittedTextMessageStart = false
+            }
           } else if (event.content_block.type === 'thinking') {
             accumulatedThinking = ''
             accumulatedSignature = ''
@@ -1095,6 +1277,9 @@ export class AnthropicTextAdapter<
                   input: currentServerTool.input,
                 },
               )
+              // Hold the call until its result block arrives so we can emit
+              // both together as one provider-executed tool call.
+              completedServerTools.set(currentServerTool.id, currentServerTool)
             }
             currentServerTool = null
           } else if (
@@ -1181,6 +1366,22 @@ export class AnthropicTextAdapter<
                 break
               }
               case 'max_tokens': {
+                // Surface a warning when the truncating cap was the
+                // adapter-supplied default (caller didn't pass `max_tokens`), so
+                // the truncation isn't silently attributed to the model "doing
+                // nothing" (issue #849). When the caller set `max_tokens`
+                // themselves, hitting it is their own deliberate ceiling.
+                if (options.modelOptions?.max_tokens == null) {
+                  const defaultedMaxTokens = getAnthropicDefaultMaxTokens(model)
+                  logger.warn(
+                    `anthropic response truncated at the default max_tokens (${defaultedMaxTokens}) for model=${model}; pass maxTokens (or modelOptions.max_tokens) to raise the output ceiling`,
+                    {
+                      source: 'anthropic.processAnthropicStream',
+                      model,
+                      defaultedMaxTokens,
+                    },
+                  )
+                }
                 yield {
                   type: EventType.RUN_ERROR,
                   model,