Anthropic

import Anthropic from '@anthropic-ai/sdk';
import { VernLLM, fromAnthropic } from 'vern-llm';

const llm = new VernLLM({
  client: fromAnthropic(new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })),
  model: 'claude-sonnet-4-6',
});

AnthropicClient is the public client type exported by VernLLM and accepted by fromAnthropic. It allows TypeScript users to type their Anthropic SDK client without depending on adapter internals.

Without jsonSchema, whether an unset json_object mode throws or is silently downgraded to plain text depends on what else the call is asking for:

• A plain call (llm.call({ userContent }), no schema, no explicit jsonMode) is silently treated as plain text: json_object is never sent, and the response comes back unparsed. This keeps the common, no-config case working exactly as before.
• An explicit jsonMode: true throws LLMError('invalid_params') before the request is sent, since that's a caller deliberately asking for a guarantee Anthropic can't provide.
• schema (Zod-style client-side validation) without jsonSchema, whether or not jsonMode is set explicitly, also throws LLMError('invalid_params'): schema needs JSON output to validate against, so an implicit request for JSON is treated the same as an explicit one rather than silently downgraded, which would skip validation instead of running it. Use jsonSchema instead: it maps to a real constraint and still runs schema against its parsed result.

Tool calling

tools and tool_calls map onto Anthropic's native tool_use / tool_result content blocks. Since Anthropic requires strict user/assistant alternation, fromAnthropic merges consecutive tool result messages from a multi-tool turn back into a single user turn with multiple tool_result blocks. ToolResult.isError is forwarded as tool_result.is_error. See Tool Calling for the full reference.

For the Anthropic adapter, tool parameter schemas and response_format: { type: 'json_schema' } schemas must have a root type: 'object'. The public VernLLM request types remain broadly typed for JSON Schema, so this restriction is validated at runtime. A schema with a non-object root causes fromAnthropic to throw an LLMError with category validation before the request is sent to Anthropic. When migrating to the Anthropic adapter, ensure all tool and JSON Schema parameter schemas use an object root.

Combining tools with jsonSchema

By default, jsonSchema and tools cannot be used in the same call: jsonSchema is emulated as a forced single tool call, which occupies the same tools/tool_choice field real tools need.

On unsupported models, this throws LLMError('invalid_params') with code: 'unsupported_capability' and issues.capability: 'tools_with_json_schema', so the default fallback policy can try the next target.

Anthropic also supports native, schema-constrained output, output_config.format, a request field independent of tools/tool_choice, so it composes with real tools on models that support it. This is opt-in, pass nativeStructuredOutputModels as the second argument to fromAnthropic. See Anthropic's Structured outputs → Compatibility page for the current list of model families and platforms that support it; that list isn't hardcoded here since it varies by exact model and can change.

const llm = new VernLLM({
  client: fromAnthropic(new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY }), {
    nativeStructuredOutputModels: ['claude-native-model-id'],
    // ...or a predicate, e.g. by model family:
    // nativeStructuredOutputModels: (model) => model.startsWith('claude-4'),
  }),
  model: 'claude-native-model-id',
});

There is no built-in default list, see Structured Output → Combining with tools for why. On a covered model, jsonSchema is sent as output_config.format instead of a forced tool call, and the schema-conforming JSON arrives as ordinary text content, no unwrapping needed, while any real tools you pass are built and sent exactly as they would be without jsonSchema present. On a model not covered by nativeStructuredOutputModels, combining tools with jsonSchema throws LLMError('invalid_params') with code: 'unsupported_capability' and issues.capability: 'tools_with_json_schema', naming the model and pointing at this option. The default fallback policy can then try the next target.

fromAnthropic's second argument also accepts reasoningEffortTokens, an override for the token counts reasoningEffort tiers map onto when budgetTokens isn't set directly. See the Call Params reference for the full table and how it works across every adapter.

Streaming

fromAnthropic implements createStream on top of the Messages API's own streaming mode. Anthropic's content_block_delta events map onto text-delta chunks, and input_json_delta events on a tool_use block map onto tool_call_delta chunks. No extra setup is needed beyond the client already passed to fromAnthropic:

const { chunks, finalResult } = await llm.call({
  userContent: 'Write a short poem about the ocean.',
  stream: true,
});

for await (const chunk of chunks) {
  if (chunk.type === 'text-delta') process.stdout.write(chunk.delta);
}

See Streaming for the full stream: true contract, none of which changes per-provider beyond how each adapter maps its own streaming events.

Multimodal input

fromAnthropic supports VernLLM's provider-independent ContentBlock[] format for image input. Image blocks are translated into Anthropic's native content blocks automatically. The selected Anthropic model must support vision/image input for multimodal requests to succeed.

const result = await llm.call({
  userContent: [
    {
      type: 'text',
      text: 'Describe this image.',
    },
    {
      type: 'image',
      mimeType: 'image/png',
      data: imageBase64,
    },
  ],
});

Image data must be base64-encoded bytes without a data: URL prefix. Supported image types are image/png, image/jpeg, image/gif, and image/webp.

Plain string userContent remains unchanged for text-only requests.