agentic-qe 2.4.0 → 2.5.1

package/dist/providers/OpenRouterProvider.d.ts

@@ -0,0 +1,150 @@
+/**
+ * OpenRouterProvider - OpenRouter API Implementation
+ *
+ * Provides LLM capabilities through OpenRouter's unified API with support for:
+ * - 300+ models from multiple providers (OpenAI, Anthropic, Google, etc.)
+ * - Model hot-swapping at runtime
+ * - Auto-routing to cheapest capable model
+ * - Streaming responses
+ * - Cost tracking
+ *
+ * @module providers/OpenRouterProvider
+ * @version 1.0.0
+ */
+import { ILLMProvider, LLMProviderConfig, LLMCompletionOptions, LLMCompletionResponse, LLMStreamEvent, LLMEmbeddingOptions, LLMEmbeddingResponse, LLMTokenCountOptions, LLMHealthStatus, LLMProviderMetadata } from './ILLMProvider';
+/**
+ * OpenRouter model information
+ */
+export interface OpenRouterModel {
+    /** Model ID (e.g., 'anthropic/claude-3.5-sonnet') */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Provider (e.g., 'Anthropic', 'OpenAI') */
+    provider?: string;
+    /** Context length */
+    contextLength: number;
+    /** Pricing per million tokens */
+    pricing: {
+        prompt: number;
+        completion: number;
+    };
+    /** Supported modalities */
+    modalities?: string[];
+    /** Whether model supports tool use */
+    supportsToolUse?: boolean;
+}
+/**
+ * OpenRouter-specific configuration
+ */
+export interface OpenRouterConfig extends LLMProviderConfig {
+    /** OpenRouter API key (uses OPENROUTER_API_KEY env var if not provided) */
+    apiKey?: string;
+    /** Default model to use (default: auto-selects cheapest capable) */
+    defaultModel?: string;
+    /** Your site URL for OpenRouter rankings */
+    siteUrl?: string;
+    /** Your site name */
+    siteName?: string;
+    /** Fallback models if primary unavailable */
+    fallbackModels?: string[];
+    /** Enable model discovery (fetch available models on init) */
+    enableModelDiscovery?: boolean;
+    /** Base URL for API (default: https://openrouter.ai/api/v1) */
+    baseUrl?: string;
+    /** Enable auto-routing to cheapest model */
+    enableAutoRoute?: boolean;
+}
+/**
+ * OpenRouterProvider - OpenRouter API implementation of ILLMProvider
+ *
+ * Enables access to 300+ models through OpenRouter's unified API
+ * with support for runtime model switching and cost optimization.
+ */
+export declare class OpenRouterProvider implements ILLMProvider {
+    private readonly logger;
+    private config;
+    private isInitialized;
+    private totalCost;
+    private requestCount;
+    private apiKey?;
+    private currentModel;
+    private availableModels;
+    constructor(config?: OpenRouterConfig);
+    /**
+     * Initialize the OpenRouter provider
+     */
+    initialize(): Promise<void>;
+    /**
+     * Discover available models from OpenRouter API
+     */
+    private discoverModels;
+    /**
+     * Complete a prompt
+     */
+    complete(options: LLMCompletionOptions): Promise<LLMCompletionResponse>;
+    /**
+     * Stream a completion
+     */
+    streamComplete(options: LLMCompletionOptions): AsyncIterableIterator<LLMStreamEvent>;
+    /**
+     * Generate embeddings
+     * Note: OpenRouter embedding support varies by model
+     */
+    embed(options: LLMEmbeddingOptions): Promise<LLMEmbeddingResponse>;
+    /**
+     * Count tokens (approximation using character count)
+     */
+    countTokens(options: LLMTokenCountOptions): Promise<number>;
+    /**
+     * Health check
+     */
+    healthCheck(): Promise<LLMHealthStatus>;
+    /**
+     * Get provider metadata
+     */
+    getMetadata(): LLMProviderMetadata;
+    /**
+     * Shutdown the provider
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Track cost for a request
+     */
+    trackCost(usage: LLMCompletionResponse['usage']): number;
+    /**
+     * Hot-swap to a different model at runtime
+     */
+    setModel(model: string): Promise<void>;
+    /**
+     * Get current model
+     */
+    getCurrentModel(): string;
+    /**
+     * Get available models
+     */
+    getAvailableModels(): Promise<OpenRouterModel[]>;
+    /**
+     * Get model info
+     */
+    getModelInfo(model: string): OpenRouterModel | null;
+    /**
+     * Get total cost tracked
+     */
+    getTotalCost(): number;
+    /**
+     * Get request count
+     */
+    getRequestCount(): number;
+    private ensureInitialized;
+    private buildMessages;
+    private getHeaders;
+    private makeRequest;
+    private mapStopReason;
+    private handleError;
+}
+/**
+ * Create an OpenRouter provider with configuration
+ */
+export declare function createOpenRouterProvider(config?: OpenRouterConfig): OpenRouterProvider;
+//# sourceMappingURL=OpenRouterProvider.d.ts.map

