Anthropic Provider

1
import { anthropic } from '@ai-sdk/anthropic';

1
import { createAnthropic } from '@ai-sdk/anthropic';
2

3
const anthropic = createAnthropic({
4
  // custom settings
5
});

1
const model = anthropic('claude-3-haiku-20240307');

1
import { anthropic } from '@ai-sdk/anthropic';
2
import { generateText } from 'ai';
3

4
const { text } = await generateText({
5
  model: anthropic('claude-3-haiku-20240307'),
6
  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
7
});

1
import { anthropic } from '@ai-sdk/anthropic';
2
import { streamText, tool } from 'ai';
3
import { z } from 'zod';
4

5
const result = streamText({
6
  model: anthropic('claude-sonnet-4-20250514'),
7
  tools: {
8
    writeFile: tool({
9
      description: 'Write content to a file',
10
      inputSchema: z.object({
11
        path: z.string(),
12
        content: z.string(),
13
      }),
14
      execute: async ({ path, content }) => {
15
        // Implementation
16
        return { success: true };
17
      },
18
    }),
19
  },
20
  prompt: 'Write a short story to story.txt',
21
});

1
import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic';
2
import { generateText } from 'ai';
3

4
const { text, usage } = await generateText({
5
  model: anthropic('claude-opus-4-20250514'),
6
  prompt: 'How many people will live in the world in 2040?',
7
  providerOptions: {
8
    anthropic: {
9
      effort: 'low',
10
    } satisfies AnthropicProviderOptions,
11
  },
12
});
13

14
console.log(text); // resulting text
15
console.log(usage); // token usage

1
import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic';
2
import { generateText } from 'ai';
3

4
const { text, reasoningText, reasoning } = await generateText({
5
  model: anthropic('claude-opus-4-20250514'),
6
  prompt: 'How many people will live in the world in 2040?',
7
  providerOptions: {
8
    anthropic: {
9
      thinking: { type: 'enabled', budgetTokens: 12000 },
10
    } satisfies AnthropicProviderOptions,
11
  },
12
});
13

14
console.log(reasoningText); // reasoning text
15
console.log(reasoning); // reasoning details including redacted reasoning
16
console.log(text); // text response

1
import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic';
2
import { generateText } from 'ai';
3

4
const result = await generateText({
5
  model: anthropic('claude-3-7-sonnet-20250219'),
6
  prompt: 'Continue our conversation...',
7
  providerOptions: {
8
    anthropic: {
9
      contextManagement: {
10
        edits: [
11
          {
12
            type: 'clear_tool_uses_20250919',
13
            trigger: { type: 'input_tokens', value: 10000 },
14
            keep: { type: 'tool_uses', value: 5 },
15
            clearAtLeast: { type: 'input_tokens', value: 1000 },
16
            clearToolInputs: true,
17
            excludeTools: ['important_tool'],
18
          },
19
        ],
20
      },
21
    } satisfies AnthropicProviderOptions,
22
  },
23
});
24

25
// Check what was cleared
26
console.log(result.providerMetadata?.anthropic?.contextManagement);

1
const result = await generateText({
2
  model: anthropic('claude-opus-4-20250514'),
3
  prompt: 'Continue reasoning...',
4
  providerOptions: {
5
    anthropic: {
6
      thinking: { type: 'enabled', budgetTokens: 12000 },
7
      contextManagement: {
8
        edits: [
9
          {
10
            type: 'clear_thinking_20251015',
11
            keep: { type: 'thinking_turns', value: 2 },
12
          },
13
        ],
14
      },
15
    } satisfies AnthropicProviderOptions,
16
  },
17
});

1
const metadata = result.providerMetadata?.anthropic?.contextManagement;
2

3
if (metadata?.appliedEdits) {
4
  metadata.appliedEdits.forEach(edit => {
5
    if (edit.type === 'clear_tool_uses_20250919') {
6
      console.log(`Cleared ${edit.clearedToolUses} tool uses`);
7
      console.log(`Freed ${edit.clearedInputTokens} tokens`);
8
    } else if (edit.type === 'clear_thinking_20251015') {
9
      console.log(`Cleared ${edit.clearedThinkingTurns} thinking turns`);
10
      console.log(`Freed ${edit.clearedInputTokens} tokens`);
11
    }
12
  });
13
}

