> For the complete documentation index, see [llms.txt](https://infronai.gitbook.io/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://infronai.gitbook.io/docs/frameworks-and-integrations/anthropic-sdk-compatibility.md).

# Anthropic SDK

Infron supports Anthropic-compatible `/v1/messages` requests through the official `@anthropic-ai/sdk`.

Use this integration when your application already uses the Anthropic SDK or needs Anthropic-native request fields such as `tools`, `thinking`, `cache_control`, `defer_loading`, or `eager_input_streaming`.

### Install

```bash
npm install @anthropic-ai/sdk
```

### Environment

```bash
export INFRON_API_KEY="your-infron-api-key"
```

Do not expose this key in browser code. Use it from a server route, API route, or backend service.

### Basic Text Generation

```ts
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.INFRON_API_KEY,
  baseURL: 'https://llm.onerouter.pro',
});

const response = await client.messages.create({
  model: 'anthropic/claude-sonnet-4.6',
  max_tokens: 128,
  messages: [
    {
      role: 'user',
      content: 'Reply with one short synthetic status sentence.',
    },
  ],
});

console.log(response.content);
```

### Streaming

```ts
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.INFRON_API_KEY,
  baseURL: 'https://llm.onerouter.pro',
});

const stream = await client.messages.create({
  model: 'anthropic/claude-sonnet-4.6',
  max_tokens: 256,
  stream: true,
  messages: [
    {
      role: 'user',
      content: 'Write three short bullets about a synthetic test workflow.',
    },
  ],
});

for await (const event of stream) {
  if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
    process.stdout.write(event.delta.text);
  }
}
```

### Tool Calling

```ts
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.INFRON_API_KEY,
  baseURL: 'https://llm.onerouter.pro',
});

const response = await client.messages.create({
  model: 'anthropic/claude-sonnet-4.6',
  max_tokens: 256,
  messages: [
    {
      role: 'user',
      content: 'Use the mock lookup tool only if needed, then return a short status sentence.',
    },
  ],
  tools: [
    {
      name: 'lookup_mock_record',
      description: 'Return a synthetic record for compatibility testing.',
      input_schema: {
        type: 'object',
        properties: {
          record_id: {
            type: 'string',
            description: 'Synthetic record id.',
          },
        },
        required: ['record_id'],
      },
    },
  ],
  tool_choice: { type: 'auto' },
});

console.log(response.content);
```

### Debugging Requests

Infron supports `debug_request` and `debug_response` on Anthropic-compatible requests.

Use these fields during integration testing to inspect how Infron maps your SDK request to the upstream provider request and response.

```ts
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.INFRON_API_KEY,
  baseURL: 'https://llm.onerouter.pro',
});

const response = await client.messages.create({
  model: 'anthropic/claude-sonnet-4.6',
  max_tokens: 128,
  debug_request: true,
  debug_response: true,
  messages: [
    {
      role: 'user',
      content: 'Reply with one short synthetic status sentence.',
    },
  ],
});

console.log(response);
```

When enabled, the response may include:

* `debug_info.request`
* `debug_info.response`

Use these fields for development and validation only. Avoid logging debug payloads in production if prompts or payloads may contain sensitive data.

### Thinking

```ts
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.INFRON_API_KEY,
  baseURL: 'https://llm.onerouter.pro',
});

const response = await client.messages.create({
  model: 'anthropic/claude-sonnet-4.6',
  max_tokens: 256,
  thinking: {
    type: 'enabled',
    budget_tokens: 1024,
  },
  messages: [
    {
      role: 'user',
      content: 'Return one short synthetic explanation.',
    },
  ],
});

console.log(response.content);
```

### Prompt Caching

Use `cache_control` on content blocks or tool definitions when applicable.

```ts
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.INFRON_API_KEY,
  baseURL: 'https://llm.onerouter.pro',
});

const response = await client.messages.create({
  model: 'anthropic/claude-sonnet-4.6',
  max_tokens: 128,
  messages: [
    {
      role: 'user',
      content: [
        {
          type: 'text',
          text: 'Synthetic reusable context for prompt cache validation.',
          cache_control: { type: 'ephemeral' },
        },
        {
          type: 'text',
          text: 'Reply with one short synthetic status sentence.',
        },
      ],
    },
  ],
});

console.log(response.usage);
```

### Anthropic Tool Options

Anthropic supports tool-level options such as:

* `defer_loading`
* `eager_input_streaming`
* `cache_control`

Use Anthropic-native snake\_case field names.

```ts
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.INFRON_API_KEY,
  baseURL: 'https://llm.onerouter.pro',
});

const response = await client.messages.create({
  model: 'anthropic/claude-sonnet-4.6',
  max_tokens: 256,
  debug_request: true,
  debug_response: true,
  messages: [
    {
      role: 'user',
      content: 'Use mock tools only if needed, then return one short synthetic status sentence.',
    },
  ],
  tools: [
    {
      name: 'lookup_mock_deferred',
      description: 'Return a synthetic deferred record.',
      input_schema: {
        type: 'object',
        properties: {
          record_id: {
            type: 'string',
            description: 'Synthetic record id.',
          },
        },
        required: ['record_id'],
      },
      defer_loading: true,
      eager_input_streaming: true,
    },
    {
      name: 'lookup_mock_regular',
      description: 'Return a synthetic regular record.',
      input_schema: {
        type: 'object',
        properties: {
          record_id: {
            type: 'string',
            description: 'Synthetic record id.',
          },
        },
        required: ['record_id'],
      },
      defer_loading: false,
      eager_input_streaming: true,
      cache_control: { type: 'ephemeral' },
    },
  ],
  tool_choice: { type: 'auto' },
  thinking: {
    type: 'enabled',
    budget_tokens: 1024,
  },
});

console.log(response);
```

{% hint style="info" %}
Infron routes requests across available providers based on model availability, reliability, latency, and provider capability.

When a request is naturally routed to a provider that does not support a given Anthropic-specific option, that option may not appear in the final upstream request body.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://infronai.gitbook.io/docs/frameworks-and-integrations/anthropic-sdk-compatibility.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.