@tanstack/ai-anthropic 0.15.9 → 0.15.10

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

@@ -0,0 +1,258 @@
+import { BetaContextManagementConfig, BetaToolChoiceAny, BetaToolChoiceAuto, BetaToolChoiceTool } from '@anthropic-ai/sdk/resources/beta/messages/messages';
+import { CacheControlEphemeral } from '@anthropic-ai/sdk/resources';
+import { AnthropicContainerSkill, AnthropicTool } from '../tools.js';
+import { MessageParam, TextBlockParam } from '@anthropic-ai/sdk/resources/messages';
+/**
+ * Per-prompt metadata Anthropic understands on `systemPrompts` entries.
+ *
+ * Used via the structured form of `systemPrompts`:
+ *
+ * @example
+ *   import type { AnthropicSystemPromptMetadata } from '@tanstack/ai-anthropic'
+ *
+ *   chat({
+ *     adapter: anthropicText(),
+ *     model: 'claude-sonnet-4-6',
+ *     systemPrompts: [
+ *       {
+ *         content: 'Stable instructions — cache me.',
+ *         metadata: { cache_control: { type: 'ephemeral' } } satisfies AnthropicSystemPromptMetadata,
+ *       },
+ *       'Volatile per-request instruction.',
+ *     ],
+ *   })
+ */
+export interface AnthropicSystemPromptMetadata {
+    /**
+     * Anthropic prompt-caching control applied to this system prompt's
+     * `TextBlockParam`.
+     *
+     * @see https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
+     */
+    cache_control?: CacheControlEphemeral;
+}
+export interface AnthropicContainerOptions {
+    /**
+     * Container identifier for reuse across requests.
+     * Container parameters with skills to be loaded.
+     */
+    container?: {
+        id: string | null;
+        /**
+         * List of skills to load into the container.
+         *
+         * @deprecated Configure skills on the `code_execution` tool instead:
+         * `codeExecutionTool(config, { skills })`. The adapter lifts those into
+         * `container.skills` and attaches the required beta headers. Setting
+         * skills here bypasses the beta-header wiring and may stop working.
+         */
+        skills: Array<AnthropicContainerSkill> | null;
+    } | null;
+}
+export interface AnthropicContextManagementOptions {
+    /**
+     * Context management configuration.
+  
+  This allows you to control how Claude manages context across multiple requests, such as whether to clear function results or not.
+     */
+    context_management?: BetaContextManagementConfig | null;
+}
+export interface AnthropicMCPOptions {
+    /**
+     * MCP servers to be utilized in this request
+     * Maximum of 20 servers
+     */
+    mcp_servers?: Array<MCPServer>;
+}
+export interface AnthropicServiceTierOptions {
+    /**
+     * Determines whether to use priority capacity (if available) or standard capacity for this request.
+     */
+    service_tier?: 'auto' | 'standard_only';
+}
+export interface AnthropicStopSequencesOptions {
+    /**
+     * Custom text sequences that will cause the model to stop generating.
+  
+  Anthropic models will normally stop when they have naturally completed their turn, which will result in a response stop_reason of "end_turn".
+  
+  If 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.
+     */
+    stop_sequences?: Array<string>;
+}
+export interface AnthropicThinkingOptions {
+    /**
+       * Configuration for enabling Claude's extended thinking.
+  
+  When 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.
+       */
+    thinking?: {
+        /**
+* 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.
+
+Must be ≥1024 and less than max_tokens
+*/
+        budget_tokens: number;
+        type: 'enabled';
+    } | {
+        type: 'disabled';
+    };
+}
+export interface AnthropicAdaptiveThinkingOptions {
+    /**
+     * Configuration for Claude's adaptive thinking (Opus 4.6+).
+     *
+     * In adaptive mode, Claude dynamically decides when and how much to think.
+     * Use the effort parameter to control thinking depth.
+     * `thinking: {type: "enabled"}` with `budget_tokens` is deprecated on Opus 4.6.
+     */
+    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'`: stream the thinking block's `signature_delta` only
+         *   (no reasoning text reaches the client).
+         *
+         * On Claude Opus 4.6 the default is `'summarized'`. On
+         * Claude Opus 4.7 the default flipped to `'omitted'` — callers
+         * must set `'summarized'` explicitly to get the reasoning text.
+         */
+        display?: 'summarized' | 'omitted';
+    } | {
+        /**
+         * @deprecated Use `type: 'adaptive'` with the effort parameter on Opus 4.6+.
+         */
+        budget_tokens: number;
+        type: 'enabled';
+    } | {
+        type: 'disabled';
+    };
+}
+export interface AnthropicEffortOptions {
+    /**
+     * Controls the thinking depth for adaptive thinking mode (Opus 4.6+).
+     *
+     * - `max`: Absolute highest capability
+     * - `high`: Default - Claude will almost always think
+     * - `medium`: Balanced cost-quality
+     * - `low`: May skip thinking for simpler problems
+     */
+    effort?: 'max' | 'high' | 'medium' | 'low';
+}
+export interface AnthropicOutputConfigOptions {
+    /**
+     * Output configuration for the model's response.
+     *
+     * On Claude 4.7+ the top-level `effort` field was relocated under
+     * `output_config.effort`, and `thinking: { type: 'enabled', budget_tokens }`
+     * was replaced by `thinking: { type: 'adaptive' }` paired with
+     * `output_config.effort`. Earlier models continue to accept the legacy
+     * top-level `effort` / `thinking.type: 'enabled'` shape.
+     *
+     * The engine also writes `output_config.format` here when the caller
+     * passes `outputSchema` to a Claude 4.5+ adapter (issue #605 native
+     * combined mode). Both fields coexist: user-supplied `effort` is
+     * preserved when the engine adds `format`.
+     */
+    output_config?: {
+        effort?: 'low' | 'medium' | 'high' | 'max' | null;
+    };
+}
+export interface AnthropicToolChoiceOptions {
+    tool_choice?: BetaToolChoiceAny | BetaToolChoiceTool | BetaToolChoiceAuto;
+}
+export interface AnthropicSamplingOptions {
+    /**
+     * Only sample from the top K options for each subsequent token.
+  
+  Used to remove "long tail" low probability responses.
+  Recommended for advanced use cases only. You usually only need to use temperature.
+  
+  Required range: x >= 0
+     */
+    top_k?: number;
+    /**
+     * Amount of randomness injected into the response.
+     * Either use this or top_p, but not both.
+     * 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.
+     * @default 1.0
+     */
+    temperature?: number;
+    /**
+     * Use nucleus sampling.
+     *
+     * 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.
+     */
+    top_p?: number;
+    /**
+     * 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 type ExternalTextProviderOptions = AnthropicContainerOptions & AnthropicContextManagementOptions & AnthropicMCPOptions & AnthropicServiceTierOptions & AnthropicStopSequencesOptions & AnthropicThinkingOptions & AnthropicToolChoiceOptions & AnthropicSamplingOptions & Partial<AnthropicAdaptiveThinkingOptions> & Partial<AnthropicEffortOptions> & Partial<AnthropicOutputConfigOptions>;
+export interface InternalTextProviderOptions extends ExternalTextProviderOptions {
+    model: string;
+    messages: Array<MessageParam>;
+    /**
+     * The maximum number of tokens to generate before stopping.  This parameter only specifies the absolute maximum number of tokens to generate.
+     * Range x >= 1.
+     */
+    max_tokens: number;
+    /**
+     * Whether to incrementally stream the response using server-sent events.
+     */
+    stream?: boolean;
+    /**
+     * System prompt — built by the adapter from the user-facing
+     * `systemPrompts: Array<string>` on the chat call. This field is internal:
+     * users should pass system prompts via `systemPrompts`, not via
+     * `modelOptions`.
+     *
+     * A system prompt is a way of providing context and instructions to Claude,
+     * such as specifying a particular goal or role.
+     */
+    system?: string | Array<TextBlockParam>;
+    tools?: Array<AnthropicTool>;
+    /**
+     * Schema-constrained final answer in a single Messages request (issue
+     * #605). Set by the engine when the adapter declared
+     * `supportsCombinedToolsAndSchema` and a caller passed `outputSchema`
+     * to `chat()`. The model emits tool calls during the agent loop and a
+     * schema-matching JSON message on the natural final turn — no separate
+     * finalization round-trip needed.
+     *
+     * The SDK type (`BetaOutputConfig`) currently exposes only `effort`;
+     * `format` is accepted at runtime per the deprecation notice on the
+     * older `output_format` field
+     * (https://platform.claude.com/docs/en/build-with-claude/structured-outputs).
+     * We type it explicitly here so the adapter call site doesn't need a
+     * cast.
+     */
+    output_config?: {
+        effort?: 'low' | 'medium' | 'high' | 'max' | null;
+        format?: {
+            type: 'json_schema';
+            schema: Record<string, unknown>;
+        };
+    };
+}
+export interface CacheControl {
+    type: 'ephemeral';
+    ttl: '5m' | '1h';
+}
+interface MCPServer {
+    name: string;
+    url: string;
+    type: 'url';
+    authorization_token?: string | null;
+    tool_configuration: {
+        allowed_tools?: Array<string> | null;
+        enabled?: boolean | null;
+    } | null;
+}
+export declare const validateTextProviderOptions: (options: InternalTextProviderOptions) => void;
+export {};

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

