overai 1.4.0

package/dist/llm/providers/ai-sdk/types.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * AI SDK Backend Types
+ *
+ * Type definitions for the AI SDK integration with praisonai-ts.
+ * These types define the configuration, errors, and stream chunk formats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADAPTERS = exports.COMMUNITY_PROVIDERS = exports.PROVIDER_ALIASES = exports.AISDK_PROVIDERS = exports.SAFE_DEFAULTS = exports.AISDKError = void 0;
+/**
+ * Custom error class for AI SDK errors
+ */
+class AISDKError extends Error {
+    constructor(message, code, isRetryable, cause, statusCode) {
+        super(message);
+        this.name = 'AISDKError';
+        this.code = code;
+        this.isRetryable = isRetryable;
+        this.cause = cause;
+        this.statusCode = statusCode;
+        // Maintain proper stack trace in V8
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, AISDKError);
+        }
+    }
+}
+exports.AISDKError = AISDKError;
+/**
+ * Safe defaults for AI SDK backend
+ */
+exports.SAFE_DEFAULTS = {
+    timeout: 60000, // 60s request timeout
+    maxRetries: 2, // Retry on transient failures
+    maxOutputTokens: 4096, // Prevent runaway generation
+    redactLogs: true, // Never log API keys
+    debugLogging: false, // Opt-in verbose logging
+};
+/**
+ * Default modalities for chat-only providers
+ */
+const CHAT_ONLY = {
+    text: true, chat: true, embeddings: false, image: false, audio: false, speech: false, tools: true
+};
+/**
+ * Full modalities for providers with embeddings
+ */
+const CHAT_EMBED = {
+    text: true, chat: true, embeddings: true, image: false, audio: false, speech: false, tools: true
+};
+/**
+ * Modalities for image generation providers
+ */
+const IMAGE_GEN = {
+    text: false, chat: false, embeddings: false, image: true, audio: false, speech: false, tools: false
+};
+/**
+ * Modalities for audio/speech providers
+ */
+const AUDIO_SPEECH = {
+    text: false, chat: false, embeddings: false, image: false, audio: true, speech: true, tools: false
+};
+/**
+ * Full multimodal support
+ */
+const MULTIMODAL = {
+    text: true, chat: true, embeddings: true, image: true, audio: true, speech: true, tools: true
+};
+/**
+ * Supported AI SDK providers with their package names and capabilities
+ * Comprehensive list covering all AI SDK v6 providers
+ */
+exports.AISDK_PROVIDERS = {
+    // === Core Providers (Official AI SDK) ===
+    openai: { package: '@ai-sdk/openai', envKey: 'OPENAI_API_KEY', modalities: MULTIMODAL, description: 'OpenAI GPT models' },
+    anthropic: { package: '@ai-sdk/anthropic', envKey: 'ANTHROPIC_API_KEY', modalities: { ...CHAT_ONLY, image: true }, description: 'Anthropic Claude models' },
+    google: { package: '@ai-sdk/google', envKey: 'GOOGLE_API_KEY', modalities: MULTIMODAL, description: 'Google Generative AI (Gemini)' },
+    'google-vertex': { package: '@ai-sdk/google-vertex', envKey: 'GOOGLE_APPLICATION_CREDENTIALS', modalities: MULTIMODAL, description: 'Google Vertex AI' },
+    azure: { package: '@ai-sdk/azure', envKey: 'AZURE_API_KEY', modalities: MULTIMODAL, description: 'Azure OpenAI Service' },
+    'amazon-bedrock': { package: '@ai-sdk/amazon-bedrock', envKey: 'AWS_ACCESS_KEY_ID', modalities: CHAT_EMBED, description: 'Amazon Bedrock' },
+    // === xAI / Grok ===
+    xai: { package: '@ai-sdk/xai', envKey: 'XAI_API_KEY', modalities: { ...CHAT_ONLY, image: true }, description: 'xAI Grok models' },
+    // === Vercel ===
+    vercel: { package: '@ai-sdk/vercel', envKey: 'VERCEL_API_KEY', modalities: CHAT_ONLY, description: 'Vercel AI models' },
+    // === Inference Providers ===
+    groq: { package: '@ai-sdk/groq', envKey: 'GROQ_API_KEY', modalities: CHAT_ONLY, description: 'Groq inference' },
+    fireworks: { package: '@ai-sdk/fireworks', envKey: 'FIREWORKS_API_KEY', modalities: CHAT_EMBED, description: 'Fireworks AI' },
+    togetherai: { package: '@ai-sdk/togetherai', envKey: 'TOGETHER_API_KEY', modalities: CHAT_EMBED, description: 'Together.ai' },
+    deepinfra: { package: '@ai-sdk/deepinfra', envKey: 'DEEPINFRA_API_KEY', modalities: CHAT_EMBED, description: 'DeepInfra' },
+    replicate: { package: '@ai-sdk/replicate', envKey: 'REPLICATE_API_TOKEN', modalities: { ...CHAT_ONLY, image: true }, description: 'Replicate' },
+    baseten: { package: '@ai-sdk/baseten', envKey: 'BASETEN_API_KEY', modalities: CHAT_ONLY, description: 'Baseten' },
+    huggingface: { package: '@ai-sdk/huggingface', envKey: 'HUGGINGFACE_API_KEY', modalities: CHAT_EMBED, description: 'Hugging Face Inference' },
+    // === Model Providers ===
+    mistral: { package: '@ai-sdk/mistral', envKey: 'MISTRAL_API_KEY', modalities: CHAT_EMBED, description: 'Mistral AI' },
+    cohere: { package: '@ai-sdk/cohere', envKey: 'COHERE_API_KEY', modalities: CHAT_EMBED, description: 'Cohere' },
+    deepseek: { package: '@ai-sdk/deepseek', envKey: 'DEEPSEEK_API_KEY', modalities: CHAT_ONLY, description: 'DeepSeek' },
+    cerebras: { package: '@ai-sdk/cerebras', envKey: 'CEREBRAS_API_KEY', modalities: CHAT_ONLY, description: 'Cerebras' },
+    perplexity: { package: '@ai-sdk/perplexity', envKey: 'PERPLEXITY_API_KEY', modalities: CHAT_ONLY, description: 'Perplexity AI' },
+    // === Image Generation ===
+    fal: { package: '@ai-sdk/fal', envKey: 'FAL_KEY', modalities: IMAGE_GEN, description: 'Fal.ai image generation' },
+    'black-forest-labs': { package: '@ai-sdk/black-forest-labs', envKey: 'BFL_API_KEY', modalities: IMAGE_GEN, description: 'Black Forest Labs (FLUX)' },
+    luma: { package: '@ai-sdk/luma', envKey: 'LUMA_API_KEY', modalities: IMAGE_GEN, description: 'Luma AI video generation' },
+    // === Audio/Speech Providers ===
+    elevenlabs: { package: '@ai-sdk/elevenlabs', envKey: 'ELEVENLABS_API_KEY', modalities: AUDIO_SPEECH, description: 'ElevenLabs TTS' },
+    assemblyai: { package: '@ai-sdk/assemblyai', envKey: 'ASSEMBLYAI_API_KEY', modalities: AUDIO_SPEECH, description: 'AssemblyAI transcription' },
+    deepgram: { package: '@ai-sdk/deepgram', envKey: 'DEEPGRAM_API_KEY', modalities: AUDIO_SPEECH, description: 'Deepgram speech' },
+    gladia: { package: '@ai-sdk/gladia', envKey: 'GLADIA_API_KEY', modalities: AUDIO_SPEECH, description: 'Gladia transcription' },
+    lmnt: { package: '@ai-sdk/lmnt', envKey: 'LMNT_API_KEY', modalities: AUDIO_SPEECH, description: 'LMNT TTS' },
+    hume: { package: '@ai-sdk/hume', envKey: 'HUME_API_KEY', modalities: AUDIO_SPEECH, description: 'Hume AI emotion' },
+    revai: { package: '@ai-sdk/revai', envKey: 'REVAI_API_KEY', modalities: AUDIO_SPEECH, description: 'Rev.ai transcription' },
+    // === Gateway/Proxy Providers ===
+    'ai-gateway': { package: '@ai-sdk/gateway', envKey: 'AI_GATEWAY_API_KEY', modalities: CHAT_EMBED, description: 'AI Gateway' },
+    openrouter: { package: '@openrouter/ai-sdk-provider', envKey: 'OPENROUTER_API_KEY', modalities: CHAT_EMBED, description: 'OpenRouter' },
+    portkey: { package: '@portkey-ai/vercel-provider', envKey: 'PORTKEY_API_KEY', modalities: CHAT_EMBED, description: 'Portkey AI Gateway' },
+    helicone: { package: '@helicone/ai-sdk', envKey: 'HELICONE_API_KEY', modalities: CHAT_EMBED, description: 'Helicone proxy' },
+    // === Cloudflare ===
+    'cloudflare-workers-ai': { package: '@ai-sdk/cloudflare', envKey: 'CLOUDFLARE_API_TOKEN', modalities: CHAT_EMBED, description: 'Cloudflare Workers AI' },
+    'cloudflare-ai-gateway': { package: '@ai-sdk/cloudflare', envKey: 'CLOUDFLARE_API_TOKEN', modalities: CHAT_EMBED, description: 'Cloudflare AI Gateway' },
+    // === Local/Self-hosted ===
+    ollama: { package: 'ollama-ai-provider', envKey: 'OLLAMA_BASE_URL', modalities: CHAT_EMBED, description: 'Ollama local models' },
+    'lm-studio': { package: '@ai-sdk/openai-compatible', envKey: 'LM_STUDIO_BASE_URL', modalities: CHAT_ONLY, description: 'LM Studio' },
+    'nvidia-nim': { package: '@ai-sdk/openai-compatible', envKey: 'NVIDIA_API_KEY', modalities: CHAT_EMBED, description: 'NVIDIA NIM' },
+    // === OpenAI Compatible ===
+    'openai-compatible': { package: '@ai-sdk/openai-compatible', envKey: 'OPENAI_COMPATIBLE_API_KEY', modalities: CHAT_EMBED, description: 'OpenAI-compatible endpoints' },
+    // === Regional/Specialized Providers ===
+    qwen: { package: '@ai-sdk/qwen', envKey: 'DASHSCOPE_API_KEY', modalities: CHAT_EMBED, description: 'Alibaba Qwen' },
+    'zhipu-ai': { package: '@ai-sdk/zhipu', envKey: 'ZHIPU_API_KEY', modalities: CHAT_EMBED, description: 'Zhipu AI (GLM)' },
+    minimax: { package: '@ai-sdk/minimax', envKey: 'MINIMAX_API_KEY', modalities: CHAT_ONLY, description: 'MiniMax' },
+    spark: { package: '@ai-sdk/spark', envKey: 'SPARK_API_KEY', modalities: CHAT_ONLY, description: 'iFlytek Spark' },
+    sambanova: { package: '@ai-sdk/sambanova', envKey: 'SAMBANOVA_API_KEY', modalities: CHAT_ONLY, description: 'SambaNova' },
+    // === Embedding Specialists ===
+    'voyage-ai': { package: '@ai-sdk/voyage', envKey: 'VOYAGE_API_KEY', modalities: { ...CHAT_ONLY, embeddings: true, tools: false }, description: 'Voyage AI embeddings' },
+    'jina-ai': { package: '@ai-sdk/jina', envKey: 'JINA_API_KEY', modalities: { ...CHAT_ONLY, embeddings: true, tools: false }, description: 'Jina AI embeddings' },
+    mixedbread: { package: '@ai-sdk/mixedbread', envKey: 'MIXEDBREAD_API_KEY', modalities: { ...CHAT_ONLY, embeddings: true, tools: false }, description: 'Mixedbread embeddings' },
+    // === Memory/Agent Providers ===
+    mem0: { package: '@mem0ai/vercel-ai-provider', envKey: 'MEM0_API_KEY', modalities: CHAT_ONLY, description: 'Mem0 memory layer' },
+    letta: { package: '@letta-ai/vercel-ai-provider', envKey: 'LETTA_API_KEY', modalities: CHAT_ONLY, description: 'Letta agent memory' },
+    // === Enterprise/Cloud ===
+    'azure-ai': { package: '@ai-sdk/azure', envKey: 'AZURE_API_KEY', modalities: CHAT_EMBED, description: 'Azure AI Services' },
+    'sap-ai-core': { package: '@sap-ai-sdk/ai-core', envKey: 'SAP_AI_CORE_KEY', modalities: CHAT_ONLY, description: 'SAP AI Core' },
+    // === Other Providers ===
+    friendliai: { package: '@friendliai/ai-provider', envKey: 'FRIENDLI_TOKEN', modalities: CHAT_ONLY, description: 'FriendliAI' },
+    runpod: { package: '@runpod/ai-sdk', envKey: 'RUNPOD_API_KEY', modalities: CHAT_ONLY, description: 'RunPod serverless' },
+    clarifai: { package: '@clarifai/ai-sdk', envKey: 'CLARIFAI_PAT', modalities: { ...CHAT_ONLY, image: true }, description: 'Clarifai' },
+    'inflection-ai': { package: '@ai-sdk/inflection', envKey: 'INFLECTION_API_KEY', modalities: CHAT_ONLY, description: 'Inflection AI (Pi)' },
+    dify: { package: '@dify-ai/ai-sdk', envKey: 'DIFY_API_KEY', modalities: CHAT_ONLY, description: 'Dify platform' },
+    sarvam: { package: '@sarvam-ai/ai-sdk', envKey: 'SARVAM_API_KEY', modalities: CHAT_ONLY, description: 'Sarvam AI (Indic)' },
+    'aiml-api': { package: '@aimlapi/ai-sdk', envKey: 'AIML_API_KEY', modalities: CHAT_EMBED, description: 'AI/ML API' },
+    aihubmix: { package: '@aihubmix/ai-sdk', envKey: 'AIHUBMIX_API_KEY', modalities: CHAT_ONLY, description: 'AIHubMix' },
+    crosshatch: { package: '@crosshatch/ai-sdk', envKey: 'CROSSHATCH_API_KEY', modalities: CHAT_ONLY, description: 'Crosshatch' },
+    langdb: { package: '@langdb/ai-sdk', envKey: 'LANGDB_API_KEY', modalities: CHAT_ONLY, description: 'LangDB' },
+    requesty: { package: '@requesty/ai-sdk', envKey: 'REQUESTY_API_KEY', modalities: CHAT_ONLY, description: 'Requesty' },
+    // === Anthropic Vertex ===
+    'anthropic-vertex': { package: '@anthropic-ai/vertex-sdk', envKey: 'GOOGLE_APPLICATION_CREDENTIALS', modalities: { ...CHAT_ONLY, image: true }, description: 'Anthropic via Vertex AI' },
+    // === Heroku ===
+    heroku: { package: '@heroku/ai-sdk', envKey: 'HEROKU_API_KEY', modalities: CHAT_ONLY, description: 'Heroku AI' },
+};
+/**
+ * Provider aliases for convenience
+ */
+exports.PROVIDER_ALIASES = {
+    // Core aliases
+    oai: 'openai',
+    claude: 'anthropic',
+    gemini: 'google',
+    gcp: 'google',
+    vertex: 'google-vertex',
+    'vertex-ai': 'google-vertex',
+    // Cloud aliases
+    aws: 'amazon-bedrock',
+    bedrock: 'amazon-bedrock',
+    'azure-openai': 'azure',
+    // Inference aliases
+    together: 'togetherai',
+    'together-ai': 'togetherai',
+    pplx: 'perplexity',
+    grok: 'xai',
+    // Image aliases
+    flux: 'black-forest-labs',
+    bfl: 'black-forest-labs',
+    // Audio aliases
+    '11labs': 'elevenlabs',
+    // Gateway aliases
+    'cf-ai': 'cloudflare-workers-ai',
+    'cf-gateway': 'cloudflare-ai-gateway',
+    cloudflare: 'cloudflare-workers-ai',
+    // Local aliases
+    local: 'ollama',
+    lmstudio: 'lm-studio',
+    nim: 'nvidia-nim',
+    nvidia: 'nvidia-nim',
+    // Regional aliases
+    alibaba: 'qwen',
+    dashscope: 'qwen',
+    glm: 'zhipu-ai',
+    zhipu: 'zhipu-ai',
+    iflytek: 'spark',
+    // Other aliases
+    voyage: 'voyage-ai',
+    jina: 'jina-ai',
+    'ai-ml': 'aiml-api',
+    inflection: 'inflection-ai',
+    pi: 'inflection-ai',
+};
+/**
+ * Known community providers (not bundled, user must install)
+ */
+exports.COMMUNITY_PROVIDERS = [
+    { name: 'a2a', package: '@anthropic/a2a-sdk', envKey: 'A2A_API_KEY', description: 'Anthropic A2A protocol' },
+    { name: 'acp', package: '@acp/ai-sdk', envKey: 'ACP_API_KEY', description: 'Agent Client Protocol' },
+    { name: 'firemoon', package: '@firemoon/ai-sdk', envKey: 'FIREMOON_API_KEY', description: 'Firemoon AI' },
+    { name: 'supermemory', package: '@supermemory/ai-sdk', envKey: 'SUPERMEMORY_API_KEY', description: 'Supermemory' },
+    { name: 'react-native-apple', package: '@react-native-ai/apple', envKey: '', description: 'React Native Apple AI' },
+    { name: 'claude-code', package: '@anthropic/claude-code', envKey: 'ANTHROPIC_API_KEY', description: 'Claude Code CLI' },
+    { name: 'gemini-cli', package: '@google/gemini-cli', envKey: 'GOOGLE_API_KEY', description: 'Gemini CLI' },
+    { name: 'built-in-ai', package: '@anthropic/built-in-ai', envKey: '', description: 'Browser built-in AI' },
+    { name: 'mcp-sampling', package: '@modelcontextprotocol/sampling', envKey: '', description: 'MCP Sampling Provider' },
+    { name: 'automatic1111', package: '@a1111/ai-sdk', envKey: 'A1111_BASE_URL', description: 'Automatic1111 Stable Diffusion' },
+];
+exports.ADAPTERS = [
+    { name: 'langchain', package: '@ai-sdk/langchain', description: 'LangChain adapter', type: 'langchain' },
+    { name: 'llamaindex', package: '@ai-sdk/llamaindex', description: 'LlamaIndex adapter', type: 'llamaindex' },
+];

