clodds 1.1.0

package/dist/providers/index.js

@@ -0,0 +1,897 @@
+"use strict";
+/**
+ * Providers Module - Clawdbot-style model provider management
+ *
+ * Features:
+ * - Multiple AI model providers (Anthropic, OpenAI, etc.)
+ * - Unified API interface
+ * - Streaming support
+ * - Fallback chains
+ * - Rate limiting
+ * - Cost tracking
+ * - Retry with exponential backoff
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProviderHealthMonitor = exports.providers = exports.ProviderManager = exports.OllamaProvider = exports.OpenAIProvider = exports.AnthropicProvider = exports.GeminiProvider = void 0;
+exports.calculateCost = calculateCost;
+exports.createProviders = createProviders;
+const events_1 = require("events");
+const logger_1 = require("../utils/logger");
+const retry_1 = require("../infra/retry");
+const discovery_1 = require("./discovery");
+// =============================================================================
+// GEMINI PROVIDER (Google Generative Language API)
+// =============================================================================
+class GeminiProvider {
+    name = 'gemini';
+    apiKey;
+    baseUrl = 'https://generativelanguage.googleapis.com/v1beta';
+    defaultModel = process.env.CLODDS_GEMINI_MODEL || 'gemini-1.5-pro';
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    endpoint(model, method) {
+        const cleanModel = model.startsWith('models/') ? model : `models/${model}`;
+        return `${this.baseUrl}/${cleanModel}:${method}?key=${this.apiKey}`;
+    }
+    toGeminiMessages(messages) {
+        const system = messages.filter(m => m.role === 'system').map(m => m.content).join('\n\n').trim();
+        const rest = messages.filter(m => m.role !== 'system');
+        const mapped = rest.map((m) => {
+            const role = m.role === 'assistant' ? 'model' : 'user';
+            return {
+                role,
+                parts: [{ text: m.content }],
+            };
+        });
+        if (system) {
+            mapped.unshift({
+                role: 'user',
+                parts: [{ text: `System instruction:\n${system}` }],
+            });
+        }
+        return mapped;
+    }
+    async complete(messages, options = {}) {
+        const startTime = Date.now();
+        const model = options.model || this.defaultModel;
+        const response = await fetch(this.endpoint(model, 'generateContent'), {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                contents: this.toGeminiMessages(messages),
+                generationConfig: {
+                    temperature: options.temperature,
+                    topP: options.topP,
+                    maxOutputTokens: options.maxTokens,
+                    stopSequences: options.stopSequences,
+                },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Gemini error: ${response.status}`);
+        }
+        const data = await response.json();
+        const content = data.candidates?.[0]?.content?.parts?.map(p => p.text || '').join('') || '';
+        const finish = data.candidates?.[0]?.finishReason;
+        return {
+            content,
+            model: data.modelVersion || model,
+            usage: {
+                inputTokens: data.usageMetadata?.promptTokenCount || 0,
+                outputTokens: data.usageMetadata?.candidatesTokenCount || 0,
+                totalTokens: data.usageMetadata?.totalTokenCount || 0,
+            },
+            finishReason: finish === 'STOP' ? 'end_turn' : 'end_turn',
+            latency: Date.now() - startTime,
+        };
+    }
+    async *stream(messages, options = {}) {
+        const model = options.model || this.defaultModel;
+        const response = await fetch(this.endpoint(model, 'streamGenerateContent'), {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                contents: this.toGeminiMessages(messages),
+                generationConfig: {
+                    temperature: options.temperature,
+                    topP: options.topP,
+                    maxOutputTokens: options.maxTokens,
+                    stopSequences: options.stopSequences,
+                },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Gemini streaming error: ${response.status}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            // Gemini streaming responses are JSON lines.
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const event = JSON.parse(trimmed);
+                    const content = event.candidates?.[0]?.content?.parts?.map(p => p.text || '').join('') || '';
+                    if (content) {
+                        yield { content, done: false };
+                    }
+                }
+                catch {
+                    // Ignore malformed chunks.
+                }
+            }
+        }
+        yield { content: '', done: true };
+    }
+    async listModels() {
+        try {
+            const response = await fetch(`${this.baseUrl}/models?key=${this.apiKey}`);
+            if (!response.ok)
+                return [];
+            const data = await response.json();
+            return data.models?.map(m => m.name.replace(/^models\//, '')) || [];
+        }
+        catch {
+            return [];
+        }
+    }
+    async isAvailable() {
+        try {
+            const models = await this.listModels();
+            return models.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.GeminiProvider = GeminiProvider;
+// =============================================================================
+// ANTHROPIC PROVIDER
+// =============================================================================
+class AnthropicProvider {
+    name = 'anthropic';
+    config;
+    retryConfig;
+    constructor(config) {
+        this.config = {
+            baseUrl: 'https://api.anthropic.com',
+            defaultModel: 'claude-3-5-sonnet-20241022',
+            timeout: 120000,
+            maxRetries: 3,
+            ...config,
+        };
+        // Set up retry configuration
+        const policy = config.retryPolicy ? retry_1.RETRY_POLICIES[config.retryPolicy] : retry_1.RETRY_POLICIES.anthropic;
+        this.retryConfig = {
+            ...policy?.config,
+            ...config.retry,
+            maxAttempts: config.maxRetries ?? policy?.config.maxAttempts ?? 3,
+            onRetry: (info) => {
+                logger_1.logger.warn({
+                    provider: 'anthropic',
+                    attempt: info.attempt,
+                    maxAttempts: info.maxAttempts,
+                    delay: info.delay,
+                    error: info.error.message,
+                }, 'Anthropic API retry');
+            },
+        };
+    }
+    async complete(messages, options = {}) {
+        const startTime = Date.now();
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const conversationMessages = messages.filter(m => m.role !== 'system');
+        const body = {
+            model: options.model || this.config.defaultModel,
+            max_tokens: options.maxTokens || 4096,
+            temperature: options.temperature,
+            top_p: options.topP,
+            stop_sequences: options.stopSequences,
+            system: systemMessages.map(m => m.content).join('\n\n') || undefined,
+            messages: conversationMessages.map(m => ({
+                role: m.role,
+                content: m.content,
+            })),
+        };
+        const response = await this.request('/v1/messages', body);
+        return {
+            content: response.content[0]?.text || '',
+            model: response.model,
+            usage: {
+                inputTokens: response.usage?.input_tokens || 0,
+                outputTokens: response.usage?.output_tokens || 0,
+                totalTokens: (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0),
+            },
+            finishReason: response.stop_reason === 'end_turn' ? 'end_turn' :
+                response.stop_reason === 'max_tokens' ? 'max_tokens' : 'end_turn',
+            latency: Date.now() - startTime,
+        };
+    }
+    async *stream(messages, options = {}) {
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const conversationMessages = messages.filter(m => m.role !== 'system');
+        const body = {
+            model: options.model || this.config.defaultModel,
+            max_tokens: options.maxTokens || 4096,
+            temperature: options.temperature,
+            top_p: options.topP,
+            stop_sequences: options.stopSequences,
+            system: systemMessages.map(m => m.content).join('\n\n') || undefined,
+            messages: conversationMessages.map(m => ({
+                role: m.role,
+                content: m.content,
+            })),
+            stream: true,
+        };
+        const response = await fetch(`${this.config.baseUrl}/v1/messages`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.config.apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`Anthropic API error: ${response.status}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        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: ')) {
+                    const data = line.slice(6);
+                    if (data === '[DONE]') {
+                        yield { content: '', done: true };
+                        return;
+                    }
+                    try {
+                        const event = JSON.parse(data);
+                        if (event.type === 'content_block_delta' && event.delta?.text) {
+                            yield { content: event.delta.text, done: false };
+                        }
+                        if (event.type === 'message_stop') {
+                            yield { content: '', done: true };
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        logger_1.logger.debug({ err: e, line }, 'Failed to parse SSE event');
+                    }
+                }
+            }
+        }
+        yield { content: '', done: true };
+    }
+    async listModels() {
+        return [
+            'claude-3-5-sonnet-20241022',
+            'claude-3-opus-20240229',
+            'claude-3-sonnet-20240229',
+            'claude-3-haiku-20240307',
+        ];
+    }
+    async isAvailable() {
+        try {
+            const response = await fetch(`${this.config.baseUrl}/v1/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.config.apiKey,
+                    'anthropic-version': '2023-06-01',
+                },
+                body: JSON.stringify({
+                    model: 'claude-3-haiku-20240307',
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'hi' }],
+                }),
+            });
+            return response.ok || response.status === 400; // 400 means auth is valid
+        }
+        catch {
+            return false;
+        }
+    }
+    async request(path, body) {
+        return (0, retry_1.withRetry)(async () => {
+            const response = await fetch(`${this.config.baseUrl}${path}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.config.apiKey,
+                    'anthropic-version': '2023-06-01',
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                const statusCode = response.status;
+                // Rate limit
+                if (statusCode === 429) {
+                    const retryAfter = response.headers.get('retry-after');
+                    throw new retry_1.RateLimitError(`Anthropic rate limited: ${statusCode} - ${errorText}`, statusCode, retryAfter ? parseInt(retryAfter, 10) * 1000 : undefined);
+                }
+                // Server errors are transient
+                if (statusCode >= 500) {
+                    throw new retry_1.TransientError(`Anthropic server error: ${statusCode} - ${errorText}`, statusCode);
+                }
+                // Client errors are not retryable
+                throw new Error(`Anthropic API error: ${statusCode} - ${errorText}`);
+            }
+            return response.json();
+        }, this.retryConfig);
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;
+// =============================================================================
+// OPENAI PROVIDER
+// =============================================================================
+class OpenAIProvider {
+    name = 'openai';
+    config;
+    retryConfig;
+    constructor(config) {
+        this.config = {
+            baseUrl: 'https://api.openai.com',
+            defaultModel: 'gpt-4o',
+            timeout: 120000,
+            maxRetries: 3,
+            ...config,
+        };
+        // Set up retry configuration
+        const policy = config.retryPolicy ? retry_1.RETRY_POLICIES[config.retryPolicy] : retry_1.RETRY_POLICIES.openai;
+        this.retryConfig = {
+            ...policy?.config,
+            ...config.retry,
+            maxAttempts: config.maxRetries ?? policy?.config.maxAttempts ?? 3,
+            onRetry: (info) => {
+                logger_1.logger.warn({
+                    provider: 'openai',
+                    attempt: info.attempt,
+                    maxAttempts: info.maxAttempts,
+                    delay: info.delay,
+                    error: info.error.message,
+                }, 'OpenAI API retry');
+            },
+        };
+    }
+    async complete(messages, options = {}) {
+        const startTime = Date.now();
+        const body = {
+            model: options.model || this.config.defaultModel,
+            max_tokens: options.maxTokens || 4096,
+            temperature: options.temperature,
+            top_p: options.topP,
+            stop: options.stopSequences,
+            messages: messages.map(m => ({
+                role: m.role,
+                content: m.content,
+            })),
+        };
+        const response = await this.request('/v1/chat/completions', body);
+        return {
+            content: response.choices[0]?.message?.content || '',
+            model: response.model,
+            usage: {
+                inputTokens: response.usage?.prompt_tokens || 0,
+                outputTokens: response.usage?.completion_tokens || 0,
+                totalTokens: response.usage?.total_tokens || 0,
+            },
+            finishReason: response.choices[0]?.finish_reason === 'stop' ? 'end_turn' :
+                response.choices[0]?.finish_reason === 'length' ? 'max_tokens' : 'end_turn',
+            latency: Date.now() - startTime,
+        };
+    }
+    async *stream(messages, options = {}) {
+        const body = {
+            model: options.model || this.config.defaultModel,
+            max_tokens: options.maxTokens || 4096,
+            temperature: options.temperature,
+            top_p: options.topP,
+            stop: options.stopSequences,
+            messages: messages.map(m => ({
+                role: m.role,
+                content: m.content,
+            })),
+            stream: true,
+        };
+        const response = await fetch(`${this.config.baseUrl}/v1/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.config.apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI API error: ${response.status}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        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: ')) {
+                    const data = line.slice(6);
+                    if (data === '[DONE]') {
+                        yield { content: '', done: true };
+                        return;
+                    }
+                    try {
+                        const event = JSON.parse(data);
+                        const content = event.choices?.[0]?.delta?.content;
+                        if (content) {
+                            yield { content, done: false };
+                        }
+                        if (event.choices?.[0]?.finish_reason) {
+                            yield { content: '', done: true };
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        logger_1.logger.debug({ err: e, line }, 'Failed to parse OpenAI SSE event');
+                    }
+                }
+            }
+        }
+        yield { content: '', done: true };
+    }
+    async listModels() {
+        const response = await this.request('/v1/models', null);
+        return response.data
+            .filter((m) => m.id.includes('gpt'))
+            .map((m) => m.id);
+    }
+    async isAvailable() {
+        try {
+            const response = await fetch(`${this.config.baseUrl}/v1/models`, {
+                headers: {
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                },
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async request(path, body) {
+        return (0, retry_1.withRetry)(async () => {
+            const response = await fetch(`${this.config.baseUrl}${path}`, {
+                method: body ? 'POST' : 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                },
+                body: body ? JSON.stringify(body) : undefined,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                const statusCode = response.status;
+                // Rate limit
+                if (statusCode === 429) {
+                    const retryAfter = response.headers.get('retry-after');
+                    throw new retry_1.RateLimitError(`OpenAI rate limited: ${statusCode} - ${errorText}`, statusCode, retryAfter ? parseInt(retryAfter, 10) * 1000 : undefined);
+                }
+                // Server errors are transient
+                if (statusCode >= 500) {
+                    throw new retry_1.TransientError(`OpenAI server error: ${statusCode} - ${errorText}`, statusCode);
+                }
+                // Client errors are not retryable
+                throw new Error(`OpenAI API error: ${statusCode} - ${errorText}`);
+            }
+            return response.json();
+        }, this.retryConfig);
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;
+// =============================================================================
+// OLLAMA PROVIDER (LOCAL)
+// =============================================================================
+class OllamaProvider {
+    name = 'ollama';
+    baseUrl;
+    defaultModel;
+    retryConfig;
+    constructor(baseUrl = 'http://localhost:11434', defaultModel = 'llama3', retryConfig) {
+        this.baseUrl = baseUrl;
+        this.defaultModel = defaultModel;
+        this.retryConfig = {
+            ...retry_1.RETRY_POLICIES.default.config,
+            ...retryConfig,
+            onRetry: (info) => {
+                logger_1.logger.warn({
+                    provider: 'ollama',
+                    attempt: info.attempt,
+                    maxAttempts: info.maxAttempts,
+                    delay: info.delay,
+                    error: info.error.message,
+                }, 'Ollama retry');
+            },
+        };
+    }
+    async complete(messages, options = {}) {
+        const startTime = Date.now();
+        return (0, retry_1.withRetry)(async () => {
+            const response = await fetch(`${this.baseUrl}/api/chat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: options.model || this.defaultModel,
+                    messages: messages.map(m => ({
+                        role: m.role,
+                        content: m.content,
+                    })),
+                    stream: false,
+                    options: {
+                        temperature: options.temperature,
+                        top_p: options.topP,
+                        num_predict: options.maxTokens,
+                        stop: options.stopSequences,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                const statusCode = response.status;
+                if (statusCode >= 500) {
+                    throw new retry_1.TransientError(`Ollama server error: ${statusCode}`, statusCode);
+                }
+                throw new Error(`Ollama error: ${statusCode}`);
+            }
+            const data = await response.json();
+            return {
+                content: data.message?.content || '',
+                model: data.model,
+                usage: {
+                    inputTokens: data.prompt_eval_count || 0,
+                    outputTokens: data.eval_count || 0,
+                    totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+                },
+                finishReason: data.done_reason === 'stop' ? 'end_turn' : 'max_tokens',
+                latency: Date.now() - startTime,
+            };
+        }, this.retryConfig);
+    }
+    async *stream(messages, options = {}) {
+        const response = await fetch(`${this.baseUrl}/api/chat`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: options.model || this.defaultModel,
+                messages: messages.map(m => ({
+                    role: m.role,
+                    content: m.content,
+                })),
+                stream: true,
+                options: {
+                    temperature: options.temperature,
+                    top_p: options.topP,
+                    num_predict: options.maxTokens,
+                    stop: options.stopSequences,
+                },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama error: ${response.status}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        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.trim())
+                    continue;
+                try {
+                    const data = JSON.parse(line);
+                    if (data.message?.content) {
+                        yield { content: data.message.content, done: false };
+                    }
+                    if (data.done) {
+                        yield { content: '', done: true };
+                        return;
+                    }
+                }
+                catch (e) {
+                    logger_1.logger.debug({ err: e, line }, 'Failed to parse Ollama stream event');
+                }
+            }
+        }
+        yield { content: '', done: true };
+    }
+    async listModels() {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/tags`);
+            if (!response.ok)
+                return [];
+            const data = await response.json();
+            return data.models?.map(m => m.name) || [];
+        }
+        catch {
+            return [];
+        }
+    }
+    async isAvailable() {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/tags`);
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.OllamaProvider = OllamaProvider;
+// =============================================================================
+// PROVIDER MANAGER
+// =============================================================================
+class ProviderManager extends events_1.EventEmitter {
+    providers = new Map();
+    defaultProvider = null;
+    fallbackChain = [];
+    circuits = new Map();
+    circuitConfig = {
+        failureThreshold: Number(process.env.CLODDS_PROVIDER_CB_FAILURE_THRESHOLD || 3),
+        cooldownMs: Number(process.env.CLODDS_PROVIDER_CB_COOLDOWN_MS || 60_000),
+        successResetThreshold: Number(process.env.CLODDS_PROVIDER_CB_SUCCESS_RESET || 2),
+    };
+    getCircuit(provider) {
+        let state = this.circuits.get(provider);
+        if (!state) {
+            state = { failures: 0, successes: 0 };
+            this.circuits.set(provider, state);
+        }
+        return state;
+    }
+    isCircuitOpen(provider) {
+        const state = this.getCircuit(provider);
+        if (!state.openUntil)
+            return false;
+        if (Date.now() >= state.openUntil) {
+            state.openUntil = undefined;
+            state.failures = 0;
+            state.successes = 0;
+            logger_1.logger.info({ provider }, 'Provider circuit cooldown expired');
+            return false;
+        }
+        return true;
+    }
+    reportSuccess(provider) {
+        const state = this.getCircuit(provider);
+        state.successes += 1;
+        state.failures = Math.max(0, state.failures - 1);
+        if (state.openUntil && state.successes >= this.circuitConfig.successResetThreshold) {
+            state.openUntil = undefined;
+            state.failures = 0;
+            state.successes = 0;
+            logger_1.logger.info({ provider }, 'Provider circuit closed after successes');
+        }
+    }
+    reportFailure(provider, error) {
+        const state = this.getCircuit(provider);
+        state.failures += 1;
+        state.successes = 0;
+        if (state.failures >= this.circuitConfig.failureThreshold) {
+            state.openUntil = Date.now() + this.circuitConfig.cooldownMs;
+            logger_1.logger.warn({
+                provider,
+                failures: state.failures,
+                openUntil: state.openUntil,
+                error: error instanceof Error ? error.message : String(error),
+            }, 'Provider circuit opened');
+        }
+    }
+    /** Register a provider */
+    register(provider) {
+        this.providers.set(provider.name, provider);
+        if (!this.defaultProvider) {
+            this.defaultProvider = provider.name;
+        }
+        return this;
+    }
+    /** Set default provider */
+    setDefault(name) {
+        if (!this.providers.has(name)) {
+            throw new Error(`Provider '${name}' not found`);
+        }
+        this.defaultProvider = name;
+        return this;
+    }
+    /** Set fallback chain */
+    setFallbackChain(providers) {
+        this.fallbackChain = providers;
+        return this;
+    }
+    /** Get a provider */
+    get(name) {
+        const providerName = name || this.defaultProvider;
+        if (!providerName) {
+            throw new Error('No provider specified and no default set');
+        }
+        const provider = this.providers.get(providerName);
+        if (!provider) {
+            throw new Error(`Provider '${providerName}' not found`);
+        }
+        return provider;
+    }
+    /** Complete with fallback */
+    async complete(messages, options = {}) {
+        const chain = options.provider ? [options.provider] : [
+            this.defaultProvider,
+            ...this.fallbackChain.filter(p => p !== this.defaultProvider),
+        ];
+        let lastError = null;
+        for (const providerName of chain) {
+            if (this.isCircuitOpen(providerName)) {
+                logger_1.logger.warn({ provider: providerName }, 'Provider circuit open, skipping');
+                continue;
+            }
+            try {
+                const provider = this.get(providerName);
+                const result = await provider.complete(messages, options);
+                this.reportSuccess(providerName);
+                this.emit('completion', { provider: providerName, result });
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                this.reportFailure(providerName, error);
+                logger_1.logger.warn({ provider: providerName, error }, 'Provider failed, trying next');
+                this.emit('fallback', { provider: providerName, error });
+            }
+        }
+        throw lastError || new Error('All providers failed');
+    }
+    /** Stream with fallback */
+    async *stream(messages, options = {}) {
+        const chain = options.provider ? [options.provider] : [
+            this.defaultProvider,
+            ...this.fallbackChain.filter(p => p !== this.defaultProvider),
+        ];
+        let lastError = null;
+        for (const providerName of chain) {
+            if (this.isCircuitOpen(providerName)) {
+                logger_1.logger.warn({ provider: providerName }, 'Provider circuit open, skipping stream');
+                continue;
+            }
+            try {
+                const provider = this.get(providerName);
+                for await (const chunk of provider.stream(messages, options)) {
+                    yield chunk;
+                }
+                this.reportSuccess(providerName);
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                this.reportFailure(providerName, error);
+                logger_1.logger.warn({ provider: providerName, error }, 'Provider streaming failed, trying next');
+            }
+        }
+        throw lastError || new Error('All providers failed');
+    }
+    /** List all providers */
+    list() {
+        return Array.from(this.providers.keys());
+    }
+    /** Check availability of all providers */
+    async checkAvailability() {
+        const results = {};
+        for (const [name, provider] of this.providers) {
+            results[name] = await provider.isAvailable();
+        }
+        return results;
+    }
+}
+exports.ProviderManager = ProviderManager;
+const MODEL_COSTS = {
+    'claude-3-5-sonnet-20241022': { inputCostPer1k: 0.003, outputCostPer1k: 0.015 },
+    'claude-3-opus-20240229': { inputCostPer1k: 0.015, outputCostPer1k: 0.075 },
+    'claude-3-sonnet-20240229': { inputCostPer1k: 0.003, outputCostPer1k: 0.015 },
+    'claude-3-haiku-20240307': { inputCostPer1k: 0.00025, outputCostPer1k: 0.00125 },
+    'gpt-4o': { inputCostPer1k: 0.005, outputCostPer1k: 0.015 },
+    'gpt-4-turbo': { inputCostPer1k: 0.01, outputCostPer1k: 0.03 },
+    'gpt-3.5-turbo': { inputCostPer1k: 0.0005, outputCostPer1k: 0.0015 },
+};
+function calculateCost(result) {
+    const costs = MODEL_COSTS[result.model];
+    if (!costs)
+        return 0;
+    return ((result.usage.inputTokens / 1000) * costs.inputCostPer1k +
+        (result.usage.outputTokens / 1000) * costs.outputCostPer1k);
+}
+// =============================================================================
+// FACTORY
+// =============================================================================
+/** Create a provider manager with common providers */
+function createProviders(options = {}) {
+    const manager = new ProviderManager();
+    if (options.anthropicKey) {
+        manager.register(new AnthropicProvider({ apiKey: options.anthropicKey }));
+    }
+    if (options.openaiKey) {
+        manager.register(new OpenAIProvider({ apiKey: options.openaiKey }));
+    }
+    if (options.ollamaUrl) {
+        manager.register(new OllamaProvider(options.ollamaUrl));
+    }
+    if (options.groqKey) {
+        manager.register(new discovery_1.GroqProvider(options.groqKey));
+    }
+    if (options.togetherKey) {
+        manager.register(new discovery_1.TogetherProvider(options.togetherKey));
+    }
+    if (options.fireworksKey) {
+        manager.register(new discovery_1.FireworksProvider(options.fireworksKey));
+    }
+    if (options.geminiKey) {
+        manager.register(new GeminiProvider(options.geminiKey));
+    }
+    return manager;
+}
+// =============================================================================
+// DEFAULT INSTANCE
+// =============================================================================
+exports.providers = new ProviderManager();
+// Auto-register from environment
+if (process.env.ANTHROPIC_API_KEY) {
+    exports.providers.register(new AnthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY }));
+}
+if (process.env.OPENAI_API_KEY) {
+    exports.providers.register(new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY }));
+}
+if (process.env.OLLAMA_URL) {
+    exports.providers.register(new OllamaProvider(process.env.OLLAMA_URL));
+}
+if (process.env.GROQ_API_KEY) {
+    exports.providers.register(new discovery_1.GroqProvider(process.env.GROQ_API_KEY));
+}
+if (process.env.TOGETHER_API_KEY) {
+    exports.providers.register(new discovery_1.TogetherProvider(process.env.TOGETHER_API_KEY));
+}
+if (process.env.FIREWORKS_API_KEY) {
+    exports.providers.register(new discovery_1.FireworksProvider(process.env.FIREWORKS_API_KEY));
+}
+if (process.env.GEMINI_API_KEY) {
+    exports.providers.register(new GeminiProvider(process.env.GEMINI_API_KEY));
+}
+var health_1 = require("./health");
+Object.defineProperty(exports, "createProviderHealthMonitor", { enumerable: true, get: function () { return health_1.createProviderHealthMonitor; } });
+//# sourceMappingURL=index.js.map