@@ -0,0 +1,30 @@
+const validateTopPandTemperature = (options) => {
+  if (options.top_p !== void 0 && options.temperature !== void 0) {
+    throw new Error("You should either set top_p or temperature, but not both.");
+  }
+};
+const validateThinking = (options) => {
+  const thinking = options.thinking;
+  if (thinking && thinking.type === "enabled") {
+    if (thinking.budget_tokens < 1024) {
+      throw new Error("thinking.budget_tokens must be at least 1024.");
+    }
+    if (thinking.budget_tokens >= options.max_tokens) {
+      throw new Error("thinking.budget_tokens must be less than max_tokens.");
+    }
+  }
+};
+const validateMaxTokens = (options) => {
+  if (options.max_tokens < 1) {
+    throw new Error("max_tokens must be at least 1.");
+  }
+};
+const validateTextProviderOptions = (options) => {
+  validateTopPandTemperature(options);
+  validateThinking(options);
+  validateMaxTokens(options);
+};
+export {
+  validateTextProviderOptions
+};
+//# sourceMappingURL=text-provider-options.js.map

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

@@ -0,0 +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;"}

package/dist/esm/tools/bash-tool.d.ts

@@ -0,0 +1,8 @@
+import { BetaToolBash20241022, BetaToolBash20250124 } from '@anthropic-ai/sdk/resources/beta';
+import { ProviderTool, Tool } from '@tanstack/ai';
+export type BashToolConfig = BetaToolBash20241022 | BetaToolBash20250124;
+/** @deprecated Renamed to `BashToolConfig`. Will be removed in a future release. */
+export type BashTool = BashToolConfig;
+export type AnthropicBashTool = ProviderTool<'anthropic', 'bash'>;
+export declare function convertBashToolToAdapterFormat(tool: Tool): BashToolConfig;
+export declare function bashTool(config: BashToolConfig): AnthropicBashTool;

