@ai-sdk/anthropic 3.0.18 → 3.0.19

package/src/anthropic-prepare-tools.ts

@@ -0,0 +1,341 @@
+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_20250305ArgsSchema } from './tool/web-search_20250305';
+import { webFetch_20250910ArgsSchema } from './tool/web-fetch-20250910';
+import { validateTypes } from '@ai-sdk/provider-utils';
+
+export interface AnthropicToolOptions {
+  deferLoading?: boolean;
+  allowedCallers?: Array<'code_execution_20250825'>;
+}
+
+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;
+        const deferLoading = anthropicOptions?.deferLoading;
+        const allowedCallers = anthropicOptions?.allowedCallers;
+
+        anthropicTools.push({
+          name: tool.name,
+          description: tool.description,
+          input_schema: tool.inputSchema,
+          cache_control: cacheControl,
+          ...(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.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_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_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.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}`,
+      });
+    }
+  }
+}

package/src/anthropic-provider.test.ts

@@ -0,0 +1,162 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { LanguageModelV3Prompt } from '@ai-sdk/provider';
+import { createAnthropic } from './anthropic-provider';
+
+vi.mock('./version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+const TEST_PROMPT: LanguageModelV3Prompt = [
+  { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
+];
+
+const createSuccessfulResponse = () =>
+  new Response(
+    JSON.stringify({
+      type: 'message',
+      id: 'msg_123',
+      model: 'claude-3-haiku-20240307',
+      content: [{ type: 'text', text: 'Hi' }],
+      stop_reason: null,
+      stop_sequence: null,
+      usage: { input_tokens: 1, output_tokens: 1 },
+    }),
+    {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    },
+  );
+
+const createFetchMock = () =>
+  vi.fn().mockResolvedValue(createSuccessfulResponse());
+
+describe('createAnthropic', () => {
+  describe('baseURL configuration', () => {
+    const originalBaseUrl = process.env.ANTHROPIC_BASE_URL;
+
+    beforeEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    afterEach(() => {
+      if (originalBaseUrl === undefined) {
+        delete process.env.ANTHROPIC_BASE_URL;
+      } else {
+        process.env.ANTHROPIC_BASE_URL = originalBaseUrl;
+      }
+    });
+
+    it('uses the default Anthropic base URL when not provided', async () => {
+      delete process.env.ANTHROPIC_BASE_URL;
+
+      const fetchMock = createFetchMock();
+      const provider = createAnthropic({
+        apiKey: 'test-api-key',
+        fetch: fetchMock,
+      });
+
+      await provider('claude-3-haiku-20240307').doGenerate({
+        prompt: TEST_PROMPT,
+      });
+
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      const [requestUrl] = fetchMock.mock.calls[0]!;
+      expect(requestUrl).toBe('https://api.anthropic.com/v1/messages');
+    });
+
+    it('uses ANTHROPIC_BASE_URL when set', async () => {
+      process.env.ANTHROPIC_BASE_URL = 'https://proxy.anthropic.example/v1/';
+
+      const fetchMock = createFetchMock();
+      const provider = createAnthropic({
+        apiKey: 'test-api-key',
+        fetch: fetchMock,
+      });
+
+      await provider('claude-3-haiku-20240307').doGenerate({
+        prompt: TEST_PROMPT,
+      });
+
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      const [requestUrl] = fetchMock.mock.calls[0]!;
+      expect(requestUrl).toBe('https://proxy.anthropic.example/v1/messages');
+    });
+
+    it('prefers the baseURL option over ANTHROPIC_BASE_URL', async () => {
+      process.env.ANTHROPIC_BASE_URL = 'https://env.anthropic.example/v1';
+
+      const fetchMock = createFetchMock();
+      const provider = createAnthropic({
+        apiKey: 'test-api-key',
+        baseURL: 'https://option.anthropic.example/v1/',
+        fetch: fetchMock,
+      });
+
+      await provider('claude-3-haiku-20240307').doGenerate({
+        prompt: TEST_PROMPT,
+      });
+
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      const [requestUrl] = fetchMock.mock.calls[0]!;
+      expect(requestUrl).toBe('https://option.anthropic.example/v1/messages');
+    });
+  });
+});
+
+describe('anthropic provider - custom provider name', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should use custom provider name when specified', () => {
+    const provider = createAnthropic({
+      name: 'my-claude-proxy',
+      apiKey: 'test-api-key',
+    });
+
+    const model = provider('claude-3-haiku-20240307');
+    expect(model.provider).toBe('my-claude-proxy');
+  });
+
+  it('should default to anthropic.messages when name not specified', () => {
+    const provider = createAnthropic({
+      apiKey: 'test-api-key',
+    });
+
+    const model = provider('claude-3-haiku-20240307');
+    expect(model.provider).toBe('anthropic.messages');
+  });
+});
+
+describe('anthropic provider - supportedUrls', () => {
+  it('should support image/* URLs', async () => {
+    const provider = createAnthropic({
+      apiKey: 'test-api-key',
+    });
+
+    const model = provider('claude-3-haiku-20240307');
+    const supportedUrls = await model.supportedUrls;
+
+    expect(supportedUrls['image/*']).toBeDefined();
+    expect(
+      supportedUrls['image/*']![0]!.test('https://example.com/image.png'),
+    ).toBe(true);
+  });
+
+  it('should support application/pdf URLs', async () => {
+    const provider = createAnthropic({
+      apiKey: 'test-api-key',
+    });
+
+    const model = provider('claude-3-haiku-20240307');
+    const supportedUrls = await model.supportedUrls;
+
+    expect(supportedUrls['application/pdf']).toBeDefined();
+    expect(
+      supportedUrls['application/pdf']![0]!.test(
+        'https://arxiv.org/pdf/2401.00001',
+      ),
+    ).toBe(true);
+  });
+});

package/src/anthropic-provider.ts

@@ -0,0 +1,152 @@
+import {
+  LanguageModelV3,
+  NoSuchModelError,
+  ProviderV3,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  generateId,
+  loadApiKey,
+  loadOptionalSetting,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { VERSION } from './version';
+import { AnthropicMessagesLanguageModel } from './anthropic-messages-language-model';
+import { AnthropicMessagesModelId } from './anthropic-messages-options';
+import { anthropicTools } from './anthropic-tools';
+
+export interface AnthropicProvider extends ProviderV3 {
+  /**
+Creates a model for text generation.
+*/
+  (modelId: AnthropicMessagesModelId): LanguageModelV3;
+
+  /**
+Creates a model for text generation.
+*/
+  languageModel(modelId: AnthropicMessagesModelId): LanguageModelV3;
+
+  chat(modelId: AnthropicMessagesModelId): LanguageModelV3;
+
+  messages(modelId: AnthropicMessagesModelId): LanguageModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: string): never;
+
+  /**
+Anthropic-specific computer use tool.
+   */
+  tools: typeof anthropicTools;
+}
+
+export interface AnthropicProviderSettings {
+  /**
+Use a different URL prefix for API calls, e.g. to use proxy servers.
+The default prefix is `https://api.anthropic.com/v1`.
+   */
+  baseURL?: string;
+
+  /**
+API key that is being send using the `x-api-key` header.
+It defaults to the `ANTHROPIC_API_KEY` environment variable.
+   */
+  apiKey?: string;
+
+  /**
+Custom headers to include in the requests.
+     */
+  headers?: Record<string, string>;
+
+  /**
+Custom fetch implementation. You can use it as a middleware to intercept requests,
+or to provide a custom fetch implementation for e.g. testing.
+    */
+  fetch?: FetchFunction;
+
+  generateId?: () => string;
+
+  /**
+   * Custom provider name
+   * Defaults to 'anthropic.messages'.
+   */
+  name?: string;
+}
+
+/**
+Create an Anthropic provider instance.
+ */
+export function createAnthropic(
+  options: AnthropicProviderSettings = {},
+): AnthropicProvider {
+  const baseURL =
+    withoutTrailingSlash(
+      loadOptionalSetting({
+        settingValue: options.baseURL,
+        environmentVariableName: 'ANTHROPIC_BASE_URL',
+      }),
+    ) ?? 'https://api.anthropic.com/v1';
+
+  const providerName = options.name ?? 'anthropic.messages';
+
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        'anthropic-version': '2023-06-01',
+        'x-api-key': loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'ANTHROPIC_API_KEY',
+          description: 'Anthropic',
+        }),
+        ...options.headers,
+      },
+      `ai-sdk/anthropic/${VERSION}`,
+    );
+
+  const createChatModel = (modelId: AnthropicMessagesModelId) =>
+    new AnthropicMessagesLanguageModel(modelId, {
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      generateId: options.generateId ?? generateId,
+      supportedUrls: () => ({
+        'image/*': [/^https?:\/\/.*$/],
+        'application/pdf': [/^https?:\/\/.*$/],
+      }),
+    });
+
+  const provider = function (modelId: AnthropicMessagesModelId) {
+    if (new.target) {
+      throw new Error(
+        'The Anthropic model function cannot be called with the new keyword.',
+      );
+    }
+
+    return createChatModel(modelId);
+  };
+
+  provider.specificationVersion = 'v3' as const;
+  provider.languageModel = createChatModel;
+  provider.chat = createChatModel;
+  provider.messages = createChatModel;
+
+  provider.embeddingModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'embeddingModel' });
+  };
+  provider.textEmbeddingModel = provider.embeddingModel;
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
+  };
+
+  provider.tools = anthropicTools;
+
+  return provider;
+}
+
+/**
+Default Anthropic provider instance.
+ */
+export const anthropic = createAnthropic();