package/dist/providers/OpenRouterProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenRouterProvider.d.ts","sourceRoot":"","sources":["../../src/providers/OpenRouterProvider.ts"],"names":[],"mappings":"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"}

package/dist/providers/OpenRouterProvider.js

@@ -0,0 +1,545 @@
+"use strict";
+/**
+ * OpenRouterProvider - OpenRouter API Implementation
+ *
+ * Provides LLM capabilities through OpenRouter's unified API with support for:
+ * - 300+ models from multiple providers (OpenAI, Anthropic, Google, etc.)
+ * - Model hot-swapping at runtime
+ * - Auto-routing to cheapest capable model
+ * - Streaming responses
+ * - Cost tracking
+ *
+ * @module providers/OpenRouterProvider
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenRouterProvider = void 0;
+exports.createOpenRouterProvider = createOpenRouterProvider;
+const ILLMProvider_1 = require("./ILLMProvider");
+const Logger_1 = require("../utils/Logger");
+/**
+ * Default OpenRouter pricing (per million tokens)
+ * These are fallback values; actual prices come from the API
+ */
+const DEFAULT_PRICING = {
+    'anthropic/claude-3.5-sonnet': { input: 3.0, output: 15.0 },
+    'anthropic/claude-3-haiku': { input: 0.25, output: 1.25 },
+    'openai/gpt-4o': { input: 2.5, output: 10.0 },
+    'openai/gpt-4o-mini': { input: 0.15, output: 0.6 },
+    'google/gemini-pro-1.5': { input: 1.25, output: 5.0 },
+    'meta-llama/llama-3.1-70b-instruct': { input: 0.52, output: 0.75 },
+    'auto': { input: 0.5, output: 2.0 }, // Average estimate for auto-routing
+};
+/**
+ * OpenRouterProvider - OpenRouter API implementation of ILLMProvider
+ *
+ * Enables access to 300+ models through OpenRouter's unified API
+ * with support for runtime model switching and cost optimization.
+ */
+class OpenRouterProvider {
+    constructor(config = {}) {
+        this.availableModels = new Map();
+        this.logger = Logger_1.Logger.getInstance();
+        this.config = {
+            name: config.name || 'openrouter',
+            debug: config.debug ?? false,
+            timeout: config.timeout ?? 60000,
+            maxRetries: config.maxRetries ?? 3,
+            defaultModel: config.defaultModel || 'auto',
+            siteUrl: config.siteUrl || process.env.OPENROUTER_SITE_URL,
+            siteName: config.siteName || process.env.OPENROUTER_SITE_NAME || 'Agentic-QE-Fleet',
+            fallbackModels: config.fallbackModels || [
+                'anthropic/claude-3.5-sonnet',
+                'openai/gpt-4o-mini',
+                'meta-llama/llama-3.1-70b-instruct'
+            ],
+            enableModelDiscovery: config.enableModelDiscovery ?? true,
+            baseUrl: config.baseUrl || 'https://openrouter.ai/api/v1',
+            enableAutoRoute: config.enableAutoRoute ?? true,
+            apiKey: config.apiKey,
+        };
+        this.currentModel = this.config.defaultModel;
+        this.isInitialized = false;
+        this.totalCost = 0;
+        this.requestCount = 0;
+    }
+    /**
+     * Initialize the OpenRouter provider
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            this.logger.warn('OpenRouterProvider already initialized');
+            return;
+        }
+        this.apiKey = this.config.apiKey || process.env.OPENROUTER_API_KEY;
+        if (!this.apiKey) {
+            throw new ILLMProvider_1.LLMProviderError('OpenRouter API key not provided. Set OPENROUTER_API_KEY environment variable.', 'openrouter', 'AUTH_ERROR', false);
+        }
+        // Optionally discover available models
+        if (this.config.enableModelDiscovery) {
+            try {
+                await this.discoverModels();
+            }
+            catch (error) {
+                this.logger.warn('Failed to discover models, using defaults:', error);
+            }
+        }
+        this.isInitialized = true;
+        this.logger.info('OpenRouterProvider initialized', {
+            model: this.currentModel,
+            autoRoute: this.config.enableAutoRoute,
+            modelsDiscovered: this.availableModels.size
+        });
+    }
+    /**
+     * Discover available models from OpenRouter API
+     */
+    async discoverModels() {
+        try {
+            const response = await fetch(`${this.config.baseUrl}/models`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch models: ${response.status}`);
+            }
+            const data = await response.json();
+            for (const model of data.data || []) {
+                this.availableModels.set(model.id, {
+                    id: model.id,
+                    name: model.name || model.id,
+                    contextLength: model.context_length || 4096,
+                    pricing: {
+                        prompt: (model.pricing?.prompt || 0) * 1000000,
+                        completion: (model.pricing?.completion || 0) * 1000000,
+                    },
+                    modalities: model.modalities,
+                    supportsToolUse: model.supports_tool_use,
+                });
+            }
+            this.logger.debug(`Discovered ${this.availableModels.size} models from OpenRouter`);
+        }
+        catch (error) {
+            this.logger.warn('Model discovery failed:', error);
+        }
+    }
+    /**
+     * Complete a prompt
+     */
+    async complete(options) {
+        this.ensureInitialized();
+        const model = options.model || this.currentModel;
+        const startTime = Date.now();
+        try {
+            // Build request body (OpenAI-compatible format)
+            const messages = this.buildMessages(options);
+            const body = {
+                model,
+                messages,
+                max_tokens: options.maxTokens || 4096,
+                temperature: options.temperature ?? 0.7,
+            };
+            // Add system prompt if provided
+            if (options.system && options.system.length > 0) {
+                const systemText = options.system.map(s => s.text).join('\n');
+                messages.unshift({ role: 'system', content: systemText });
+            }
+            const response = await this.makeRequest('/chat/completions', body);
+            // Convert OpenRouter response to our format
+            const choice = response.choices?.[0];
+            const content = choice?.message?.content || '';
+            const result = {
+                content: [{ type: 'text', text: content }],
+                usage: {
+                    input_tokens: response.usage?.prompt_tokens || 0,
+                    output_tokens: response.usage?.completion_tokens || 0,
+                },
+                model: response.model || model,
+                stop_reason: this.mapStopReason(choice?.finish_reason),
+                id: response.id || `or-${Date.now()}`,
+                metadata: {
+                    latency: Date.now() - startTime,
+                    provider: 'openrouter',
+                },
+            };
+            // Track cost
+            this.trackCost(result.usage);
+            this.requestCount++;
+            return result;
+        }
+        catch (error) {
+            this.handleError(error, 'complete');
+            throw error;
+        }
+    }
+    /**
+     * Stream a completion
+     */
+    async *streamComplete(options) {
+        this.ensureInitialized();
+        const model = options.model || this.currentModel;
+        try {
+            const messages = this.buildMessages(options);
+            const body = {
+                model,
+                messages,
+                max_tokens: options.maxTokens || 4096,
+                temperature: options.temperature ?? 0.7,
+                stream: true,
+            };
+            // Add system prompt if provided
+            if (options.system && options.system.length > 0) {
+                const systemText = options.system.map(s => s.text).join('\n');
+                messages.unshift({ role: 'system', content: systemText });
+            }
+            const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                throw new ILLMProvider_1.LLMProviderError(`OpenRouter request failed: ${response.status}`, 'openrouter', 'REQUEST_ERROR', response.status >= 500);
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new ILLMProvider_1.LLMProviderError('No response body for streaming', 'openrouter', 'STREAM_ERROR', false);
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            // Emit message start
+            yield {
+                type: 'message_start',
+                message: {
+                    id: `or-stream-${Date.now()}`,
+                    model,
+                    content: [],
+                    usage: { input_tokens: 0, output_tokens: 0 },
+                    stop_reason: 'end_turn',
+                },
+            };
+            // Emit content block start
+            yield {
+                type: 'content_block_start',
+                content_block: { type: 'text', text: '' },
+            };
+            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).trim();
+                        if (data === '[DONE]') {
+                            yield { type: 'content_block_stop' };
+                            yield { type: 'message_stop' };
+                            return;
+                        }
+                        try {
+                            const parsed = JSON.parse(data);
+                            const delta = parsed.choices?.[0]?.delta?.content;
+                            if (delta) {
+                                yield {
+                                    type: 'content_block_delta',
+                                    delta: { type: 'text_delta', text: delta },
+                                };
+                            }
+                        }
+                        catch {
+                            // Skip malformed JSON
+                        }
+                    }
+                }
+            }
+            yield { type: 'content_block_stop' };
+            yield { type: 'message_stop' };
+        }
+        catch (error) {
+            this.handleError(error, 'streamComplete');
+            throw error;
+        }
+    }
+    /**
+     * Generate embeddings
+     * Note: OpenRouter embedding support varies by model
+     */
+    async embed(options) {
+        this.ensureInitialized();
+        const model = options.model || 'openai/text-embedding-3-small';
+        try {
+            const response = await this.makeRequest('/embeddings', {
+                model,
+                input: options.text,
+                dimensions: options.dimensions,
+            });
+            const embedding = response.data?.[0]?.embedding || [];
+            return {
+                embedding,
+                model: response.model || model,
+                tokens: response.usage?.prompt_tokens || 0,
+            };
+        }
+        catch (error) {
+            // Embeddings may not be available for all models
+            throw new ILLMProvider_1.LLMProviderError(`Embeddings not available: ${error.message}`, 'openrouter', 'EMBEDDINGS_UNAVAILABLE', false);
+        }
+    }
+    /**
+     * Count tokens (approximation using character count)
+     */
+    async countTokens(options) {
+        // OpenRouter doesn't have a token counting endpoint
+        // Use approximation: ~4 characters per token for English
+        return Math.ceil(options.text.length / 4);
+    }
+    /**
+     * Health check
+     */
+    async healthCheck() {
+        const startTime = Date.now();
+        if (!this.isInitialized) {
+            return {
+                healthy: false,
+                error: 'Provider not initialized',
+                timestamp: new Date(),
+            };
+        }
+        try {
+            // Check API health by fetching models endpoint
+            const response = await fetch(`${this.config.baseUrl}/models`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+                signal: AbortSignal.timeout(5000),
+            });
+            const healthy = response.ok;
+            return {
+                healthy,
+                latency: Date.now() - startTime,
+                timestamp: new Date(),
+                metadata: {
+                    statusCode: response.status,
+                    requestCount: this.requestCount,
+                    totalCost: this.totalCost,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                error: error.message,
+                timestamp: new Date(),
+            };
+        }
+    }
+    /**
+     * Get provider metadata
+     */
+    getMetadata() {
+        const models = this.availableModels.size > 0
+            ? Array.from(this.availableModels.keys())
+            : Object.keys(DEFAULT_PRICING);
+        // Get pricing for current model
+        const modelInfo = this.availableModels.get(this.currentModel);
+        const defaultPricing = DEFAULT_PRICING[this.currentModel] || DEFAULT_PRICING['auto'];
+        return {
+            name: 'openrouter',
+            version: '1.0.0',
+            models,
+            capabilities: {
+                streaming: true,
+                caching: false, // OpenRouter doesn't support prompt caching
+                embeddings: true,
+                vision: true, // Many models support vision
+            },
+            costs: {
+                inputPerMillion: modelInfo?.pricing.prompt || defaultPricing.input,
+                outputPerMillion: modelInfo?.pricing.completion || defaultPricing.output,
+            },
+            location: 'cloud',
+        };
+    }
+    /**
+     * Shutdown the provider
+     */
+    async shutdown() {
+        this.logger.info('OpenRouterProvider shutting down', {
+            totalRequests: this.requestCount,
+            totalCost: this.totalCost,
+        });
+        this.isInitialized = false;
+        this.availableModels.clear();
+    }
+    /**
+     * Track cost for a request
+     */
+    trackCost(usage) {
+        const modelInfo = this.availableModels.get(this.currentModel);
+        const defaultPricing = DEFAULT_PRICING[this.currentModel] || DEFAULT_PRICING['auto'];
+        const inputCost = (usage.input_tokens / 1000000) *
+            (modelInfo?.pricing.prompt || defaultPricing.input);
+        const outputCost = (usage.output_tokens / 1000000) *
+            (modelInfo?.pricing.completion || defaultPricing.output);
+        const cost = inputCost + outputCost;
+        this.totalCost += cost;
+        return cost;
+    }
+    // ============================================
+    // Hot-Swap Methods (G6)
+    // ============================================
+    /**
+     * Hot-swap to a different model at runtime
+     */
+    async setModel(model) {
+        if (!this.isInitialized) {
+            throw new ILLMProvider_1.LLMProviderError('Provider not initialized', 'openrouter', 'NOT_INITIALIZED', false);
+        }
+        // Validate model exists (if we have model info)
+        if (this.availableModels.size > 0 && !this.availableModels.has(model) && model !== 'auto') {
+            this.logger.warn(`Model ${model} not found in available models, proceeding anyway`);
+        }
+        const previousModel = this.currentModel;
+        this.currentModel = model;
+        this.logger.info('Model hot-swapped', {
+            from: previousModel,
+            to: model,
+        });
+    }
+    /**
+     * Get current model
+     */
+    getCurrentModel() {
+        return this.currentModel;
+    }
+    /**
+     * Get available models
+     */
+    async getAvailableModels() {
+        if (this.availableModels.size === 0) {
+            await this.discoverModels();
+        }
+        return Array.from(this.availableModels.values());
+    }
+    /**
+     * Get model info
+     */
+    getModelInfo(model) {
+        return this.availableModels.get(model) || null;
+    }
+    /**
+     * Get total cost tracked
+     */
+    getTotalCost() {
+        return this.totalCost;
+    }
+    /**
+     * Get request count
+     */
+    getRequestCount() {
+        return this.requestCount;
+    }
+    // ============================================
+    // Private Methods
+    // ============================================
+    ensureInitialized() {
+        if (!this.isInitialized) {
+            throw new ILLMProvider_1.LLMProviderError('OpenRouterProvider not initialized. Call initialize() first.', 'openrouter', 'NOT_INITIALIZED', false);
+        }
+    }
+    buildMessages(options) {
+        return options.messages.map(m => ({
+            role: m.role,
+            content: typeof m.content === 'string'
+                ? m.content
+                : m.content.filter(c => c.type === 'text').map(c => c.text || '').join(''),
+        }));
+    }
+    getHeaders() {
+        const headers = {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+        };
+        if (this.config.siteUrl) {
+            headers['HTTP-Referer'] = this.config.siteUrl;
+        }
+        if (this.config.siteName) {
+            headers['X-Title'] = this.config.siteName;
+        }
+        return headers;
+    }
+    async makeRequest(endpoint, body) {
+        let lastError = null;
+        const maxRetries = this.config.maxRetries;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                const response = await fetch(`${this.config.baseUrl}${endpoint}`, {
+                    method: 'POST',
+                    headers: this.getHeaders(),
+                    body: JSON.stringify(body),
+                    signal: AbortSignal.timeout(this.config.timeout),
+                });
+                if (!response.ok) {
+                    const errorBody = await response.text();
+                    const retryable = response.status >= 500 || response.status === 429;
+                    if (retryable && attempt < maxRetries) {
+                        const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
+                        this.logger.warn(`Request failed (${response.status}), retrying in ${delay}ms...`);
+                        await new Promise(r => setTimeout(r, delay));
+                        continue;
+                    }
+                    throw new ILLMProvider_1.LLMProviderError(`OpenRouter request failed: ${response.status} - ${errorBody}`, 'openrouter', 'REQUEST_ERROR', retryable);
+                }
+                return await response.json();
+            }
+            catch (error) {
+                lastError = error;
+                if (error instanceof ILLMProvider_1.LLMProviderError && !error.retryable) {
+                    throw error;
+                }
+                if (attempt < maxRetries) {
+                    const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
+                    this.logger.warn(`Request error, retrying in ${delay}ms...`, error);
+                    await new Promise(r => setTimeout(r, delay));
+                }
+            }
+        }
+        throw lastError || new Error('Request failed after all retries');
+    }
+    mapStopReason(finishReason) {
+        switch (finishReason) {
+            case 'stop':
+                return 'end_turn';
+            case 'length':
+                return 'max_tokens';
+            case 'content_filter':
+                return 'stop_sequence';
+            default:
+                return 'end_turn';
+        }
+    }
+    handleError(error, operation) {
+        if (error instanceof ILLMProvider_1.LLMProviderError) {
+            this.logger.error(`OpenRouter ${operation} failed:`, {
+                code: error.code,
+                retryable: error.retryable,
+                message: error.message,
+            });
+        }
+        else {
+            this.logger.error(`OpenRouter ${operation} error:`, error);
+        }
+    }
+}
+exports.OpenRouterProvider = OpenRouterProvider;
+/**
+ * Create an OpenRouter provider with configuration
+ */
+function createOpenRouterProvider(config) {
+    return new OpenRouterProvider(config);
+}
+//# sourceMappingURL=OpenRouterProvider.js.map