1
import { anthropic } from '@ai-sdk/anthropic';
2
import { generateText } from 'ai';
3

4
const errorMessage = '... long error message ...';
5

6
const result = await generateText({
7
  model: anthropic('claude-3-5-sonnet-20240620'),
8
  messages: [
9
    {
10
      role: 'user',
11
      content: [
12
        { type: 'text', text: 'You are a JavaScript expert.' },
13
        {
14
          type: 'text',
15
          text: `Error message: ${errorMessage}`,
16
          providerOptions: {
17
            anthropic: { cacheControl: { type: 'ephemeral' } },
18
          },
19
        },
20
        { type: 'text', text: 'Explain the error message.' },
21
      ],
22
    },
23
  ],
24
});
25

26
console.log(result.text);
27
console.log(result.providerMetadata?.anthropic);
28
// e.g. { cacheCreationInputTokens: 2118 }

1
const result = await generateText({
2
  model: anthropic('claude-3-5-sonnet-20240620'),
3
  messages: [
4
    {
5
      role: 'system',
6
      content: 'Cached system message part',
7
      providerOptions: {
8
        anthropic: { cacheControl: { type: 'ephemeral' } },
9
      },
10
    },
11
    {
12
      role: 'system',
13
      content: 'Uncached system message part',
14
    },
15
    {
16
      role: 'user',
17
      content: 'User prompt',
18
    },
19
  ],
20
});

1
const result = await generateText({
2
  model: anthropic('claude-3-5-haiku-latest'),
3
  tools: {
4
    cityAttractions: tool({
5
      inputSchema: z.object({ city: z.string() }),
6
      providerOptions: {
7
        anthropic: {
8
          cacheControl: { type: 'ephemeral' },
9
        },
10
      },
11
    }),
12
  },
13
  messages: [
14
    {
15
      role: 'user',
16
      content: 'User prompt',
17
    },
18
  ],
19
});

1
const result = await generateText({
2
  model: anthropic('claude-3-5-haiku-latest'),
3
  messages: [
4
    {
5
      role: 'user',
6
      content: [
7
        {
8
          type: 'text',
9
          text: 'Long cached message',
10
          providerOptions: {
11
            anthropic: {
12
              cacheControl: { type: 'ephemeral', ttl: '1h' },
13
            },
14
          },
15
        },
16
      ],
17
    },
18
  ],
19
});

1
const bashTool = anthropic.tools.bash_20241022({
2
  execute: async ({ command, restart }) => {
3
    // Implement your bash command execution logic here
4
    // Return the result of the command execution
5
  },
6
});

1
const memory = anthropic.tools.memory_20250818({
2
  execute: async action => {
3
    // Implement your memory command execution logic here
4
    // Return the result of the command execution
5
  },
6
});

1
const tools = {
2
  str_replace_based_edit_tool: anthropic.tools.textEditor_20250728({
3
    maxCharacters: 10000, // optional
4
    async execute({ command, path, old_str, new_str }) {
5
      // ...
6
    },
7
  }),
8
} satisfies ToolSet;

1
const computerTool = anthropic.tools.computer_20241022({
2
  displayWidthPx: 1920,
3
  displayHeightPx: 1080,
4
  displayNumber: 0, // Optional, for X11 environments
5

6
  execute: async ({ action, coordinate, text }) => {
7
    // Implement your computer control logic here
8
    // Return the result of the action
9

10
    // Example code:
11
    switch (action) {
12
      case 'screenshot': {
13
        // multipart result:
14
        return {
15
          type: 'image',
16
          data: fs
17
            .readFileSync('./data/screenshot-editor.png')
18
            .toString('base64'),
19
        };
20
      }
21
      default: {
22
        console.log('Action:', action);
23
        console.log('Coordinate:', coordinate);
24
        console.log('Text:', text);
25
        return `executed ${action}`;
26
      }
27
    }
28
  },
29

30
  // map to tool result content for LLM consumption:
31
  toModelOutput(result) {
32
    return typeof result === 'string'
33
      ? [{ type: 'text', text: result }]
34
      : [{ type: 'image', data: result.data, mediaType: 'image/png' }];
35
  },
36
});

