Anthropic SDK

Use Anthropic SDK with Infron AI models

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

npm install @anthropic-ai/sdk

Environment

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

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

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

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.

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

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.

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.

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

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.