@fairyhunter13/ai-anthropic 3.0.58-fork.1

package/src/anthropic-messages-options.ts

@@ -0,0 +1,267 @@
+import { z } from 'zod/v4';
+
+// https://docs.claude.com/en/docs/about-claude/models/overview
+export type AnthropicMessagesModelId =
+  | 'claude-3-haiku-20240307'
+  | 'claude-haiku-4-5-20251001'
+  | 'claude-haiku-4-5'
+  | 'claude-opus-4-0'
+  | 'claude-opus-4-20250514'
+  | 'claude-opus-4-1-20250805'
+  | 'claude-opus-4-1'
+  | 'claude-opus-4-5'
+  | 'claude-opus-4-5-20251101'
+  | 'claude-sonnet-4-0'
+  | 'claude-sonnet-4-20250514'
+  | 'claude-sonnet-4-5-20250929'
+  | 'claude-sonnet-4-5'
+  | 'claude-sonnet-4-6'
+  | 'claude-opus-4-6'
+  | (string & {});
+
+/**
+ * Anthropic file part provider options for document-specific features.
+ * These options apply to individual file parts (documents).
+ */
+export const anthropicFilePartProviderOptions = z.object({
+  /**
+   * Citation configuration for this document.
+   * When enabled, this document will generate citations in the response.
+   */
+  citations: z
+    .object({
+      /**
+       * Enable citations for this document
+       */
+      enabled: z.boolean(),
+    })
+    .optional(),
+
+  /**
+   * Custom title for the document.
+   * If not provided, the filename will be used.
+   */
+  title: z.string().optional(),
+
+  /**
+   * Context about the document that will be passed to the model
+   * but not used towards cited content.
+   * Useful for storing document metadata as text or stringified JSON.
+   */
+  context: z.string().optional(),
+});
+
+export type AnthropicFilePartProviderOptions = z.infer<
+  typeof anthropicFilePartProviderOptions
+>;
+
+export const anthropicLanguageModelOptions = z.object({
+  /**
+   * Whether to send reasoning to the model.
+   *
+   * This allows you to deactivate reasoning inputs for models that do not support them.
+   */
+  sendReasoning: z.boolean().optional(),
+
+  /**
+   * Determines how structured outputs are generated.
+   *
+   * - `outputFormat`: Use the `output_config.format` parameter to specify the structured output format.
+   * - `jsonTool`: Use a special 'json' tool to specify the structured output format.
+   * - `auto`: Use 'outputFormat' when supported, otherwise use 'jsonTool' (default).
+   */
+  structuredOutputMode: z.enum(['outputFormat', 'jsonTool', 'auto']).optional(),
+
+  /**
+   * 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 the `max_tokens` limit.
+   */
+  thinking: z
+    .discriminatedUnion('type', [
+      z.object({
+        /** for Sonnet 4.6, Opus 4.6, and newer models */
+        type: z.literal('adaptive'),
+        /**
+         * Controls thinking output visibility.
+         * - 'omitted': thinking happens but output is not returned (faster TTFT)
+         * - 'summarized': a summary of the thinking is returned
+         */
+        display: z.enum(['omitted', 'summarized']).optional(),
+      }),
+      z.object({
+        /** for models before Opus 4.6, except Sonnet 4.6 still supports it */
+        type: z.literal('enabled'),
+        budgetTokens: z.number().optional(),
+        /**
+         * Controls thinking output visibility.
+         * - 'omitted': thinking happens but output is not returned (faster TTFT)
+         * - 'summarized': a summary of the thinking is returned
+         */
+        display: z.enum(['omitted', 'summarized']).optional(),
+      }),
+      z.object({
+        type: z.literal('disabled'),
+      }),
+    ])
+    .optional(),
+
+  /**
+   * Whether to disable parallel function calling during tool use. Default is false.
+   * When set to true, Claude will use at most one tool per response.
+   */
+  disableParallelToolUse: z.boolean().optional(),
+
+  /**
+   * Cache control settings for this message.
+   * See https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
+   */
+  cacheControl: z
+    .object({
+      type: z.literal('ephemeral'),
+      ttl: z.union([z.literal('5m'), z.literal('1h')]).optional(),
+    })
+    .optional(),
+
+  /**
+   * MCP servers to be utilized in this request.
+   */
+  mcpServers: z
+    .array(
+      z.object({
+        type: z.literal('url'),
+        name: z.string(),
+        url: z.string(),
+        authorizationToken: z.string().nullish(),
+        toolConfiguration: z
+          .object({
+            enabled: z.boolean().nullish(),
+            allowedTools: z.array(z.string()).nullish(),
+          })
+          .nullish(),
+      }),
+    )
+    .optional(),
+
+  /**
+   * Agent Skills configuration. Skills enable Claude to perform specialized tasks
+   * like document processing (PPTX, DOCX, PDF, XLSX) and data analysis.
+   * Requires code execution tool to be enabled.
+   */
+  container: z
+    .object({
+      id: z.string().optional(),
+      skills: z
+        .array(
+          z.object({
+            type: z.union([z.literal('anthropic'), z.literal('custom')]),
+            skillId: z.string(),
+            version: z.string().optional(),
+          }),
+        )
+        .optional(),
+    })
+    .optional(),
+
+  /**
+   * Whether to enable tool streaming (and structured output streaming).
+   *
+   * When set to false, the model will return all tool calls and results
+   * at once after a delay.
+   *
+   * @default true
+   */
+  toolStreaming: z.boolean().optional(),
+
+  /**
+   * @default 'high'
+   */
+  effort: z.enum(['low', 'medium', 'high', 'max']).optional(),
+
+  /**
+   * Enable fast mode for faster inference (2.5x faster output token speeds).
+   * Only supported with claude-opus-4-6.
+   */
+  speed: z.enum(['fast', 'standard']).optional(),
+
+  /**
+   * A set of beta features to enable.
+   * Allow a provider to receive the full `betas` set if it needs it.
+   */
+  anthropicBeta: z.array(z.string()).optional(),
+
+  /**
+   * Assistant prefill text. When set, this text is appended as a partial
+   * assistant message at the end of the prompt, guiding the model's output.
+   * The model will continue generating from where the prefill ends.
+   *
+   * Example: Setting prefill to '{"' will make the model start its response with '{"'
+   */
+  prefill: z.string().optional(),
+
+  contextManagement: z
+    .object({
+      edits: z.array(
+        z.discriminatedUnion('type', [
+          z.object({
+            type: z.literal('clear_tool_uses_20250919'),
+            trigger: z
+              .discriminatedUnion('type', [
+                z.object({
+                  type: z.literal('input_tokens'),
+                  value: z.number(),
+                }),
+                z.object({
+                  type: z.literal('tool_uses'),
+                  value: z.number(),
+                }),
+              ])
+              .optional(),
+            keep: z
+              .object({
+                type: z.literal('tool_uses'),
+                value: z.number(),
+              })
+              .optional(),
+            clearAtLeast: z
+              .object({
+                type: z.literal('input_tokens'),
+                value: z.number(),
+              })
+              .optional(),
+            clearToolInputs: z.boolean().optional(),
+            excludeTools: z.array(z.string()).optional(),
+          }),
+          z.object({
+            type: z.literal('clear_thinking_20251015'),
+            keep: z
+              .union([
+                z.literal('all'),
+                z.object({
+                  type: z.literal('thinking_turns'),
+                  value: z.number(),
+                }),
+              ])
+              .optional(),
+          }),
+          z.object({
+            type: z.literal('compact_20260112'),
+            trigger: z
+              .object({
+                type: z.literal('input_tokens'),
+                value: z.number(),
+              })
+              .optional(),
+            pauseAfterCompaction: z.boolean().optional(),
+            instructions: z.string().optional(),
+          }),
+        ]),
+      ),
+    })
+    .optional(),
+});
+
+export type AnthropicLanguageModelOptions = z.infer<
+  typeof anthropicLanguageModelOptions
+>;

