Package Exports

@bernierllc/ai-provider-anthropic
@bernierllc/ai-provider-anthropic/dist/index.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (@bernierllc/ai-provider-anthropic) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

@bernierllc/ai-provider-anthropic

Anthropic Claude API adapter implementing the unified AI provider interface from @bernierllc/ai-provider-core.

Features

All Claude 3 Models: Full support for Opus, Sonnet, and Haiku
Streaming: Async generator-based streaming completions
Vision Analysis: Image analysis with all Claude 3 models
Extended Context: Support for 200K token context windows
Cost Estimation: Accurate cost calculation with model-specific pricing
TypeScript: Full type safety with strict mode
Error Handling: Comprehensive error handling with retry support

Installation

npm install @bernierllc/ai-provider-anthropic

Basic Usage

import { AnthropicProvider } from '@bernierllc/ai-provider-anthropic';

const provider = new AnthropicProvider({
  providerName: 'anthropic',
  apiKey: process.env.ANTHROPIC_API_KEY!,
  defaultModel: 'claude-3-opus-20240229'
});

// Generate completion
const response = await provider.complete({
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Explain TypeScript generics in simple terms.' }
  ],
  maxTokens: 500,
  temperature: 0.7
});

if (response.success) {
  console.log(response.content);
  console.log(`Tokens used: ${response.usage?.totalTokens}`);
}

API Reference

Constructor

new AnthropicProvider(config: AnthropicProviderConfig)

Config Options:

providerName: Must be 'anthropic'
apiKey: Anthropic API key (required)
defaultModel: Default model to use (optional, defaults to claude-3-opus-20240229)
baseURL: Custom API base URL (optional)
timeout: Request timeout in milliseconds (optional, defaults to 60000)
maxRetries: Maximum number of retries (optional, defaults to 3)

Methods

`complete(request: CompletionRequest): Promise<CompletionResponse>`

Generate a text completion.

const response = await provider.complete({
  messages: [
    { role: 'user', content: 'Hello!' }
  ],
  maxTokens: 100,
  temperature: 0.7
});

`streamComplete(request: CompletionRequest): AsyncGenerator<StreamChunk>`

Generate a streaming text completion.

for await (const chunk of provider.streamComplete({
  messages: [
    { role: 'user', content: 'Write a short poem about coding' }
  ]
})) {
  process.stdout.write(chunk.delta);

  if (chunk.finishReason) {
    console.log(`\n\nFinished: ${chunk.finishReason}`);
  }
}

`analyzeImage(imageData, prompt, model?, maxTokens?, temperature?): Promise<CompletionResponse>`

Analyze an image using Claude's vision capabilities.

const imageBuffer = fs.readFileSync('diagram.png');

const analysis = await provider.analyzeImage(
  imageBuffer,
  'Describe this architecture diagram in detail',
  'claude-3-opus-20240229'
);

if (analysis.success) {
  console.log(analysis.content);
}

`extendedContextCompletion(request): Promise<CompletionResponse>`

Process requests with extended context (200K tokens).

const longDocument = fs.readFileSync('very-long-document.txt', 'utf-8');

const response = await provider.extendedContextCompletion({
  messages: [
    { role: 'user', content: `Summarize this document:\n\n${longDocument}` }
  ],
  enableExtendedContext: true
});

`estimateCost(request: CompletionRequest): CostEstimate`

Estimate the cost of a request before sending it.

const cost = provider.estimateCost({
  messages: [{ role: 'user', content: 'Hello world!' }],
  model: 'claude-3-opus-20240229',
  maxTokens: 100
});

console.log(`Estimated cost: $${cost.estimatedCostUSD.toFixed(4)}`);

`getAvailableModels(): Promise<ModelInfo[]>`

Get information about all available Claude models.

const models = await provider.getAvailableModels();

models.forEach(model => {
  console.log(`${model.name}: ${model.contextWindow} tokens`);
});

`checkHealth(): Promise<HealthStatus>`

Check if the Anthropic API is available.

const health = await provider.checkHealth();

if (health.status === 'healthy') {
  console.log(`API is healthy (latency: ${health.latency}ms)`);
}

Available Models

Model	ID	Context	Output	Cost (Input/Output per 1M tokens)
Claude 3 Opus	`claude-3-opus-20240229`	200K	4096	$15 / $75
Claude 3 Sonnet	`claude-3-sonnet-20240229`	200K	4096	$3 / $15
Claude 3 Haiku	`claude-3-haiku-20240307`	200K	4096	$0.25 / $1.25

All models support:

Text completion
Streaming
Vision analysis
Extended context (200K tokens)

Error Handling

The provider returns structured error responses:

const response = await provider.complete({
  messages: [{ role: 'user', content: 'Test' }]
});

if (!response.success) {
  console.error('Error:', response.error);
}

Limitations

Embeddings

Anthropic does not provide an embeddings API. Use @bernierllc/ai-provider-openai for embeddings:

const embeddingResponse = await provider.generateEmbeddings({
  input: 'test text'
});

// Returns: { success: false, error: 'Anthropic does not provide an embeddings API...' }

Content Moderation

Claude has built-in safety features (Constitutional AI), so no separate moderation API is needed:

const moderation = await provider.moderate('content');

// Always returns: { success: true, flagged: false, ... }

Integration Status

Logger: ✅ Integrated - Uses @bernierllc/logger for error logging
Docs-Suite: ✅ Ready - Full TypeDoc/JSDoc documentation
NeverHub: ⚠️ Optional - Can integrate for monitoring and metrics

Advanced Usage

Model Comparison

const models = await provider.getAvailableModels();

models.forEach(model => {
  console.log(`${model.name}:`);
  console.log(`  Context: ${model.contextWindow.toLocaleString()} tokens`);
  console.log(`  Capabilities: ${model.capabilities.join(', ')}`);
  if (model.pricing) {
    console.log(`  Input: $${model.pricing.inputPricePerToken * 1000000}/M tokens`);
    console.log(`  Output: $${model.pricing.outputPricePerToken * 1000000}/M tokens`);
  }
});

Complex Reasoning Task

// Claude excels at complex reasoning and analysis
const response = await provider.complete({
  messages: [
    {
      role: 'user',
      content: `Analyze this code architecture and suggest improvements:

[Large codebase content...]

Consider: scalability, maintainability, security, performance`
    }
  ],
  model: 'claude-3-opus-20240229',
  maxTokens: 4096,
  temperature: 0.3 // Lower temperature for analytical tasks
});

Vision with Multiple Images

// Analyze multiple images in sequence
const images = ['image1.png', 'image2.png', 'image3.png'];

for (const imagePath of images) {
  const imageBuffer = fs.readFileSync(imagePath);

  const analysis = await provider.analyzeImage(
    imageBuffer,
    'What do you see in this image?'
  );

  console.log(`${imagePath}: ${analysis.content}`);
}

TypeScript Types

import type {
  AnthropicProviderConfig,
  AnthropicVisionRequest,
  AnthropicExtendedContextRequest
} from '@bernierllc/ai-provider-anthropic';

import type {
  CompletionRequest,
  CompletionResponse,
  StreamChunk,
  ModelInfo,
  HealthStatus,
  CostEstimate
} from '@bernierllc/ai-provider-core';

JSPM