package/dist/llm/providers/anthropic.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Anthropic Provider - Implementation for Anthropic Claude API
+ */
+import { BaseProvider } from './base';
+import type { ProviderConfig, GenerateTextOptions, GenerateTextResult, StreamTextOptions, StreamChunk, GenerateObjectOptions, GenerateObjectResult, Message, ToolDefinition } from './types';
+interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: string | Array<{
+        type: string;
+        text?: string;
+        tool_use_id?: string;
+        content?: string;
+    }>;
+}
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: Record<string, any>;
+}
+export declare class AnthropicProvider extends BaseProvider {
+    readonly providerId = "anthropic";
+    private apiKey;
+    private baseUrl;
+    constructor(modelId: string, config?: ProviderConfig);
+    generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+    streamText(options: StreamTextOptions): Promise<AsyncIterable<StreamChunk>>;
+    generateObject<T = any>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+    private extractSystemPrompt;
+    protected formatMessages(messages: Message[]): AnthropicMessage[];
+    protected formatTools(tools: ToolDefinition[]): AnthropicTool[];
+    private mapStopReason;
+}
+export {};

package/dist/llm/providers/anthropic.js

@@ -0,0 +1,291 @@
+"use strict";
+/**
+ * Anthropic Provider - Implementation for Anthropic Claude API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+const base_1 = require("./base");
+class AnthropicProvider extends base_1.BaseProvider {
+    constructor(modelId, config = {}) {
+        super(modelId, config);
+        this.providerId = 'anthropic';
+        this.apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || '';
+        this.baseUrl = config.baseUrl || 'https://api.anthropic.com';
+        if (!this.apiKey) {
+            throw new Error('ANTHROPIC_API_KEY is required');
+        }
+    }
+    async generateText(options) {
+        return this.withRetry(async () => {
+            const { systemPrompt, messages } = this.extractSystemPrompt(options.messages);
+            const response = await fetch(`${this.baseUrl}/v1/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.apiKey,
+                    'anthropic-version': '2023-06-01',
+                },
+                body: JSON.stringify({
+                    model: this.modelId,
+                    max_tokens: options.maxTokens || 4096,
+                    system: systemPrompt,
+                    messages: this.formatMessages(messages),
+                    temperature: options.temperature ?? 0.7,
+                    tools: options.tools ? this.formatTools(options.tools) : undefined,
+                    stop_sequences: options.stop,
+                    top_p: options.topP,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw Object.assign(new Error(error.error?.message || `Anthropic API error: ${response.status}`), {
+                    status: response.status,
+                });
+            }
+            const data = await response.json();
+            let text = '';
+            const toolCalls = [];
+            for (const block of data.content || []) {
+                if (block.type === 'text') {
+                    text += block.text;
+                }
+                else if (block.type === 'tool_use') {
+                    toolCalls.push({
+                        id: block.id,
+                        type: 'function',
+                        function: {
+                            name: block.name,
+                            arguments: JSON.stringify(block.input),
+                        },
+                    });
+                }
+            }
+            return {
+                text,
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                usage: {
+                    promptTokens: data.usage?.input_tokens || 0,
+                    completionTokens: data.usage?.output_tokens || 0,
+                    totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0),
+                },
+                finishReason: this.mapStopReason(data.stop_reason),
+                raw: data,
+            };
+        });
+    }
+    async streamText(options) {
+        const self = this;
+        const { systemPrompt, messages } = this.extractSystemPrompt(options.messages);
+        return {
+            async *[Symbol.asyncIterator]() {
+                const response = await fetch(`${self.baseUrl}/v1/messages`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-api-key': self.apiKey,
+                        'anthropic-version': '2023-06-01',
+                    },
+                    body: JSON.stringify({
+                        model: self.modelId,
+                        max_tokens: options.maxTokens || 4096,
+                        system: systemPrompt,
+                        messages: self.formatMessages(messages),
+                        temperature: options.temperature ?? 0.7,
+                        tools: options.tools ? self.formatTools(options.tools) : undefined,
+                        stream: true,
+                    }),
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({}));
+                    throw new Error(error.error?.message || `Anthropic API error: ${response.status}`);
+                }
+                const reader = response.body?.getReader();
+                if (!reader)
+                    throw new Error('No response body');
+                const decoder = new TextDecoder();
+                let buffer = '';
+                const toolCalls = [];
+                let currentToolCall = null;
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const data = line.slice(6);
+                        if (data === '[DONE]')
+                            continue;
+                        try {
+                            const event = JSON.parse(data);
+                            if (event.type === 'content_block_delta') {
+                                if (event.delta?.type === 'text_delta') {
+                                    const text = event.delta.text;
+                                    if (options.onToken)
+                                        options.onToken(text);
+                                    yield { text };
+                                }
+                                else if (event.delta?.type === 'input_json_delta') {
+                                    if (currentToolCall) {
+                                        currentToolCall.function.arguments += event.delta.partial_json;
+                                    }
+                                }
+                            }
+                            else if (event.type === 'content_block_start') {
+                                if (event.content_block?.type === 'tool_use') {
+                                    currentToolCall = {
+                                        id: event.content_block.id,
+                                        type: 'function',
+                                        function: {
+                                            name: event.content_block.name,
+                                            arguments: '',
+                                        },
+                                    };
+                                }
+                            }
+                            else if (event.type === 'content_block_stop') {
+                                if (currentToolCall) {
+                                    toolCalls.push(currentToolCall);
+                                    currentToolCall = null;
+                                }
+                            }
+                            else if (event.type === 'message_delta') {
+                                yield {
+                                    finishReason: self.mapStopReason(event.delta?.stop_reason),
+                                    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                                    usage: event.usage ? {
+                                        promptTokens: 0,
+                                        completionTokens: event.usage.output_tokens,
+                                        totalTokens: event.usage.output_tokens,
+                                    } : undefined,
+                                };
+                            }
+                        }
+                        catch (e) {
+                            // Skip malformed JSON
+                        }
+                    }
+                }
+            },
+        };
+    }
+    async generateObject(options) {
+        const { systemPrompt, messages } = this.extractSystemPrompt(options.messages);
+        // Add JSON instruction to system prompt
+        const jsonSystemPrompt = `${systemPrompt}\n\nYou must respond with valid JSON matching this schema:\n${JSON.stringify(options.schema, null, 2)}`;
+        return this.withRetry(async () => {
+            const response = await fetch(`${this.baseUrl}/v1/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.apiKey,
+                    'anthropic-version': '2023-06-01',
+                },
+                body: JSON.stringify({
+                    model: this.modelId,
+                    max_tokens: options.maxTokens || 4096,
+                    system: jsonSystemPrompt,
+                    messages: this.formatMessages(messages),
+                    temperature: options.temperature ?? 0.7,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || `Anthropic API error: ${response.status}`);
+            }
+            const data = await response.json();
+            let text = '';
+            for (const block of data.content || []) {
+                if (block.type === 'text') {
+                    text += block.text;
+                }
+            }
+            // Extract JSON from response
+            const jsonMatch = text.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                throw new Error(`No JSON found in response: ${text}`);
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(jsonMatch[0]);
+            }
+            catch (e) {
+                throw new Error(`Failed to parse JSON: ${jsonMatch[0]}`);
+            }
+            return {
+                object: parsed,
+                usage: {
+                    promptTokens: data.usage?.input_tokens || 0,
+                    completionTokens: data.usage?.output_tokens || 0,
+                    totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0),
+                },
+                raw: data,
+            };
+        });
+    }
+    extractSystemPrompt(messages) {
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const otherMessages = messages.filter(m => m.role !== 'system');
+        const systemPrompt = systemMessages.map(m => m.content).join('\n');
+        return { systemPrompt, messages: otherMessages };
+    }
+    formatMessages(messages) {
+        const result = [];
+        for (const msg of messages) {
+            if (msg.role === 'system')
+                continue; // Handled separately
+            if (msg.role === 'tool') {
+                // Tool results need to be part of user message in Anthropic
+                result.push({
+                    role: 'user',
+                    content: [{
+                            type: 'tool_result',
+                            tool_use_id: msg.tool_call_id || '',
+                            content: msg.content || '',
+                        }],
+                });
+            }
+            else if (msg.role === 'assistant' && msg.tool_calls) {
+                const content = [];
+                if (msg.content) {
+                    content.push({ type: 'text', text: msg.content });
+                }
+                for (const tc of msg.tool_calls) {
+                    content.push({
+                        type: 'tool_use',
+                        id: tc.id,
+                        name: tc.function.name,
+                        input: JSON.parse(tc.function.arguments),
+                    });
+                }
+                result.push({ role: 'assistant', content });
+            }
+            else {
+                result.push({
+                    role: msg.role,
+                    content: msg.content || '',
+                });
+            }
+        }
+        return result;
+    }
+    formatTools(tools) {
+        return tools.map(tool => ({
+            name: tool.name,
+            description: tool.description || `Function ${tool.name}`,
+            input_schema: tool.parameters || { type: 'object', properties: {} },
+        }));
+    }
+    mapStopReason(reason) {
+        switch (reason) {
+            case 'end_turn': return 'stop';
+            case 'max_tokens': return 'length';
+            case 'tool_use': return 'tool_calls';
+            default: return 'stop';
+        }
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;

package/dist/llm/providers/base.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Base Provider - Abstract base class for LLM providers
+ */
+import type { LLMProvider, ProviderConfig, GenerateTextOptions, GenerateTextResult, StreamTextOptions, StreamChunk, GenerateObjectOptions, GenerateObjectResult, Message, ToolDefinition } from './types';
+export declare abstract class BaseProvider implements LLMProvider {
+    abstract readonly providerId: string;
+    readonly modelId: string;
+    protected config: ProviderConfig;
+    constructor(modelId: string, config?: ProviderConfig);
+    abstract generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+    abstract streamText(options: StreamTextOptions): Promise<AsyncIterable<StreamChunk>>;
+    abstract generateObject<T = any>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+    /**
+     * Convert tool definitions to provider-specific format
+     */
+    protected abstract formatTools(tools: ToolDefinition[]): any[];
+    /**
+     * Convert messages to provider-specific format
+     */
+    protected abstract formatMessages(messages: Message[]): any[];
+    /**
+     * Retry logic with exponential backoff
+     */
+    protected withRetry<T>(fn: () => Promise<T>, maxRetries?: number): Promise<T>;
+}