package/dist/esm/tools/bash-tool.js

@@ -0,0 +1,17 @@
+import { brandProviderTool } from "@tanstack/ai";
+function convertBashToolToAdapterFormat(tool) {
+  const metadata = tool.metadata;
+  return metadata;
+}
+function bashTool(config) {
+  return brandProviderTool({
+    name: "bash",
+    description: "",
+    metadata: config
+  });
+}
+export {
+  bashTool,
+  convertBashToolToAdapterFormat
+};
+//# sourceMappingURL=bash-tool.js.map

package/dist/esm/tools/bash-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash-tool.js","sources":["../../../src/tools/bash-tool.ts"],"sourcesContent":["import { brandProviderTool } from '@tanstack/ai'\nimport type {\n  BetaToolBash20241022,\n  BetaToolBash20250124,\n} from '@anthropic-ai/sdk/resources/beta'\nimport type { ProviderTool, Tool } from '@tanstack/ai'\n\nexport type BashToolConfig = BetaToolBash20241022 | BetaToolBash20250124\n\n/** @deprecated Renamed to `BashToolConfig`. Will be removed in a future release. */\nexport type BashTool = BashToolConfig\n\nexport type AnthropicBashTool = ProviderTool<'anthropic', 'bash'>\n\nexport function convertBashToolToAdapterFormat(tool: Tool): BashToolConfig {\n  const metadata = tool.metadata as BashToolConfig\n  return metadata\n}\n\nexport function bashTool(config: BashToolConfig): AnthropicBashTool {\n  return brandProviderTool<AnthropicBashTool>({\n    name: 'bash',\n    description: '',\n    metadata: config,\n  })\n}\n"],"names":[],"mappings":";AAcO,SAAS,+BAA+B,MAA4B;AACzE,QAAM,WAAW,KAAK;AACtB,SAAO;AACT;AAEO,SAAS,SAAS,QAA2C;AAClE,SAAO,kBAAqC;AAAA,IAC1C,MAAM;AAAA,IACN,aAAa;AAAA,IACb,UAAU;AAAA,EAAA,CACX;AACH;"}

package/dist/esm/tools/code-execution-tool.d.ts

