Anthropic Provider

npm install @core-ai/anthropic

import { createAnthropic } from '@core-ai/anthropic';

const anthropic = createAnthropic({
    apiKey: process.env.ANTHROPIC_API_KEY,
});

import {
    createAnthropic,
    getAnthropicModelCapabilities,
} from '@core-ai/anthropic';

const anthropic = createAnthropic();
const model = anthropic.chatModel('claude-opus-5');
const capabilities = model.capabilities;

const otherCapabilities = getAnthropicModelCapabilities('claude-opus-4-5');

const result = await generate({
    model: anthropic.chatModel('claude-sonnet-4-6'),
    messages,
    toolDiscovery: { description: 'Discoverable tools: get_order_status.' },
    providerOptions: {
        anthropic: { emulateToolDiscovery: true },
    },
});

const result = await generate({
    model: anthropic.chatModel('claude-sonnet-5-5'),
    messages: [
        { role: 'system', content: 'You are a support agent.' },
        { role: 'user', content: 'I want a refund.' },
        { role: 'system', content: 'Offer a manager callback.' },
    ],
});

import { createAnthropic } from '@core-ai/anthropic';
import { generate } from '@core-ai/core-ai';

const anthropic = createAnthropic();

const result = await generate({
    model: anthropic.chatModel('claude-sonnet-4-6'),
    messages: [{ role: 'user', content: 'Explain the theory of relativity' }],
});

console.log(result.content);

const result = await generate({
    model: anthropic.chatModel('claude-opus-5'),
    messages: [
        {
            role: 'user',
            content: 'Analyze this complex dataset and provide insights...',
        },
    ],
    reasoning: {
        effort: 'max',
    },
});

if (result.reasoning) {
    console.log('Reasoning:', result.reasoning);
}
console.log('Answer:', result.content);

import { stream } from '@core-ai/core-ai';

const chatStream = await stream({
    model: anthropic.chatModel('claude-sonnet-4-6'),
    messages: [{ role: 'user', content: 'Write a detailed analysis of...' }],
    reasoning: {
        effort: 'high',
    },
});

for await (const event of chatStream) {
    if (event.type === 'reasoning-delta') {
        process.stdout.write(event.text);
    } else if (event.type === 'text-delta') {
        process.stdout.write(event.text);
    }
}

import { generate, defineTool } from '@core-ai/core-ai';
import { z } from 'zod';

const result = await generate({
    model: anthropic.chatModel('claude-sonnet-4-6'),
    messages: [
        { role: 'user', content: 'What is the weather in San Francisco?' },
    ],
    tools: {
        getWeather: defineTool({
            name: 'getWeather',
            description: 'Get weather for a location',
            parameters: z.object({
                location: z.string(),
            }),
        }),
    },
});

const result = await generate({
    model: anthropic.chatModel('claude-sonnet-4-6'),
    messages: [
        {
            role: 'user',
            content: [
                { type: 'text', text: 'What is in this image?' },
                {
                    type: 'image',
                    source: {
                        type: 'url',
                        url: 'https://example.com/image.jpg',
                    },
                },
            ],
        },
    ],
});

const result = await generate({
    model: anthropic.chatModel('claude-opus-5'),
    messages: [{ role: 'user', content: 'Complex problem...' }],
    reasoning: {
        effort: 'high',
    },
});

const result = await generate({
    model: anthropic.chatModel('claude-opus-4-5'),
    messages: [{ role: 'user', content: 'Complex reasoning task...' }],
    reasoning: { effort: 'high' },
    providerOptions: {
        anthropic: { outputConfig: { effort: 'medium' } },
    },
});

const result = await generate({
    model: anthropic.chatModel('claude-opus-4-5'),
    messages: [{ role: 'user', content: 'Complex reasoning task...' }],
    reasoning: {
        effort: 'high',
    },
});

import { generate, getProviderMetadata } from '@core-ai/core-ai';
import type { AnthropicReasoningMetadata } from '@core-ai/anthropic';

const result = await generate({
    model: anthropic.chatModel('claude-opus-5'),
    messages: [{ role: 'user', content: 'Think step by step.' }],
    reasoning: { effort: 'high' },
});

for (const part of result.parts) {
    if (part.type !== 'reasoning') continue;

    const metadata = getProviderMetadata<AnthropicReasoningMetadata>(
        part.providerMetadata,
        'anthropic'
    );

    console.log(metadata?.signature);
    console.log(metadata?.redactedData);
}

const result = await generate({
    model: anthropic.chatModel('claude-sonnet-5'),
    messages: [{ role: 'user', content: 'Hello' }],
    providerOptions: {
        anthropic: {
            stopSequences: ['\n\n'],
        },
    },
});

const result = await generate({
    model: anthropic.chatModel('claude-sonnet-4-6'),
    messages: [
        { role: 'system', content: 'You are a careful technical editor.' },
        {
            role: 'user',
            content: 'Summarize this document and keep all key dates.',
        },
    ],
    providerOptions: {
        anthropic: {
            cacheControl: { type: 'ephemeral' },
        },
    },
});

console.log(result.usage.inputTokenDetails.cacheReadTokens);
console.log(result.usage.inputTokenDetails.cacheWriteTokens);

const result = await generate({
    model: anthropic.chatModel('claude-sonnet-4-6'),
    messages: [{ role: 'user', content: 'Summarize this large document.' }],
    providerOptions: {
        anthropic: {
            cacheControl: { type: 'ephemeral', ttl: '1h' },
        },
    },
});

const result = await generate({
    model: anthropic.chatModel('claude-sonnet-5-5'),
    messages: [
        {
            role: 'system',
            content: largeStaticInstructions,
            providerOptions: {
                anthropic: {
                    cacheControl: { type: 'ephemeral', ttl: '1h' },
                },
            },
        },
        ...conversation,
    ],
    providerOptions: {
        anthropic: {
            cacheControl: { type: 'ephemeral' },
        },
    },
});

const previousStepEnd =
    messages.findLastIndex((message) => message.role === 'assistant') - 1;

const result = await generate({
    model: anthropic.chatModel('claude-sonnet-5-5'),
    messages: messages.map((message, index) =>
        index === previousStepEnd && message.role !== 'assistant'
            ? {
                  ...message,
                  providerOptions: {
                      ...message.providerOptions,
                      anthropic: {
                          // Keep an existing marker, such as a 1h one.
                          cacheControl: message.providerOptions?.anthropic
                              ?.cacheControl ?? { type: 'ephemeral' },
                      },
                  },
              }
            : message
    ),
    providerOptions: {
        anthropic: {
            cacheControl: { type: 'ephemeral' },
        },
    },
});

import { ProviderError } from '@core-ai/core-ai';

try {
    const result = await generate({
        model: anthropic.chatModel('claude-sonnet-4-6'),
        messages: [{ role: 'user', content: 'Hello!' }],
    });
} catch (error) {
    if (error instanceof ProviderError) {
        console.error('Anthropic API error:', error.message);
        console.error('Status:', error.statusCode);
    }
}