@bernierllc/ai-provider-anthropic 1.0.0

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './message-conversion';
+export * from './error-handling';

package/dist/utils/index.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code only within the scope of the project it was delivered for.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./message-conversion"), exports);
+__exportStar(require("./error-handling"), exports);

package/dist/utils/message-conversion.d.ts

@@ -0,0 +1,17 @@
+import { Message } from '@bernierllc/ai-provider-core';
+import Anthropic from '@anthropic-ai/sdk';
+/**
+ * Convert messages from unified format to Anthropic format
+ * Extracts system messages separately (Anthropic uses system parameter, not messages array)
+ */
+export declare function convertMessagesToAnthropicFormat(messages: Message[]): {
+    system?: string;
+    messages: Anthropic.MessageParam[];
+};
+/**
+ * Validate message format before conversion
+ */
+export declare function validateMessages(messages: Message[]): {
+    isValid: boolean;
+    error?: string;
+};

package/dist/utils/message-conversion.js

@@ -0,0 +1,65 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code only within the scope of the project it was delivered for.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertMessagesToAnthropicFormat = convertMessagesToAnthropicFormat;
+exports.validateMessages = validateMessages;
+/**
+ * Convert messages from unified format to Anthropic format
+ * Extracts system messages separately (Anthropic uses system parameter, not messages array)
+ */
+function convertMessagesToAnthropicFormat(messages) {
+    // Extract system messages
+    const systemMessages = messages.filter(m => m.role === 'system');
+    const system = systemMessages.length > 0
+        ? systemMessages.map(m => m.content).join('\n\n')
+        : undefined;
+    // Convert remaining messages to Anthropic format
+    const anthropicMessages = messages
+        .filter(m => m.role !== 'system')
+        .map(msg => ({
+        role: msg.role === 'assistant' ? 'assistant' : 'user',
+        content: msg.content
+    }));
+    return { system, messages: anthropicMessages };
+}
+/**
+ * Validate message format before conversion
+ */
+function validateMessages(messages) {
+    if (!messages || messages.length === 0) {
+        return {
+            isValid: false,
+            error: 'Messages array cannot be empty'
+        };
+    }
+    // Check that all messages have required fields
+    for (const msg of messages) {
+        if (!msg.role || !msg.content) {
+            return {
+                isValid: false,
+                error: 'All messages must have role and content'
+            };
+        }
+        if (!['system', 'user', 'assistant'].includes(msg.role)) {
+            return {
+                isValid: false,
+                error: `Invalid message role: ${msg.role}`
+            };
+        }
+    }
+    // Ensure non-system messages exist
+    const nonSystemMessages = messages.filter(m => m.role !== 'system');
+    if (nonSystemMessages.length === 0) {
+        return {
+            isValid: false,
+            error: 'At least one non-system message is required'
+        };
+    }
+    return { isValid: true };
+}

package/jest.config.js

@@ -0,0 +1,30 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code only within the scope of the project it was delivered for.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/__tests__'],
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  collectCoverageFrom: [
+    'src/**/*.{ts,tsx}',
+    '!src/**/*.d.ts',
+    '!src/index.ts'
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 90,
+      functions: 90,
+      lines: 90,
+      statements: 90
+    }
+  },
+  coverageDirectory: 'coverage',
+  verbose: true,
+  testTimeout: 30000
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@bernierllc/ai-provider-anthropic",
+  "version": "1.0.0",
+  "description": "Anthropic Claude API adapter implementing the unified AI provider interface",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --watch",
+    "test:run": "jest",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "ai",
+    "provider",
+    "anthropic",
+    "claude",
+    "adapter",
+    "claude-3",
+    "vision",
+    "streaming"
+  ],
+  "author": "Bernier LLC",
+  "license": "SEE LICENSE IN LICENSE",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.20.0",
+    "@bernierllc/ai-provider-core": "^1.0.0",
+    "@bernierllc/retry-policy": "^1.0.0",
+    "@bernierllc/logger": "^1.0.0"
+  },
+  "devDependencies": {
+    "@bernierllc/neverhub-adapter": "^1.0.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.50.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.3.0"
+  },
+  "bernierllc": {
+    "category": "core",
+    "tags": [
+      "ai",
+      "provider",
+      "anthropic",
+      "claude",
+      "adapter"
+    ],
+    "integration": {
+      "neverhub": "optional",
+      "logger": "integrated",
+      "docs-suite": "ready"
+    }
+  }
+}