package/dist/llm/providers/base.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Base Provider - Abstract base class for LLM providers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProvider = void 0;
+class BaseProvider {
+    constructor(modelId, config = {}) {
+        this.modelId = modelId;
+        this.config = {
+            maxRetries: 3,
+            timeout: 60000,
+            ...config,
+        };
+    }
+    /**
+     * Retry logic with exponential backoff
+     */
+    async withRetry(fn, maxRetries = this.config.maxRetries || 3) {
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                // Check if error is retryable (rate limit, server error)
+                const isRetryable = error.status === 429 ||
+                    error.status >= 500 ||
+                    error.code === 'ECONNRESET' ||
+                    error.code === 'ETIMEDOUT';
+                if (!isRetryable || attempt === maxRetries) {
+                    throw error;
+                }
+                // Exponential backoff
+                const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+        throw lastError;
+    }
+}
+exports.BaseProvider = BaseProvider;

package/dist/llm/providers/google.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Google Provider - Implementation for Google Gemini API
+ */
+import { BaseProvider } from './base';
+import type { ProviderConfig, GenerateTextOptions, GenerateTextResult, StreamTextOptions, StreamChunk, GenerateObjectOptions, GenerateObjectResult, Message, ToolDefinition } from './types';
+interface GeminiContent {
+    role: 'user' | 'model';
+    parts: Array<{
+        text?: string;
+        functionCall?: any;
+        functionResponse?: any;
+    }>;
+}
+export declare class GoogleProvider extends BaseProvider {
+    readonly providerId = "google";
+    private apiKey;
+    private baseUrl;
+    constructor(modelId: string, config?: ProviderConfig);
+    generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+    streamText(options: StreamTextOptions): Promise<AsyncIterable<StreamChunk>>;
+    generateObject<T = any>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+    private formatRequest;
+    protected formatMessages(messages: Message[]): GeminiContent[];
+    protected formatTools(tools: ToolDefinition[]): any[];
+    private mapFinishReason;
+}
+export {};