1
import { anthropic } from '@ai-sdk/anthropic';
2
import { generateText } from 'ai';
3

4
const webSearchTool = anthropic.tools.webSearch_20250305({
5
  maxUses: 5,
6
});
7

8
const result = await generateText({
9
  model: anthropic('claude-opus-4-20250514'),
10
  prompt: 'What are the latest developments in AI?',
11
  tools: {
12
    web_search: webSearchTool,
13
  },
14
});

1
const webSearchTool = anthropic.tools.webSearch_20250305({
2
  maxUses: 3,
3
  allowedDomains: ['techcrunch.com', 'wired.com'],
4
  blockedDomains: ['example-spam-site.com'],
5
  userLocation: {
6
    type: 'approximate',
7
    country: 'US',
8
    region: 'California',
9
    city: 'San Francisco',
10
    timezone: 'America/Los_Angeles',
11
  },
12
});
13

14
const result = await generateText({
15
  model: anthropic('claude-opus-4-20250514'),
16
  prompt: 'Find local news about technology',
17
  tools: {
18
    web_search: webSearchTool,
19
  },
20
});

1
import { anthropic } from '@ai-sdk/anthropic';
2
import { generateText } from 'ai';
3

4
const result = await generateText({
5
  model: anthropic('claude-sonnet-4-0'),
6
  prompt:
7
    'What is this page about? https://en.wikipedia.org/wiki/Maglemosian_culture',
8
  tools: {
9
    web_fetch: anthropic.tools.webFetch_20250910({ maxUses: 1 }),
10
  },
11
});

1
import { anthropic } from '@ai-sdk/anthropic';
2
import { generateText, tool } from 'ai';
3
import { z } from 'zod';
4

5
const result = await generateText({
6
  model: anthropic('claude-sonnet-4-5'),
7
  prompt: 'What is the weather in San Francisco?',
8
  tools: {
9
    toolSearch: anthropic.tools.toolSearchBm25_20251119(),
10

11
    get_weather: tool({
12
      description: 'Get the current weather at a specific location',
13
      inputSchema: z.object({
14
        location: z.string().describe('The city and state'),
15
      }),
16
      execute: async ({ location }) => ({
17
        location,
18
        temperature: 72,
19
        condition: 'Sunny',
20
      }),
21
      // Defer tool here - Claude discovers these via the tool search tool
22
      providerOptions: {
23
        anthropic: { deferLoading: true },
24
      },
25
    }),
26
  },
27
});

1
const result = await generateText({
2
  model: anthropic('claude-sonnet-4-5'),
3
  prompt: 'Get the weather data',
4
  tools: {
5
    toolSearch: anthropic.tools.toolSearchRegex_20251119(),
6
    // ... deferred tools
7
  },
8
});

1
import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic';
2
import { generateText } from 'ai';
3

4
const result = await generateText({
5
  model: anthropic('claude-sonnet-4-5'),
6
  prompt: `Call the echo tool with "hello world". what does it respond with back?`,
7
  providerOptions: {
8
    anthropic: {
9
      mcpServers: [
10
        {
11
          type: 'url',
12
          name: 'echo',
13
          url: 'https://echo.mcp.inevitable.fyi/mcp',
14
          // optional: authorization token
15
          authorizationToken: mcpAuthToken,
16
          // optional: tool configuration
17
          toolConfiguration: {
18
            enabled: true,
19
            allowedTools: ['echo'],
20
          },
21
        },
22
      ],
23
    } satisfies AnthropicProviderOptions,
24
  },
25
});

1
try {
2
  const result = await generateText({
3
    model: anthropic('claude-opus-4-20250514'),
4
    prompt: 'Search for something',
5
    tools: {
6
      web_search: webSearchTool,
7
    },
8
  });
9
} catch (error) {
10
  if (error.message.includes('Web search failed')) {
11
    console.log('Search error:', error.message);
12
    // Handle search error appropriately
13
  }
14
}

