Anthropic Provider

Overview

The Anthropic provider gives you access to Claude models with advanced reasoning capabilities through adaptive and manual thinking modes.

Installation

npm install @core-ai/anthropic

createAnthropic()

Create an Anthropic provider instance.

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

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

Options

apiKey

string

Your Anthropic API key. Defaults to ANTHROPIC_API_KEY environment variable.

baseURL

string

Custom base URL for API requests.

defaultMaxTokens

number

default:"4096"

Default maximum tokens for completions. Can be overridden per request.

client

Anthropic

Provide your own configured Anthropic client instance.

Returns

AnthropicProvider with method chatModel().

Supported models

Claude Fable and Mythos (adaptive thinking)

Claude Fable and Mythos models use adaptive thinking mode.

claude-fable-5 - Widely available model for demanding reasoning and agentic work
claude-mythos-5 - Limited-access model with the same capability handling
claude-mythos-preview - Limited-access preview model

Claude Opus and Sonnet (adaptive thinking)

Current Opus and Sonnet models use effort-based adaptive thinking.

claude-sonnet-5 - Most agentic Sonnet model with near-Opus performance at lower cost
claude-opus-4-8 - Opus model for complex reasoning and agentic coding
claude-opus-4-7 - Opus model with max effort support
claude-opus-4-6 - Opus model with max effort support
claude-sonnet-4-6 - Balanced performance and speed with max effort support

Claude 4.5 (manual thinking)

Models with manual thinking budget control.

claude-opus-4-5 - High capability
claude-sonnet-4-5 - Efficient reasoning
claude-haiku-4-5 - Fast and lightweight

Claude 4 and earlier

claude-opus-4-1 - Enhanced reasoning
claude-opus-4 - Strong performance
claude-sonnet-4 - Balanced model
claude-sonnet-3-7 - Previous generation

Capabilities

Feature	Support
Chat Completion	Yes
Streaming	Yes
Function Calling	Yes
Vision	Yes
Reasoning	Yes
Prompt Caching	Yes
Embeddings	No
Image Generation	No

Use ChatModel.capabilities or getAnthropicModelCapabilities(modelId) to inspect reasoning support at runtime:

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

const anthropic = createAnthropic();
const model = anthropic.chatModel('claude-opus-4-8');

if (model.capabilities.reasoning.supported) {
    const effort = clampReasoningEffort(
        'max',
        model.capabilities.reasoning.supportedEfforts
    );

    await generate({
        model,
        messages: [{ role: 'user', content: 'Analyze this carefully.' }],
        reasoning: { effort },
        // Anthropic sets restrictsSamplingParams: true — omit temperature/topP
    });
}

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

When restrictsSamplingParams is true, do not set temperature (and keep topP in the allowed range) while reasoning is enabled.

Examples

Basic chat

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);

Extended thinking

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

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

Streaming

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);
    }
}

Tool calling

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(),
            }),
        }),
    },
});

Vision and file inputs

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',
                    },
                },
            ],
        },
    ],
});

Anthropic accepts image parts and PDF file parts. Other file MIME types are rejected.

Thinking modes

Adaptive thinking

The model automatically determines thinking depth based on the effort level.

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

claude-fable-5, claude-mythos-5, claude-mythos-preview, claude-opus-4-8, claude-opus-4-7, claude-opus-4-6, claude-sonnet-5, and claude-sonnet-4-6 support 'max' effort directly.

Manual thinking budget (Claude 4.5 and earlier)

Token budgets: minimal -> 1,024, low -> 2,048, medium -> 8,192, high -> 32,768, max -> 65,536.

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

Reasoning restrictions

When reasoning is enabled, Anthropic enforces additional request constraints:

temperature must be omitted
topP must be between 0.95 and 1
toolChoice must be 'auto' or 'none'
providerOptions.anthropic.topK must be omitted

Violating these constraints throws a ProviderError before the request is sent.

When you combine reasoning with tools, the adapter automatically adds the interleaved-thinking-2025-05-14 beta.

Reasoning metadata

When reasoning is enabled, Anthropic reasoning parts include provider metadata with signature and redacted data fields. Use getProviderMetadata to access them in a type-safe way.

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

const result = await generate({
    model: anthropic.chatModel('claude-opus-4-8'),
    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);
}

The AnthropicReasoningMetadata type contains:

signature — cryptographic signature for multi-turn reasoning fidelity
redactedData — redacted thinking content, if present

Provider-specific options

Options are namespaced under anthropic in providerOptions:

const result = await generate({
    model: anthropic.chatModel('claude-sonnet-4-6'),
    messages: [{ role: 'user', content: 'Hello' }],
    providerOptions: {
        anthropic: {
            stopSequences: ['\n\n'],
            betas: ['interleaved-thinking-2025-05-14'],
        },
    },
});

Available fields: topK, stopSequences, betas, outputConfig, cacheControl.

Prompt caching

Use cacheControl to enable Anthropic prompt caching. This maps to Anthropic’s top-level cache_control request field and uses automatic caching for the reusable prompt prefix.

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);

You can request a 1-hour cache TTL when you expect follow-up requests to arrive later than Anthropic’s default 5-minute cache window:

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' },
        },
    },
});

Anthropic reports cache usage in result.usage.inputTokenDetails:

cacheReadTokens: Tokens served from an existing cache entry
cacheWriteTokens: Tokens written to the cache for future requests

Anthropic only caches prompts above the model’s minimum cacheable length:

1024 tokens for Claude Opus 4.8
1024 tokens for Claude Sonnet 4.5, Claude Opus 4.1, Claude Opus 4, Claude Sonnet 4, and Claude Sonnet 3.7
2048 tokens for Claude Sonnet 4.6
4096 tokens for Claude Opus 4.6, Claude Opus 4.5, and Claude Haiku 4.5

Error handling

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);
    }
}

OpenAI Provider

GPT models with reasoning capabilities

Google GenAI Provider

Gemini models with multimodal support

Chat Completion Guide

Learn how to use chat completion

​Overview

​Installation

​createAnthropic()

​Options

​Returns

​Supported models

​Capabilities

​Examples

​Basic chat

​Extended thinking

​Streaming

​Tool calling

​Vision and file inputs

​Thinking modes

​Adaptive thinking

​Manual thinking budget (Claude 4.5 and earlier)

​Reasoning restrictions

​Reasoning metadata

​Provider-specific options

​Prompt caching

​Error handling

​Related

OpenAI Provider

Google GenAI Provider

Chat Completion Guide

Overview

Installation

createAnthropic()

Options

Returns

Supported models

Capabilities

Examples

Basic chat

Extended thinking

Streaming

Tool calling

Vision and file inputs

Thinking modes

Adaptive thinking

Manual thinking budget (Claude 4.5 and earlier)

Reasoning restrictions

Reasoning metadata

Provider-specific options

Prompt caching

Error handling

Related