package/src/anthropic-prepare-tools.ts

@@ -0,0 +1,404 @@
+import {
+  LanguageModelV3CallOptions,
+  SharedV3Warning,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import { AnthropicTool, AnthropicToolChoice } from './anthropic-messages-api';
+import { CacheControlValidator } from './get-cache-control';
+import { textEditor_20250728ArgsSchema } from './tool/text-editor_20250728';
+import { webSearch_20260209ArgsSchema } from './tool/web-search_20260209';
+import { webSearch_20250305ArgsSchema } from './tool/web-search_20250305';
+import { webFetch_20260209ArgsSchema } from './tool/web-fetch-20260209';
+import { webFetch_20250910ArgsSchema } from './tool/web-fetch-20250910';
+import { validateTypes } from '@ai-sdk/provider-utils';
+
+export interface AnthropicToolOptions {
+  deferLoading?: boolean;
+  allowedCallers?: Array<
+    'direct' | 'code_execution_20250825' | 'code_execution_20260120'
+  >;
+  eagerInputStreaming?: boolean;
+}
+
+export async function prepareTools({
+  tools,
+  toolChoice,
+  disableParallelToolUse,
+  cacheControlValidator,
+  supportsStructuredOutput,
+}: {
+  tools: LanguageModelV3CallOptions['tools'];
+  toolChoice: LanguageModelV3CallOptions['toolChoice'] | undefined;
+  disableParallelToolUse?: boolean;
+  cacheControlValidator?: CacheControlValidator;
+
+  /**
+   * Whether the model supports structured output.
+   */
+  supportsStructuredOutput: boolean;
+}): Promise<{
+  tools: Array<AnthropicTool> | undefined;
+  toolChoice: AnthropicToolChoice | undefined;
+  toolWarnings: SharedV3Warning[];
+  betas: Set<string>;
+}> {
+  // when the tools array is empty, change it to undefined to prevent errors:
+  tools = tools?.length ? tools : undefined;
+
+  const toolWarnings: SharedV3Warning[] = [];
+  const betas = new Set<string>();
+  const validator = cacheControlValidator || new CacheControlValidator();
+
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings, betas };
+  }
+
+  const anthropicTools: AnthropicTool[] = [];
+
+  for (const tool of tools) {
+    switch (tool.type) {
+      case 'function': {
+        const cacheControl = validator.getCacheControl(tool.providerOptions, {
+          type: 'tool definition',
+          canCache: true,
+        });
+
+        // Read Anthropic-specific provider options
+        const anthropicOptions = tool.providerOptions?.anthropic as
+          | AnthropicToolOptions
+          | undefined;
+        // eager_input_streaming is only supported on custom (function) tools
+        const eagerInputStreaming = anthropicOptions?.eagerInputStreaming;
+        const deferLoading = anthropicOptions?.deferLoading;
+        const allowedCallers = anthropicOptions?.allowedCallers;
+
+        anthropicTools.push({
+          name: tool.name,
+          description: tool.description,
+          input_schema: tool.inputSchema,
+          cache_control: cacheControl,
+          ...(eagerInputStreaming ? { eager_input_streaming: true } : {}),
+          ...(supportsStructuredOutput === true && tool.strict != null
+            ? { strict: tool.strict }
+            : {}),
+          ...(deferLoading != null ? { defer_loading: deferLoading } : {}),
+          ...(allowedCallers != null
+            ? { allowed_callers: allowedCallers }
+            : {}),
+          ...(tool.inputExamples != null
+            ? {
+                input_examples: tool.inputExamples.map(
+                  example => example.input,
+                ),
+              }
+            : {}),
+        });
+
+        if (supportsStructuredOutput === true) {
+          betas.add('structured-outputs-2025-11-13');
+        }
+
+        if (tool.inputExamples != null || allowedCallers != null) {
+          betas.add('advanced-tool-use-2025-11-20');
+        }
+
+        break;
+      }
+
+      case 'provider': {
+        // Note: Provider-defined tools don't currently support providerOptions in the SDK,
+        // so cache_control cannot be set on them. The Anthropic API supports caching all tools,
+        // but the SDK would need to be updated to expose providerOptions on provider-defined tools.
+        switch (tool.id) {
+          case 'anthropic.code_execution_20250522': {
+            betas.add('code-execution-2025-05-22');
+            anthropicTools.push({
+              type: 'code_execution_20250522',
+              name: 'code_execution',
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.code_execution_20250825': {
+            betas.add('code-execution-2025-08-25');
+            anthropicTools.push({
+              type: 'code_execution_20250825',
+              name: 'code_execution',
+            });
+            break;
+          }
+          case 'anthropic.code_execution_20260120': {
+            anthropicTools.push({
+              type: 'code_execution_20260120',
+              name: 'code_execution',
+            });
+            break;
+          }
+          case 'anthropic.computer_20250124': {
+            betas.add('computer-use-2025-01-24');
+            anthropicTools.push({
+              name: 'computer',
+              type: 'computer_20250124',
+              display_width_px: tool.args.displayWidthPx as number,
+              display_height_px: tool.args.displayHeightPx as number,
+              display_number: tool.args.displayNumber as number,
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.computer_20251124': {
+            betas.add('computer-use-2025-11-24');
+            anthropicTools.push({
+              name: 'computer',
+              type: 'computer_20251124',
+              display_width_px: tool.args.displayWidthPx as number,
+              display_height_px: tool.args.displayHeightPx as number,
+              display_number: tool.args.displayNumber as number,
+              enable_zoom: tool.args.enableZoom as boolean,
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.computer_20241022': {
+            betas.add('computer-use-2024-10-22');
+            anthropicTools.push({
+              name: 'computer',
+              type: 'computer_20241022',
+              display_width_px: tool.args.displayWidthPx as number,
+              display_height_px: tool.args.displayHeightPx as number,
+              display_number: tool.args.displayNumber as number,
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.text_editor_20250124': {
+            betas.add('computer-use-2025-01-24');
+            anthropicTools.push({
+              name: 'str_replace_editor',
+              type: 'text_editor_20250124',
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.text_editor_20241022': {
+            betas.add('computer-use-2024-10-22');
+            anthropicTools.push({
+              name: 'str_replace_editor',
+              type: 'text_editor_20241022',
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.text_editor_20250429': {
+            betas.add('computer-use-2025-01-24');
+            anthropicTools.push({
+              name: 'str_replace_based_edit_tool',
+              type: 'text_editor_20250429',
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.text_editor_20250728': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: textEditor_20250728ArgsSchema,
+            });
+            anthropicTools.push({
+              name: 'str_replace_based_edit_tool',
+              type: 'text_editor_20250728',
+              max_characters: args.maxCharacters,
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.bash_20250124': {
+            betas.add('computer-use-2025-01-24');
+            anthropicTools.push({
+              name: 'bash',
+              type: 'bash_20250124',
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.bash_20241022': {
+            betas.add('computer-use-2024-10-22');
+            anthropicTools.push({
+              name: 'bash',
+              type: 'bash_20241022',
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.memory_20250818': {
+            betas.add('context-management-2025-06-27');
+            anthropicTools.push({
+              name: 'memory',
+              type: 'memory_20250818',
+            });
+            break;
+          }
+          case 'anthropic.web_fetch_20250910': {
+            betas.add('web-fetch-2025-09-10');
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webFetch_20250910ArgsSchema,
+            });
+            anthropicTools.push({
+              type: 'web_fetch_20250910',
+              name: 'web_fetch',
+              max_uses: args.maxUses,
+              allowed_domains: args.allowedDomains,
+              blocked_domains: args.blockedDomains,
+              citations: args.citations,
+              max_content_tokens: args.maxContentTokens,
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.web_fetch_20260209': {
+            betas.add('code-execution-web-tools-2026-02-09');
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webFetch_20260209ArgsSchema,
+            });
+            anthropicTools.push({
+              type: 'web_fetch_20260209',
+              name: 'web_fetch',
+              max_uses: args.maxUses,
+              allowed_domains: args.allowedDomains,
+              blocked_domains: args.blockedDomains,
+              citations: args.citations,
+              max_content_tokens: args.maxContentTokens,
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.web_search_20250305': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webSearch_20250305ArgsSchema,
+            });
+            anthropicTools.push({
+              type: 'web_search_20250305',
+              name: 'web_search',
+              max_uses: args.maxUses,
+              allowed_domains: args.allowedDomains,
+              blocked_domains: args.blockedDomains,
+              user_location: args.userLocation,
+              cache_control: undefined,
+            });
+            break;
+          }
+          case 'anthropic.web_search_20260209': {
+            betas.add('code-execution-web-tools-2026-02-09');
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webSearch_20260209ArgsSchema,
+            });
+            anthropicTools.push({
+              type: 'web_search_20260209',
+              name: 'web_search',
+              max_uses: args.maxUses,
+              allowed_domains: args.allowedDomains,
+              blocked_domains: args.blockedDomains,
+              user_location: args.userLocation,
+              cache_control: undefined,
+            });
+            break;
+          }
+
+          case 'anthropic.tool_search_regex_20251119': {
+            betas.add('advanced-tool-use-2025-11-20');
+            anthropicTools.push({
+              type: 'tool_search_tool_regex_20251119',
+              name: 'tool_search_tool_regex',
+            });
+            break;
+          }
+
+          case 'anthropic.tool_search_bm25_20251119': {
+            betas.add('advanced-tool-use-2025-11-20');
+            anthropicTools.push({
+              type: 'tool_search_tool_bm25_20251119',
+              name: 'tool_search_tool_bm25',
+            });
+            break;
+          }
+
+          default: {
+            toolWarnings.push({
+              type: 'unsupported',
+              feature: `provider-defined tool ${tool.id}`,
+            });
+            break;
+          }
+        }
+        break;
+      }
+
+      default: {
+        toolWarnings.push({
+          type: 'unsupported',
+          feature: `tool ${tool}`,
+        });
+        break;
+      }
+    }
+  }
+
+  if (toolChoice == null) {
+    return {
+      tools: anthropicTools,
+      toolChoice: disableParallelToolUse
+        ? { type: 'auto', disable_parallel_tool_use: disableParallelToolUse }
+        : undefined,
+      toolWarnings,
+      betas,
+    };
+  }
+
+  const type = toolChoice.type;
+
+  switch (type) {
+    case 'auto':
+      return {
+        tools: anthropicTools,
+        toolChoice: {
+          type: 'auto',
+          disable_parallel_tool_use: disableParallelToolUse,
+        },
+        toolWarnings,
+        betas,
+      };
+    case 'required':
+      return {
+        tools: anthropicTools,
+        toolChoice: {
+          type: 'any',
+          disable_parallel_tool_use: disableParallelToolUse,
+        },
+        toolWarnings,
+        betas,
+      };
+    case 'none':
+      // Anthropic does not support 'none' tool choice, so we remove the tools:
+      return { tools: undefined, toolChoice: undefined, toolWarnings, betas };
+    case 'tool':
+      return {
+        tools: anthropicTools,
+        toolChoice: {
+          type: 'tool',
+          name: toolChoice.toolName,
+          disable_parallel_tool_use: disableParallelToolUse,
+        },
+        toolWarnings,
+        betas,
+      };
+    default: {
+      const _exhaustiveCheck: never = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`,
+      });
+    }
+  }
+}