1
const result = await streamText({
2
  model: anthropic('claude-opus-4-20250514'),
3
  prompt: 'Search for something',
4
  tools: {
5
    web_search: webSearchTool,
6
  },
7
});
8

9
for await (const part of result.textStream) {
10
  if (part.type === 'error') {
11
    console.log('Search error:', part.error);
12
    // Handle search error appropriately
13
  }
14
}

1
import { anthropic } from '@ai-sdk/anthropic';
2
import { generateText } from 'ai';
3

4
const codeExecutionTool = anthropic.tools.codeExecution_20250825();
5

6
const result = await generateText({
7
  model: anthropic('claude-opus-4-20250514'),
8
  prompt:
9
    'Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]',
10
  tools: {
11
    code_execution: codeExecutionTool,
12
  },
13
});

1
const result = await generateText({
2
  model: anthropic('claude-opus-4-20250514'),
3
  prompt: 'Execute some Python script',
4
  tools: {
5
    code_execution: codeExecutionTool,
6
  },
7
});
8

9
const toolErrors = result.content?.filter(
10
  content => content.type === 'tool-error',
11
);
12

13
toolErrors?.forEach(error => {
14
  console.error('Tool execution error:', {
15
    toolName: error.toolName,
16
    toolCallId: error.toolCallId,
17
    error: error.error,
18
  });
19
});

1
const result = await streamText({
2
  model: anthropic('claude-opus-4-20250514'),
3
  prompt: 'Execute some Python script',
4
  tools: {
5
    code_execution: codeExecutionTool,
6
  },
7
});
8
for await (const part of result.textStream) {
9
  if (part.type === 'error') {
10
    console.log('Code execution error:', part.error);
11
    // Handle code execution error appropriately
12
  }
13
}

1
import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic';
2
import { generateText } from 'ai';
3

4
const result = await generateText({
5
  model: anthropic('claude-sonnet-4-5'),
6
  tools: {
7
    code_execution: anthropic.tools.codeExecution_20250825(),
8
  },
9
  prompt: 'Create a presentation about renewable energy with 5 slides',
10
  providerOptions: {
11
    anthropic: {
12
      container: {
13
        skills: [
14
          {
15
            type: 'anthropic',
16
            skillId: 'pptx',
17
            version: 'latest', // optional
18
          },
19
        ],
20
      },
21
    } satisfies AnthropicProviderOptions,
22
  },
23
});

1
const result = await generateText({
2
  model: anthropic('claude-sonnet-4-5'),
3
  tools: {
4
    code_execution: anthropic.tools.codeExecution_20250825(),
5
  },
6
  prompt: 'Use my custom skill to process this data',
7
  providerOptions: {
8
    anthropic: {
9
      container: {
10
        skills: [
11
          {
12
            type: 'custom',
13
            skillId: 'my-custom-skill-id',
14
            version: '1.0', // optional
15
          },
16
        ],
17
      },
18
    } satisfies AnthropicProviderOptions,
19
  },
20
});

1
const result = await generateText({
2
  model: anthropic('claude-3-5-sonnet-20241022'),
3
  messages: [
4
    {
5
      role: 'user',
6
      content: [
7
        {
8
          type: 'text',
9
          text: 'What is an embedding model according to this document?',
10
        },
11
        {
12
          type: 'file',
13
          data: new URL(
14
            'https://github.com/vercel/ai/blob/main/examples/ai-core/data/ai.pdf?raw=true',
15
          ),
16
          mimeType: 'application/pdf',
17
        },
18
      ],
19
    },
20
  ],
21
});

1
const result = await generateText({
2
  model: anthropic('claude-3-5-sonnet-20241022'),
3
  messages: [
4
    {
5
      role: 'user',
6
      content: [
7
        {
8
          type: 'text',
9
          text: 'What is an embedding model according to this document?',
10
        },
11
        {
12
          type: 'file',
13
          data: fs.readFileSync('./data/ai.pdf'),
14
          mediaType: 'application/pdf',
15
        },
16
      ],
17
    },
18
  ],
19
});