@bernierllc/ai-provider-anthropic 1.0.0

package/dist/AnthropicProvider.js

@@ -0,0 +1,337 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const ai_provider_core_1 = require("@bernierllc/ai-provider-core");
+const model_registry_1 = require("./models/model-registry");
+const message_conversion_1 = require("./utils/message-conversion");
+const error_handling_1 = require("./utils/error-handling");
+/**
+ * Anthropic Provider Implementation
+ * Concrete implementation of the AI provider interface for Anthropic's Claude API
+ */
+class AnthropicProvider extends ai_provider_core_1.AIProvider {
+    constructor(config) {
+        super(config);
+        this.client = new sdk_1.default({
+            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) {
+        // Validate request
+        const validation = this.validateRequest(request);
+        if (!validation.isValid) {
+            return {
+                success: false,
+                error: validation.errors.join(', ')
+            };
+        }
+        // Validate messages
+        const messageValidation = (0, message_conversion_1.validateMessages)(request.messages);
+        if (!messageValidation.isValid) {
+            return {
+                success: false,
+                error: messageValidation.error
+            };
+        }
+        try {
+            // Convert messages to Anthropic format
+            const { system, messages } = (0, message_conversion_1.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.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 = (0, error_handling_1.handleAnthropicError)(error);
+            return {
+                success: false,
+                error: aiError.message
+            };
+        }
+    }
+    /**
+     * Generate streaming text completion
+     */
+    async *streamComplete(request) {
+        const validation = this.validateRequest(request);
+        if (!validation.isValid) {
+            throw new Error(validation.errors.join(', '));
+        }
+        const messageValidation = (0, message_conversion_1.validateMessages)(request.messages);
+        if (!messageValidation.isValid) {
+            throw new Error(messageValidation.error || 'Invalid messages');
+        }
+        try {
+            const { system, messages } = (0, message_conversion_1.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;
+            let finalStopReason;
+            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.usage;
+                    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 (0, error_handling_1.handleAnthropicError)(error);
+        }
+    }
+    /**
+     * Generate embeddings (Anthropic doesn't provide embeddings API)
+     * Returns error indicating feature not supported
+     */
+    generateEmbeddings(_request) {
+        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) {
+        // 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() {
+        // Anthropic doesn't provide a models list endpoint
+        // Return cached model information
+        return Promise.resolve(model_registry_1.ClaudeModelRegistry.getAllModels());
+    }
+    /**
+     * Check Anthropic API health
+     */
+    async checkHealth() {
+        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) {
+        // 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, prompt, model = 'claude-3-opus-20240229', maxTokens, temperature) {
+        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.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 = (0, error_handling_1.handleAnthropicError)(error);
+            return {
+                success: false,
+                error: aiError.message
+            };
+        }
+    }
+    // ============================================
+    // COST ESTIMATION (OVERRIDE)
+    // ============================================
+    /**
+     * Estimate cost using Anthropic pricing
+     */
+    estimateCost(request) {
+        const model = request.model || this.config.defaultModel || 'claude-3-opus-20240229';
+        const pricing = model_registry_1.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
+     */
+    mapStopReason(stopReason) {
+        switch (stopReason) {
+            case 'end_turn':
+                return 'stop';
+            case 'max_tokens':
+                return 'length';
+            case 'stop_sequence':
+                return 'stop';
+            default:
+                return 'stop';
+        }
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { AnthropicProvider } from './AnthropicProvider';
+export * from './types';
+export { ClaudeModelRegistry } from './models/model-registry';
+export * from './utils';

package/dist/index.js

@@ -0,0 +1,34 @@
+"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 });
+exports.ClaudeModelRegistry = exports.AnthropicProvider = void 0;
+// Main provider class
+var AnthropicProvider_1 = require("./AnthropicProvider");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return AnthropicProvider_1.AnthropicProvider; } });
+// Types
+__exportStar(require("./types"), exports);
+// Models
+var model_registry_1 = require("./models/model-registry");
+Object.defineProperty(exports, "ClaudeModelRegistry", { enumerable: true, get: function () { return model_registry_1.ClaudeModelRegistry; } });
+// Utilities
+__exportStar(require("./utils"), exports);

package/dist/models/model-registry.d.ts

@@ -0,0 +1,31 @@
+import { ModelInfo } from '@bernierllc/ai-provider-core';
+/**
+ * Claude 3 Model Registry
+ * Contains information about all available Claude models
+ */
+export declare class ClaudeModelRegistry {
+    private static models;
+    /**
+     * Initialize the model registry with Claude 3 models
+     */
+    static initialize(): void;
+    /**
+     * Get a specific model by ID
+     */
+    static getModel(modelId: string): ModelInfo | undefined;
+    /**
+     * Get all available models
+     */
+    static getAllModels(): ModelInfo[];
+    /**
+     * Check if a model ID is valid
+     */
+    static isValidModel(modelId: string): boolean;
+    /**
+     * Get pricing for a specific model
+     */
+    static getModelPricing(modelId: string): {
+        inputPrice: number;
+        outputPrice: number;
+    };
+}

package/dist/models/model-registry.js

@@ -0,0 +1,113 @@
+"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.ClaudeModelRegistry = void 0;
+/**
+ * Claude 3 Model Registry
+ * Contains information about all available Claude models
+ */
+class ClaudeModelRegistry {
+    /**
+     * Initialize the model registry with Claude 3 models
+     */
+    static initialize() {
+        const models = [
+            {
+                id: 'claude-3-opus-20240229',
+                name: 'Claude 3 Opus',
+                contextWindow: 200000,
+                maxOutputTokens: 4096,
+                pricing: {
+                    inputPricePerToken: 15 / 1000000,
+                    outputPricePerToken: 75 / 1000000,
+                    currency: 'USD'
+                },
+                capabilities: ['chat', 'completion', 'vision', 'extended-context', 'analysis'],
+                description: 'Most capable Claude model for complex tasks with superior reasoning'
+            },
+            {
+                id: 'claude-3-sonnet-20240229',
+                name: 'Claude 3 Sonnet',
+                contextWindow: 200000,
+                maxOutputTokens: 4096,
+                pricing: {
+                    inputPricePerToken: 3 / 1000000,
+                    outputPricePerToken: 15 / 1000000,
+                    currency: 'USD'
+                },
+                capabilities: ['chat', 'completion', 'vision', 'extended-context'],
+                description: 'Balanced performance and speed for most tasks'
+            },
+            {
+                id: 'claude-3-haiku-20240307',
+                name: 'Claude 3 Haiku',
+                contextWindow: 200000,
+                maxOutputTokens: 4096,
+                pricing: {
+                    inputPricePerToken: 0.25 / 1000000,
+                    outputPricePerToken: 1.25 / 1000000,
+                    currency: 'USD'
+                },
+                capabilities: ['chat', 'completion', 'vision', 'extended-context'],
+                description: 'Fastest and most compact model for quick responses'
+            }
+        ];
+        models.forEach(model => {
+            this.models.set(model.id, model);
+        });
+    }
+    /**
+     * Get a specific model by ID
+     */
+    static getModel(modelId) {
+        if (this.models.size === 0) {
+            this.initialize();
+        }
+        return this.models.get(modelId);
+    }
+    /**
+     * Get all available models
+     */
+    static getAllModels() {
+        if (this.models.size === 0) {
+            this.initialize();
+        }
+        return Array.from(this.models.values());
+    }
+    /**
+     * Check if a model ID is valid
+     */
+    static isValidModel(modelId) {
+        if (this.models.size === 0) {
+            this.initialize();
+        }
+        return this.models.has(modelId);
+    }
+    /**
+     * Get pricing for a specific model
+     */
+    static getModelPricing(modelId) {
+        const model = this.getModel(modelId);
+        if (model?.pricing) {
+            return {
+                inputPrice: model.pricing.inputPricePerToken * 1000000,
+                outputPrice: model.pricing.outputPricePerToken * 1000000
+            };
+        }
+        // Default to Sonnet pricing
+        return {
+            inputPrice: 3,
+            outputPrice: 15
+        };
+    }
+}
+exports.ClaudeModelRegistry = ClaudeModelRegistry;
+ClaudeModelRegistry.models = new Map();
+// Initialize on module load
+ClaudeModelRegistry.initialize();

package/dist/types/anthropic-types.d.ts

@@ -0,0 +1,46 @@
+import { AIProviderConfig, CompletionRequest } from '@bernierllc/ai-provider-core';
+/**
+ * Anthropic Provider Configuration
+ */
+export interface AnthropicProviderConfig extends AIProviderConfig {
+    providerName: 'anthropic';
+}
+/**
+ * Anthropic Extended Context Request
+ */
+export interface AnthropicExtendedContextRequest extends CompletionRequest {
+    enableExtendedContext?: boolean;
+}
+/**
+ * Anthropic Vision Request
+ */
+export interface AnthropicVisionRequest {
+    imageData: string | Buffer;
+    prompt: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+/**
+ * Anthropic Message Content Block
+ */
+export interface AnthropicMessageContent {
+    type: 'text' | 'image';
+    text?: string;
+    source?: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+}
+/**
+ * Anthropic Message Format (Internal)
+ */
+export interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: string | AnthropicMessageContent[];
+}
+/**
+ * Anthropic Stop Reason
+ */
+export type AnthropicStopReason = 'end_turn' | 'max_tokens' | 'stop_sequence' | null;

package/dist/types/anthropic-types.js

@@ -0,0 +1,9 @@
+"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 });

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './anthropic-types';

package/dist/types/index.js

@@ -0,0 +1,24 @@
+"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("./anthropic-types"), exports);

package/dist/utils/error-handling.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Handle Anthropic API errors and convert to provider error format
+ */
+export declare function handleAnthropicError(error: unknown): Error;
+/**
+ * Check if error is retryable
+ */
+export declare function isRetryableError(error: unknown): boolean;
+/**
+ * Get retry delay from error (if available)
+ */
+export declare function getRetryDelay(error: unknown): number | undefined;

package/dist/utils/error-handling.js

@@ -0,0 +1,67 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAnthropicError = handleAnthropicError;
+exports.isRetryableError = isRetryableError;
+exports.getRetryDelay = getRetryDelay;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+/**
+ * Handle Anthropic API errors and convert to provider error format
+ */
+function handleAnthropicError(error) {
+    if (error instanceof sdk_1.default.APIError) {
+        const status = error.status || 'unknown';
+        const message = `Anthropic API Error (${status}): ${error.message}`;
+        const providerError = new Error(message);
+        providerError.name = 'AnthropicAPIError';
+        return providerError;
+    }
+    if (error instanceof sdk_1.default.AuthenticationError) {
+        const providerError = new Error('Anthropic authentication failed. Check your API key.');
+        providerError.name = 'AnthropicAuthError';
+        return providerError;
+    }
+    if (error instanceof sdk_1.default.RateLimitError) {
+        const providerError = new Error('Anthropic rate limit exceeded. Please retry after a delay.');
+        providerError.name = 'AnthropicRateLimitError';
+        return providerError;
+    }
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(`Unknown Anthropic error: ${String(error)}`);
+}
+/**
+ * Check if error is retryable
+ */
+function isRetryableError(error) {
+    if (error instanceof sdk_1.default.APIError) {
+        // Retry on 5xx errors and rate limits
+        const status = error.status || 0;
+        return status >= 500 || status === 429;
+    }
+    if (error instanceof sdk_1.default.RateLimitError) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Get retry delay from error (if available)
+ */
+function getRetryDelay(error) {
+    if (error instanceof sdk_1.default.RateLimitError) {
+        // Check for Retry-After header if available
+        // Default to 1 second if not specified
+        return 1000;
+    }
+    return undefined;
+}