@@ -0,0 +1,34 @@
+import { BetaCodeExecutionTool20250522, BetaCodeExecutionTool20250825 } from '@anthropic-ai/sdk/resources/beta';
+import { ProviderTool, Tool } from '@tanstack/ai';
+export type CodeExecutionToolConfig = BetaCodeExecutionTool20250522 | BetaCodeExecutionTool20250825;
+/** @deprecated Renamed to `CodeExecutionToolConfig`. Will be removed in a future release. */
+export type CodeExecutionTool = CodeExecutionToolConfig;
+/**
+ * A hosted/managed Anthropic Skill reference. Lifted by the text adapter into
+ * the top-level `container.skills` request param (NOT serialized into the
+ * `tools[]` entry). Requires the `code_execution` tool to be enabled.
+ */
+export interface AnthropicContainerSkill {
+    /** 1–64 characters. */
+    skill_id: string;
+    type: 'anthropic' | 'custom';
+    /** Skill version, or `'latest'` (default) when omitted. */
+    version?: string;
+}
+export interface CodeExecutionToolOptions {
+    /** Hosted skills to load into the code-execution container (max 8). */
+    skills?: Array<AnthropicContainerSkill>;
+}
+export type AnthropicCodeExecutionTool = ProviderTool<'anthropic', 'code_execution'>;
+export declare function convertCodeExecutionToolToAdapterFormat(tool: Tool): CodeExecutionToolConfig;
+/**
+ * Reads the SDK tool config attached to a `code_execution` tool, if any.
+ * Used by the text adapter to select the version-aware code-execution beta.
+ */
+export declare function readCodeExecutionConfig(tool: Tool): CodeExecutionToolConfig | undefined;
+/**
+ * Reads the hosted skills attached to a `code_execution` tool, if any.
+ * Used by the text adapter to build the top-level `container.skills` param.
+ */
+export declare function readCodeExecutionSkills(tool: Tool): Array<AnthropicContainerSkill> | undefined;
+export declare function codeExecutionTool(config: CodeExecutionToolConfig, options?: CodeExecutionToolOptions): AnthropicCodeExecutionTool;

package/dist/esm/tools/code-execution-tool.js

@@ -0,0 +1,39 @@
+import { brandProviderTool } from "@tanstack/ai";
+function convertCodeExecutionToolToAdapterFormat(tool) {
+  return readCodeExecutionConfig(tool);
+}
+function readCodeExecutionConfig(tool) {
+  return tool.metadata?.config;
+}
+function readCodeExecutionSkills(tool) {
+  return tool.metadata?.skills;
+}
+function codeExecutionTool(config, options = {}) {
+  const { skills } = options;
+  if (skills) {
+    if (skills.length > 8) {
+      throw new Error("code_execution supports at most 8 skills per request.");
+    }
+    for (const skill of skills) {
+      if (skill.skill_id.length < 1 || skill.skill_id.length > 64) {
+        throw new Error("skill_id must be between 1 and 64 characters.");
+      }
+    }
+  }
+  const metadata = {
+    config,
+    ...skills && { skills }
+  };
+  return brandProviderTool({
+    name: "code_execution",
+    description: "",
+    metadata
+  });
+}
+export {
+  codeExecutionTool,
+  convertCodeExecutionToolToAdapterFormat,
+  readCodeExecutionConfig,
+  readCodeExecutionSkills
+};
+//# sourceMappingURL=code-execution-tool.js.map