package/src/AnthropicProvider.ts

@@ -0,0 +1,392 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code only within the scope of the project it was delivered for.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import Anthropic from '@anthropic-ai/sdk';
+import {
+  AIProvider,
+  CompletionRequest,
+  CompletionResponse,
+  StreamChunk,
+  EmbeddingRequest,
+  EmbeddingResponse,
+  ModerationResponse,
+  ModelInfo,
+  HealthStatus,
+  CostEstimate
+} from '@bernierllc/ai-provider-core';
+import { AnthropicProviderConfig, AnthropicStopReason } from './types';
+import { ClaudeModelRegistry } from './models/model-registry';
+import { convertMessagesToAnthropicFormat, validateMessages } from './utils/message-conversion';
+import { handleAnthropicError } from './utils/error-handling';
+
+/**
+ * Anthropic Provider Implementation
+ * Concrete implementation of the AI provider interface for Anthropic's Claude API
+ */
+export class AnthropicProvider extends AIProvider {
+  private client: Anthropic;
+
+  constructor(config: AnthropicProviderConfig) {
+    super(config);
+    this.client = new Anthropic({
+      apiKey: config.apiKey,
+      baseURL: config.baseURL,
+      timeout: config.timeout || 60000,
+      maxRetries: config.maxRetries || 3
+    });
+  }
+
+  // ============================================
+  // CORE OPERATIONS
+  // ============================================
+
+  /**
+   * Generate text completion using Anthropic Claude API
+   */
+  async complete(request: CompletionRequest): Promise<CompletionResponse> {
+    // Validate request
+    const validation = this.validateRequest(request);
+    if (!validation.isValid) {
+      return {
+        success: false,
+        error: validation.errors.join(', ')
+      };
+    }
+
+    // Validate messages
+    const messageValidation = validateMessages(request.messages);
+    if (!messageValidation.isValid) {
+      return {
+        success: false,
+        error: messageValidation.error
+      };
+    }
+
+    try {
+      // Convert messages to Anthropic format
+      const { system, messages } = convertMessagesToAnthropicFormat(request.messages);
+
+      const completion = await this.client.messages.create({
+        model: request.model || this.config.defaultModel || 'claude-3-opus-20240229',
+        system,
+        messages,
+        max_tokens: request.maxTokens || 4096,
+        temperature: request.temperature,
+        top_p: request.topP,
+        stop_sequences: request.stop,
+        metadata: request.user ? {
+          user_id: request.user
+        } : undefined
+      });
+
+      // Extract content from response
+      const content = completion.content
+        .filter((block): block is Anthropic.TextBlock => block.type === 'text')
+        .map(block => block.text)
+        .join('');
+
+      return {
+        success: true,
+        content,
+        finishReason: this.mapStopReason(completion.stop_reason),
+        usage: {
+          promptTokens: completion.usage.input_tokens,
+          completionTokens: completion.usage.output_tokens,
+          totalTokens: completion.usage.input_tokens + completion.usage.output_tokens
+        },
+        model: completion.model,
+        metadata: {
+          id: completion.id,
+          type: completion.type,
+          role: completion.role,
+          stopSequence: completion.stop_sequence
+        }
+      };
+    } catch (error) {
+      const aiError = handleAnthropicError(error);
+      return {
+        success: false,
+        error: aiError.message
+      };
+    }
+  }
+
+  /**
+   * Generate streaming text completion
+   */
+  async *streamComplete(
+    request: CompletionRequest
+  ): AsyncGenerator<StreamChunk, void, unknown> {
+    const validation = this.validateRequest(request);
+    if (!validation.isValid) {
+      throw new Error(validation.errors.join(', '));
+    }
+
+    const messageValidation = validateMessages(request.messages);
+    if (!messageValidation.isValid) {
+      throw new Error(messageValidation.error || 'Invalid messages');
+    }
+
+    try {
+      const { system, messages } = convertMessagesToAnthropicFormat(request.messages);
+
+      const stream = this.client.messages.stream({
+        model: request.model || this.config.defaultModel || 'claude-3-opus-20240229',
+        system,
+        messages,
+        max_tokens: request.maxTokens || 4096,
+        temperature: request.temperature,
+        top_p: request.topP,
+        stop_sequences: request.stop
+      });
+
+      let finalUsage: { promptTokens: number; completionTokens: number; totalTokens: number } | undefined;
+      let finalStopReason: AnthropicStopReason | undefined;
+
+      for await (const event of stream) {
+        if (event.type === 'content_block_delta') {
+          const delta = event.delta;
+          if (delta.type === 'text_delta') {
+            yield {
+              delta: delta.text,
+              finishReason: undefined
+            };
+          }
+        }
+
+        if (event.type === 'message_delta') {
+          // Capture usage information from message_delta event
+          const usage = (event as unknown as Record<string, unknown>).usage as { input_tokens: number; output_tokens: number } | undefined;
+          if (usage) {
+            finalUsage = {
+              promptTokens: usage.input_tokens,
+              completionTokens: usage.output_tokens,
+              totalTokens: usage.input_tokens + usage.output_tokens
+            };
+          }
+        }
+
+        if (event.type === 'message_stop') {
+          // Capture stop reason
+          finalStopReason = null; // message_stop doesn't provide stop_reason directly
+
+          yield {
+            delta: '',
+            finishReason: this.mapStopReason(finalStopReason),
+            usage: finalUsage
+          };
+        }
+      }
+    } catch (error) {
+      throw handleAnthropicError(error);
+    }
+  }
+
+  /**
+   * Generate embeddings (Anthropic doesn't provide embeddings API)
+   * Returns error indicating feature not supported
+   */
+  generateEmbeddings(
+    _request: EmbeddingRequest
+  ): Promise<EmbeddingResponse> {
+    return Promise.resolve({
+      success: false,
+      error: 'Anthropic does not provide an embeddings API. Use OpenAI provider for embeddings.'
+    });
+  }
+
+  /**
+   * Check content moderation (Anthropic doesn't provide moderation API)
+   * Returns success with no flags (Claude has built-in safety)
+   */
+  moderate(_content: string): Promise<ModerationResponse> {
+    // Claude has built-in safety features
+    // We can return success with no flags as Claude refuses unsafe content
+    return Promise.resolve({
+      success: true,
+      flagged: false,
+      categories: {},
+      categoryScores: {}
+    });
+  }
+
+  /**
+   * Get available Anthropic models
+   */
+  getAvailableModels(): Promise<ModelInfo[]> {
+    // Anthropic doesn't provide a models list endpoint
+    // Return cached model information
+    return Promise.resolve(ClaudeModelRegistry.getAllModels());
+  }
+
+  /**
+   * Check Anthropic API health
+   */
+  async checkHealth(): Promise<HealthStatus> {
+    const startTime = Date.now();
+
+    try {
+      // Simple test request with minimal tokens
+      await this.client.messages.create({
+        model: 'claude-3-haiku-20240307',
+        max_tokens: 10,
+        messages: [
+          { role: 'user', content: 'Hi' }
+        ]
+      });
+
+      return {
+        status: 'healthy',
+        latency: Date.now() - startTime,
+        lastChecked: new Date()
+      };
+    } catch (error) {
+      return {
+        status: 'unavailable',
+        latency: Date.now() - startTime,
+        lastChecked: new Date(),
+        details: {
+          error: error instanceof Error ? error.message : 'Unknown error'
+        }
+      };
+    }
+  }
+
+  // ============================================
+  // ANTHROPIC-SPECIFIC FEATURES
+  // ============================================
+
+  /**
+   * Extended context completion (200K tokens for all Claude 3 models)
+   */
+  async extendedContextCompletion(
+    request: CompletionRequest & { enableExtendedContext?: boolean }
+  ): Promise<CompletionResponse> {
+    // All Claude 3 models support 200K context window
+    const model = request.model || 'claude-3-opus-20240229';
+
+    return this.complete({
+      ...request,
+      model
+    });
+  }
+
+  /**
+   * Vision analysis (All Claude 3 models support vision)
+   */
+  async analyzeImage(
+    imageData: string | Buffer,
+    prompt: string,
+    model: string = 'claude-3-opus-20240229',
+    maxTokens?: number,
+    temperature?: number
+  ): Promise<CompletionResponse> {
+    try {
+      // Convert image to base64 if needed
+      const base64Image = Buffer.isBuffer(imageData)
+        ? imageData.toString('base64')
+        : imageData;
+
+      const completion = await this.client.messages.create({
+        model,
+        max_tokens: maxTokens || 4096,
+        temperature,
+        messages: [
+          {
+            role: 'user',
+            content: [
+              {
+                type: 'image',
+                source: {
+                  type: 'base64',
+                  media_type: 'image/jpeg',
+                  data: base64Image
+                }
+              },
+              {
+                type: 'text',
+                text: prompt
+              }
+            ]
+          }
+        ]
+      });
+
+      const content = completion.content
+        .filter((block): block is Anthropic.TextBlock => block.type === 'text')
+        .map(block => block.text)
+        .join('');
+
+      return {
+        success: true,
+        content,
+        finishReason: this.mapStopReason(completion.stop_reason),
+        usage: {
+          promptTokens: completion.usage.input_tokens,
+          completionTokens: completion.usage.output_tokens,
+          totalTokens: completion.usage.input_tokens + completion.usage.output_tokens
+        },
+        model: completion.model
+      };
+    } catch (error) {
+      const aiError = handleAnthropicError(error);
+      return {
+        success: false,
+        error: aiError.message
+      };
+    }
+  }
+
+  // ============================================
+  // COST ESTIMATION (OVERRIDE)
+  // ============================================
+
+  /**
+   * Estimate cost using Anthropic pricing
+   */
+  estimateCost(request: CompletionRequest): CostEstimate {
+    const model = request.model || this.config.defaultModel || 'claude-3-opus-20240229';
+    const pricing = ClaudeModelRegistry.getModelPricing(model);
+
+    const inputTokens = this.estimateTokens(
+      request.messages.map(m => m.content).join(' ')
+    );
+    const outputTokens = request.maxTokens || 4096;
+
+    const inputCost = (inputTokens / 1000000) * pricing.inputPrice;
+    const outputCost = (outputTokens / 1000000) * pricing.outputPrice;
+
+    return {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens,
+      estimatedCostUSD: inputCost + outputCost,
+      currency: 'USD'
+    };
+  }
+
+  // ============================================
+  // PRIVATE METHODS
+  // ============================================
+
+  /**
+   * Map Anthropic stop reason to unified format
+   */
+  private mapStopReason(stopReason: AnthropicStopReason): 'stop' | 'length' | 'content_filter' {
+    switch (stopReason) {
+      case 'end_turn':
+        return 'stop';
+      case 'max_tokens':
+        return 'length';
+      case 'stop_sequence':
+        return 'stop';
+      default:
+        return 'stop';
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code only within the scope of the project it was delivered for.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+// Main provider class
+export { AnthropicProvider } from './AnthropicProvider';
+
+// Types
+export * from './types';
+
+// Models
+export { ClaudeModelRegistry } from './models/model-registry';
+
+// Utilities
+export * from './utils';