package/dist/esm/tools/code-execution-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-execution-tool.js","sources":["../../../src/tools/code-execution-tool.ts"],"sourcesContent":["import { brandProviderTool } from '@tanstack/ai'\nimport type {\n  BetaCodeExecutionTool20250522,\n  BetaCodeExecutionTool20250825,\n} from '@anthropic-ai/sdk/resources/beta'\nimport type { ProviderTool, Tool } from '@tanstack/ai'\n\nexport type CodeExecutionToolConfig =\n  | BetaCodeExecutionTool20250522\n  | BetaCodeExecutionTool20250825\n\n/** @deprecated Renamed to `CodeExecutionToolConfig`. Will be removed in a future release. */\nexport type CodeExecutionTool = CodeExecutionToolConfig\n\n/**\n * A hosted/managed Anthropic Skill reference. Lifted by the text adapter into\n * the top-level `container.skills` request param (NOT serialized into the\n * `tools[]` entry). Requires the `code_execution` tool to be enabled.\n */\nexport interface AnthropicContainerSkill {\n  /** 1–64 characters. */\n  skill_id: string\n  type: 'anthropic' | 'custom'\n  /** Skill version, or `'latest'` (default) when omitted. */\n  version?: string\n}\n\nexport interface CodeExecutionToolOptions {\n  /** Hosted skills to load into the code-execution container (max 8). */\n  skills?: Array<AnthropicContainerSkill>\n}\n\ninterface CodeExecutionToolMetadata {\n  config: CodeExecutionToolConfig\n  skills?: Array<AnthropicContainerSkill>\n}\n\nexport type AnthropicCodeExecutionTool = ProviderTool<\n  'anthropic',\n  'code_execution'\n>\n\nexport function convertCodeExecutionToolToAdapterFormat(\n  tool: Tool,\n): CodeExecutionToolConfig {\n  // The converter is only called for real `code_execution` tools, so a\n  // non-undefined config is expected — but read via optional chaining so an\n  // absent metadata object doesn't throw.\n  return readCodeExecutionConfig(tool) as CodeExecutionToolConfig\n}\n\n/**\n * Reads the SDK tool config attached to a `code_execution` tool, if any.\n * Used by the text adapter to select the version-aware code-execution beta.\n */\nexport function readCodeExecutionConfig(\n  tool: Tool,\n): CodeExecutionToolConfig | undefined {\n  return (tool.metadata as CodeExecutionToolMetadata | undefined)?.config\n}\n\n/**\n * Reads the hosted skills attached to a `code_execution` tool, if any.\n * Used by the text adapter to build the top-level `container.skills` param.\n */\nexport function readCodeExecutionSkills(\n  tool: Tool,\n): Array<AnthropicContainerSkill> | undefined {\n  return (tool.metadata as CodeExecutionToolMetadata | undefined)?.skills\n}\n\nexport function codeExecutionTool(\n  config: CodeExecutionToolConfig,\n  options: CodeExecutionToolOptions = {},\n): AnthropicCodeExecutionTool {\n  const { skills } = options\n  if (skills) {\n    if (skills.length > 8) {\n      throw new Error('code_execution supports at most 8 skills per request.')\n    }\n    for (const skill of skills) {\n      if (skill.skill_id.length < 1 || skill.skill_id.length > 64) {\n        throw new Error('skill_id must be between 1 and 64 characters.')\n      }\n    }\n  }\n  const metadata: CodeExecutionToolMetadata = {\n    config,\n    ...(skills && { skills }),\n  }\n  return brandProviderTool<AnthropicCodeExecutionTool>({\n    name: 'code_execution',\n    description: '',\n    metadata,\n  })\n}\n"],"names":[],"mappings":";AA0CO,SAAS,wCACd,MACyB;AAIzB,SAAO,wBAAwB,IAAI;AACrC;AAMO,SAAS,wBACd,MACqC;AACrC,SAAQ,KAAK,UAAoD;AACnE;AAMO,SAAS,wBACd,MAC4C;AAC5C,SAAQ,KAAK,UAAoD;AACnE;AAEO,SAAS,kBACd,QACA,UAAoC,IACR;AAC5B,QAAM,EAAE,WAAW;AACnB,MAAI,QAAQ;AACV,QAAI,OAAO,SAAS,GAAG;AACrB,YAAM,IAAI,MAAM,uDAAuD;AAAA,IACzE;AACA,eAAW,SAAS,QAAQ;AAC1B,UAAI,MAAM,SAAS,SAAS,KAAK,MAAM,SAAS,SAAS,IAAI;AAC3D,cAAM,IAAI,MAAM,+CAA+C;AAAA,MACjE;AAAA,IACF;AAAA,EACF;AACA,QAAM,WAAsC;AAAA,IAC1C;AAAA,IACA,GAAI,UAAU,EAAE,OAAA;AAAA,EAAO;AAEzB,SAAO,kBAA8C;AAAA,IACnD,MAAM;AAAA,IACN,aAAa;AAAA,IACb;AAAA,EAAA,CACD;AACH;"}

package/dist/esm/tools/computer-use-tool.d.ts

@@ -0,0 +1,8 @@
+import { BetaToolComputerUse20241022, BetaToolComputerUse20250124 } from '@anthropic-ai/sdk/resources/beta';
+import { ProviderTool, Tool } from '@tanstack/ai';
+export type ComputerUseToolConfig = BetaToolComputerUse20241022 | BetaToolComputerUse20250124;
+/** @deprecated Renamed to `ComputerUseToolConfig`. Will be removed in a future release. */
+export type ComputerUseTool = ComputerUseToolConfig;
+export type AnthropicComputerUseTool = ProviderTool<'anthropic', 'computer_use'>;
+export declare function convertComputerUseToolToAdapterFormat(tool: Tool): ComputerUseToolConfig;
+export declare function computerUseTool(config: ComputerUseToolConfig): AnthropicComputerUseTool;

package/dist/esm/tools/computer-use-tool.js

@@ -0,0 +1,17 @@
+import { brandProviderTool } from "@tanstack/ai";
+function convertComputerUseToolToAdapterFormat(tool) {
+  const metadata = tool.metadata;
+  return metadata;
+}
+function computerUseTool(config) {
+  return brandProviderTool({
+    name: "computer",
+    description: "",
+    metadata: config
+  });
+}
+export {
+  computerUseTool,
+  convertComputerUseToolToAdapterFormat
+};
+//# sourceMappingURL=computer-use-tool.js.map

package/dist/esm/tools/computer-use-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computer-use-tool.js","sources":["../../../src/tools/computer-use-tool.ts"],"sourcesContent":["import { brandProviderTool } from '@tanstack/ai'\nimport type {\n  BetaToolComputerUse20241022,\n  BetaToolComputerUse20250124,\n} from '@anthropic-ai/sdk/resources/beta'\nimport type { ProviderTool, Tool } from '@tanstack/ai'\n\nexport type ComputerUseToolConfig =\n  | BetaToolComputerUse20241022\n  | BetaToolComputerUse20250124\n\n/** @deprecated Renamed to `ComputerUseToolConfig`. Will be removed in a future release. */\nexport type ComputerUseTool = ComputerUseToolConfig\n\nexport type AnthropicComputerUseTool = ProviderTool<'anthropic', 'computer_use'>\n\nexport function convertComputerUseToolToAdapterFormat(\n  tool: Tool,\n): ComputerUseToolConfig {\n  const metadata = tool.metadata as ComputerUseToolConfig\n  return metadata\n}\n\nexport function computerUseTool(\n  config: ComputerUseToolConfig,\n): AnthropicComputerUseTool {\n  return brandProviderTool<AnthropicComputerUseTool>({\n    name: 'computer',\n    description: '',\n    metadata: config,\n  })\n}\n"],"names":[],"mappings":";AAgBO,SAAS,sCACd,MACuB;AACvB,QAAM,WAAW,KAAK;AACtB,SAAO;AACT;AAEO,SAAS,gBACd,QAC0B;AAC1B,SAAO,kBAA4C;AAAA,IACjD,MAAM;AAAA,IACN,aAAa;AAAA,IACb,UAAU;AAAA,EAAA,CACX;AACH;"}

package/dist/esm/tools/custom-tool.d.ts

@@ -0,0 +1,26 @@
+import { SchemaInput, Tool } from '@tanstack/ai';
+import { CacheControl } from '../text/text-provider-options.js';
+export interface CustomToolConfig {
+    /**
+     * The name of the tool.
+     */
+    name: string;
+    type: 'custom';
+    /**
+     * A brief description of what the tool does. Tool descriptions should be as detailed as possible. The more information that the model has about what the tool is and how to use it, the better it will perform. You can use natural language descriptions to reinforce important aspects of the tool input JSON schema.
+     */
+    description: string;
+    /**
+     * This defines the shape of the input that your tool accepts and that the model will produce.
+     */
+    input_schema: {
+        type: 'object';
+        properties: Record<string, any> | null;
+        required?: Array<string> | null;
+    };
+    cache_control?: CacheControl | null;
+}
+/** @deprecated Renamed to `CustomToolConfig`. Will be removed in a future release. */
+export type CustomTool = CustomToolConfig;
+export declare function convertCustomToolToAdapterFormat(tool: Tool): CustomToolConfig;
+export declare function customTool(name: string, description: string, inputSchema: SchemaInput, cacheControl?: CacheControl | null): Tool;

package/dist/esm/tools/custom-tool.js

@@ -0,0 +1,34 @@
+function convertCustomToolToAdapterFormat(tool) {
+  const metadata = tool.metadata || {};
+  const jsonSchema = tool.inputSchema ?? {
+    properties: {},
+    required: []
+  };
+  const inputSchema = {
+    type: "object",
+    properties: jsonSchema.properties || null,
+    required: jsonSchema.required || null
+  };
+  return {
+    name: tool.name,
+    type: "custom",
+    description: tool.description,
+    input_schema: inputSchema,
+    cache_control: metadata.cacheControl || null
+  };
+}
+function customTool(name, description, inputSchema, cacheControl) {
+  return {
+    name,
+    description,
+    inputSchema,
+    metadata: {
+      cacheControl
+    }
+  };
+}
+export {
+  convertCustomToolToAdapterFormat,
+  customTool
+};
+//# sourceMappingURL=custom-tool.js.map

package/dist/esm/tools/custom-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-tool.js","sources":["../../../src/tools/custom-tool.ts"],"sourcesContent":["import type { JSONSchema, SchemaInput, Tool } from '@tanstack/ai'\nimport type { CacheControl } from '../text/text-provider-options'\n\nexport interface CustomToolConfig {\n  /**\n   * The name of the tool.\n   */\n  name: string\n  type: 'custom'\n  /**\n   * A brief description of what the tool does. Tool descriptions should be as detailed as possible. The more information that the model has about what the tool is and how to use it, the better it will perform. You can use natural language descriptions to reinforce important aspects of the tool input JSON schema.\n   */\n  description: string\n  /**\n   * This defines the shape of the input that your tool accepts and that the model will produce.\n   */\n  input_schema: {\n    type: 'object'\n    properties: Record<string, any> | null\n    required?: Array<string> | null\n  }\n\n  cache_control?: CacheControl | null\n}\n\n/** @deprecated Renamed to `CustomToolConfig`. Will be removed in a future release. */\nexport type CustomTool = CustomToolConfig\n\nexport function convertCustomToolToAdapterFormat(tool: Tool): CustomToolConfig {\n  const metadata =\n    (tool.metadata as { cacheControl?: CacheControl | null } | undefined) || {}\n\n  const jsonSchema = (tool.inputSchema ?? {\n    type: 'object',\n    properties: {},\n    required: [],\n  }) as JSONSchema\n\n  const inputSchema = {\n    type: 'object' as const,\n    properties: jsonSchema.properties || null,\n    required: jsonSchema.required || null,\n  }\n\n  return {\n    name: tool.name,\n    type: 'custom',\n    description: tool.description,\n    input_schema: inputSchema,\n    cache_control: metadata.cacheControl || null,\n  }\n}\n\nexport function customTool(\n  name: string,\n  description: string,\n  inputSchema: SchemaInput,\n  cacheControl?: CacheControl | null,\n): Tool {\n  return {\n    name,\n    description,\n    inputSchema,\n    metadata: {\n      cacheControl,\n    },\n  }\n}\n"],"names":[],"mappings":"AA4BO,SAAS,iCAAiC,MAA8B;AAC7E,QAAM,WACH,KAAK,YAAmE,CAAA;AAE3E,QAAM,aAAc,KAAK,eAAe;AAAA,IAEtC,YAAY,CAAA;AAAA,IACZ,UAAU,CAAA;AAAA,EAAC;AAGb,QAAM,cAAc;AAAA,IAClB,MAAM;AAAA,IACN,YAAY,WAAW,cAAc;AAAA,IACrC,UAAU,WAAW,YAAY;AAAA,EAAA;AAGnC,SAAO;AAAA,IACL,MAAM,KAAK;AAAA,IACX,MAAM;AAAA,IACN,aAAa,KAAK;AAAA,IAClB,cAAc;AAAA,IACd,eAAe,SAAS,gBAAgB;AAAA,EAAA;AAE5C;AAEO,SAAS,WACd,MACA,aACA,aACA,cACM;AACN,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU;AAAA,MACR;AAAA,IAAA;AAAA,EACF;AAEJ;"}

package/dist/esm/tools/index.d.ts

@@ -0,0 +1,17 @@
+import { BashTool } from './bash-tool.js';
+import { CodeExecutionTool } from './code-execution-tool.js';
+import { ComputerUseTool } from './computer-use-tool.js';
+import { CustomTool } from './custom-tool.js';
+import { MemoryTool } from './memory-tool.js';
+import { TextEditorTool } from './text-editor-tool.js';
+import { WebFetchTool } from './web-fetch-tool.js';
+import { WebSearchTool } from './web-search-tool.js';
+export { bashTool, type AnthropicBashTool, type BashToolConfig, type BashTool, } from './bash-tool.js';
+export { codeExecutionTool, convertCodeExecutionToolToAdapterFormat, readCodeExecutionConfig, readCodeExecutionSkills, type AnthropicCodeExecutionTool, type AnthropicContainerSkill, type CodeExecutionToolConfig, type CodeExecutionToolOptions, type CodeExecutionTool, } from './code-execution-tool.js';
+export { computerUseTool, type AnthropicComputerUseTool, type ComputerUseToolConfig, type ComputerUseTool, } from './computer-use-tool.js';
+export { customTool, type CustomToolConfig, type CustomTool, } from './custom-tool.js';
+export { memoryTool, type AnthropicMemoryTool, type MemoryToolConfig, type MemoryTool, } from './memory-tool.js';
+export { textEditorTool, type AnthropicTextEditorTool, type TextEditorToolConfig, type TextEditorTool, } from './text-editor-tool.js';
+export { webFetchTool, type AnthropicWebFetchTool, type WebFetchToolConfig, type WebFetchTool, } from './web-fetch-tool.js';
+export { webSearchTool, type AnthropicWebSearchTool, type WebSearchToolConfig, type WebSearchTool, } from './web-search-tool.js';
+export type AnthropicTool = BashTool | CodeExecutionTool | ComputerUseTool | CustomTool | MemoryTool | TextEditorTool | WebFetchTool | WebSearchTool;

package/dist/esm/tools/index.js

@@ -0,0 +1,22 @@
+import { bashTool } from "./bash-tool.js";
+import { codeExecutionTool, convertCodeExecutionToolToAdapterFormat, readCodeExecutionConfig, readCodeExecutionSkills } from "./code-execution-tool.js";
+import { computerUseTool } from "./computer-use-tool.js";
+import { customTool } from "./custom-tool.js";
+import { memoryTool } from "./memory-tool.js";
+import { textEditorTool } from "./text-editor-tool.js";
+import { webFetchTool } from "./web-fetch-tool.js";
+import { webSearchTool } from "./web-search-tool.js";
+export {
+  bashTool,
+  codeExecutionTool,
+  computerUseTool,
+  convertCodeExecutionToolToAdapterFormat,
+  customTool,
+  memoryTool,
+  readCodeExecutionConfig,
+  readCodeExecutionSkills,
+  textEditorTool,
+  webFetchTool,
+  webSearchTool
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/tools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/dist/esm/tools/memory-tool.d.ts

@@ -0,0 +1,8 @@
+import { BetaMemoryTool20250818 } from '@anthropic-ai/sdk/resources/beta';
+import { ProviderTool, Tool } from '@tanstack/ai';
+export type MemoryToolConfig = BetaMemoryTool20250818;
+/** @deprecated Renamed to `MemoryToolConfig`. Will be removed in a future release. */
+export type MemoryTool = MemoryToolConfig;
+export type AnthropicMemoryTool = ProviderTool<'anthropic', 'memory'>;
+export declare function convertMemoryToolToAdapterFormat(tool: Tool): MemoryToolConfig;
+export declare function memoryTool(config?: MemoryToolConfig): AnthropicMemoryTool;

package/dist/esm/tools/memory-tool.js

@@ -0,0 +1,20 @@
+import { brandProviderTool } from "@tanstack/ai";
+function convertMemoryToolToAdapterFormat(tool) {
+  const metadata = tool.metadata;
+  return {
+    type: "memory_20250818",
+    ...metadata
+  };
+}
+function memoryTool(config) {
+  return brandProviderTool({
+    name: "memory",
+    description: "",
+    metadata: config
+  });
+}
+export {
+  convertMemoryToolToAdapterFormat,
+  memoryTool
+};
+//# sourceMappingURL=memory-tool.js.map

package/dist/esm/tools/memory-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-tool.js","sources":["../../../src/tools/memory-tool.ts"],"sourcesContent":["import { brandProviderTool } from '@tanstack/ai'\nimport type { BetaMemoryTool20250818 } from '@anthropic-ai/sdk/resources/beta'\nimport type { ProviderTool, Tool } from '@tanstack/ai'\n\nexport type MemoryToolConfig = BetaMemoryTool20250818\n\n/** @deprecated Renamed to `MemoryToolConfig`. Will be removed in a future release. */\nexport type MemoryTool = MemoryToolConfig\n\nexport type AnthropicMemoryTool = ProviderTool<'anthropic', 'memory'>\n\nexport function convertMemoryToolToAdapterFormat(tool: Tool): MemoryToolConfig {\n  const metadata = tool.metadata as Omit<MemoryToolConfig, 'type'>\n  return {\n    type: 'memory_20250818',\n    ...metadata,\n  }\n}\n\nexport function memoryTool(config?: MemoryToolConfig): AnthropicMemoryTool {\n  return brandProviderTool<AnthropicMemoryTool>({\n    name: 'memory',\n    description: '',\n    metadata: config,\n  })\n}\n"],"names":[],"mappings":";AAWO,SAAS,iCAAiC,MAA8B;AAC7E,QAAM,WAAW,KAAK;AACtB,SAAO;AAAA,IACL,MAAM;AAAA,IACN,GAAG;AAAA,EAAA;AAEP;AAEO,SAAS,WAAW,QAAgD;AACzE,SAAO,kBAAuC;AAAA,IAC5C,MAAM;AAAA,IACN,aAAa;AAAA,IACb,UAAU;AAAA,EAAA,CACX;AACH;"}

package/dist/esm/tools/text-editor-tool.d.ts

@@ -0,0 +1,8 @@
+import { ToolTextEditor20250124, ToolTextEditor20250429, ToolTextEditor20250728 } from '@anthropic-ai/sdk/resources/messages';
+import { ProviderTool, Tool } from '@tanstack/ai';
+export type TextEditorToolConfig = ToolTextEditor20250124 | ToolTextEditor20250429 | ToolTextEditor20250728;
+/** @deprecated Renamed to `TextEditorToolConfig`. Will be removed in a future release. */
+export type TextEditorTool = TextEditorToolConfig;
+export type AnthropicTextEditorTool = ProviderTool<'anthropic', 'text_editor'>;
+export declare function convertTextEditorToolToAdapterFormat(tool: Tool): TextEditorToolConfig;
+export declare function textEditorTool<T extends TextEditorToolConfig>(config: T): AnthropicTextEditorTool;