cowork-os 0.3.21

package/dist/electron/electron/agent/llm/openrouter-provider.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenRouterProvider = void 0;
+/**
+ * OpenRouter API provider implementation
+ * OpenRouter provides access to multiple LLM providers through a unified API
+ */
+class OpenRouterProvider {
+    constructor(config) {
+        this.type = 'openrouter';
+        this.baseUrl = 'https://openrouter.ai/api/v1';
+        const apiKey = config.openrouterApiKey;
+        if (!apiKey) {
+            throw new Error('OpenRouter API key is required. Configure it in Settings or get one from https://openrouter.ai/keys');
+        }
+        this.apiKey = apiKey;
+        this.defaultModel = config.model || 'anthropic/claude-3.5-sonnet';
+    }
+    async createMessage(request) {
+        const messages = this.convertMessages(request.messages, request.system);
+        const tools = request.tools ? this.convertTools(request.tools) : undefined;
+        try {
+            console.log(`[OpenRouter] Calling API with model: ${request.model || this.defaultModel}`);
+            const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                    'HTTP-Referer': 'https://github.com/CoWork-OS/cowork-os',
+                    'X-Title': 'CoWork-OS',
+                },
+                body: JSON.stringify({
+                    model: request.model || this.defaultModel,
+                    messages,
+                    max_tokens: request.maxTokens,
+                    ...(tools && { tools, tool_choice: 'auto' }),
+                }),
+                // Pass abort signal to allow cancellation
+                signal: request.signal,
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                throw new Error(`OpenRouter API error: ${response.status} ${response.statusText}` +
+                    (errorData.error?.message ? ` - ${errorData.error.message}` : ''));
+            }
+            const data = await response.json();
+            return this.convertResponse(data);
+        }
+        catch (error) {
+            // Handle abort errors gracefully
+            if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+                console.log(`[OpenRouter] Request aborted`);
+                throw new Error('Request cancelled');
+            }
+            console.error(`[OpenRouter] API error:`, {
+                message: error.message,
+                status: error.status,
+            });
+            throw error;
+        }
+    }
+    async testConnection() {
+        try {
+            const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                    'HTTP-Referer': 'https://github.com/CoWork-OS/cowork-os',
+                    'X-Title': 'CoWork-OS',
+                },
+                body: JSON.stringify({
+                    model: this.defaultModel,
+                    messages: [{ role: 'user', content: 'Hi' }],
+                    max_tokens: 10,
+                }),
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                return {
+                    success: false,
+                    error: errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`,
+                };
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to connect to OpenRouter API',
+            };
+        }
+    }
+    convertMessages(messages, system) {
+        const result = [];
+        // Add system message if provided
+        if (system) {
+            result.push({ role: 'system', content: system });
+        }
+        for (const msg of messages) {
+            if (typeof msg.content === 'string') {
+                result.push({ role: msg.role, content: msg.content });
+            }
+            else {
+                // Handle array content (tool results or mixed content)
+                for (const item of msg.content) {
+                    if (item.type === 'tool_result') {
+                        result.push({
+                            role: 'tool',
+                            content: item.content,
+                            tool_call_id: item.tool_use_id,
+                        });
+                    }
+                    else if (item.type === 'tool_use') {
+                        // Tool use from assistant - add as assistant message with tool_calls
+                        result.push({
+                            role: 'assistant',
+                            content: null,
+                            tool_calls: [{
+                                    id: item.id,
+                                    type: 'function',
+                                    function: {
+                                        name: item.name,
+                                        arguments: JSON.stringify(item.input),
+                                    },
+                                }],
+                        });
+                    }
+                    else if (item.type === 'text') {
+                        result.push({ role: msg.role, content: item.text });
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    convertTools(tools) {
+        return tools.map((tool) => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.input_schema,
+            },
+        }));
+    }
+    convertResponse(response) {
+        const content = [];
+        const choice = response.choices?.[0];
+        if (!choice) {
+            return {
+                content: [{ type: 'text', text: '' }],
+                stopReason: 'end_turn',
+            };
+        }
+        const message = choice.message;
+        // Handle text content
+        if (message.content) {
+            content.push({
+                type: 'text',
+                text: message.content,
+            });
+        }
+        // Handle tool calls
+        if (message.tool_calls) {
+            for (const toolCall of message.tool_calls) {
+                if (toolCall.type === 'function') {
+                    content.push({
+                        type: 'tool_use',
+                        id: toolCall.id,
+                        name: toolCall.function.name,
+                        input: JSON.parse(toolCall.function.arguments || '{}'),
+                    });
+                }
+            }
+        }
+        // If no content was parsed, return empty text
+        if (content.length === 0) {
+            content.push({ type: 'text', text: '' });
+        }
+        return {
+            content,
+            stopReason: this.mapStopReason(choice.finish_reason),
+            usage: response.usage
+                ? {
+                    inputTokens: response.usage.prompt_tokens || 0,
+                    outputTokens: response.usage.completion_tokens || 0,
+                }
+                : undefined,
+        };
+    }
+    mapStopReason(finishReason) {
+        switch (finishReason) {
+            case 'stop':
+                return 'end_turn';
+            case 'length':
+                return 'max_tokens';
+            case 'tool_calls':
+                return 'tool_use';
+            case 'content_filter':
+                return 'stop_sequence';
+            default:
+                return 'end_turn';
+        }
+    }
+    /**
+     * Fetch available models from OpenRouter API
+     */
+    async getAvailableModels() {
+        try {
+            const response = await fetch(`${this.baseUrl}/models`, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+            });
+            if (!response.ok) {
+                return [];
+            }
+            const data = await response.json();
+            return (data.data || []).map((model) => ({
+                id: model.id,
+                name: model.name || model.id,
+                context_length: model.context_length || 0,
+            }));
+        }
+        catch (error) {
+            console.error('Failed to fetch OpenRouter models:', error);
+            return [];
+        }
+    }
+}
+exports.OpenRouterProvider = OpenRouterProvider;

package/dist/electron/electron/agent/llm/pricing.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Model Pricing Table
+ *
+ * Contains pricing information for various LLM models.
+ * Prices are per 1 million tokens in USD.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMAGE_GENERATION_PRICING = exports.MODEL_PRICING = void 0;
+exports.calculateCost = calculateCost;
+exports.getModelPricing = getModelPricing;
+exports.formatCost = formatCost;
+exports.calculateImageCost = calculateImageCost;
+exports.getImagePricing = getImagePricing;
+/**
+ * Model pricing table (per 1M tokens in USD)
+ * Updated as of January 2025
+ */
+exports.MODEL_PRICING = {
+    // Anthropic Claude models
+    'claude-opus-4-5-20250101': { inputPer1M: 15.00, outputPer1M: 75.00 },
+    'claude-sonnet-4-5-20250514': { inputPer1M: 3.00, outputPer1M: 15.00 },
+    'claude-sonnet-4-20250514': { inputPer1M: 3.00, outputPer1M: 15.00 },
+    'claude-3-5-sonnet-20241022': { inputPer1M: 3.00, outputPer1M: 15.00 },
+    'claude-3-5-sonnet-latest': { inputPer1M: 3.00, outputPer1M: 15.00 },
+    'claude-3-5-haiku-20241022': { inputPer1M: 0.80, outputPer1M: 4.00 },
+    'claude-3-5-haiku-latest': { inputPer1M: 0.80, outputPer1M: 4.00 },
+    'claude-3-opus-20240229': { inputPer1M: 15.00, outputPer1M: 75.00 },
+    'claude-3-sonnet-20240229': { inputPer1M: 3.00, outputPer1M: 15.00 },
+    'claude-3-haiku-20240307': { inputPer1M: 0.25, outputPer1M: 1.25 },
+    // AWS Bedrock model IDs
+    'anthropic.claude-3-5-sonnet-20241022-v2:0': { inputPer1M: 3.00, outputPer1M: 15.00 },
+    'anthropic.claude-3-5-haiku-20241022-v1:0': { inputPer1M: 0.80, outputPer1M: 4.00 },
+    'anthropic.claude-3-opus-20240229-v1:0': { inputPer1M: 15.00, outputPer1M: 75.00 },
+    'anthropic.claude-3-sonnet-20240229-v1:0': { inputPer1M: 3.00, outputPer1M: 15.00 },
+    'anthropic.claude-3-haiku-20240307-v1:0': { inputPer1M: 0.25, outputPer1M: 1.25 },
+    'us.anthropic.claude-opus-4-5-20251101-v1:0': { inputPer1M: 15.00, outputPer1M: 75.00 },
+    'us.anthropic.claude-sonnet-4-5-20250514-v1:0': { inputPer1M: 3.00, outputPer1M: 15.00 },
+    'us.anthropic.claude-sonnet-4-20250514-v1:0': { inputPer1M: 3.00, outputPer1M: 15.00 },
+    // Google Gemini models (prices may vary, free tier has limits)
+    'gemini-2.0-flash': { inputPer1M: 0.10, outputPer1M: 0.40 },
+    'gemini-2.0-flash-lite': { inputPer1M: 0.075, outputPer1M: 0.30 },
+    'gemini-2.5-pro': { inputPer1M: 1.25, outputPer1M: 5.00 },
+    'gemini-2.5-flash': { inputPer1M: 0.15, outputPer1M: 0.60 },
+    'gemini-1.5-pro': { inputPer1M: 1.25, outputPer1M: 5.00 },
+    'gemini-1.5-flash': { inputPer1M: 0.075, outputPer1M: 0.30 },
+    // OpenAI models (direct API)
+    'gpt-4o': { inputPer1M: 2.50, outputPer1M: 10.00 },
+    'gpt-4o-mini': { inputPer1M: 0.15, outputPer1M: 0.60 },
+    'gpt-4-turbo': { inputPer1M: 10.00, outputPer1M: 30.00 },
+    'gpt-4': { inputPer1M: 30.00, outputPer1M: 60.00 },
+    'gpt-3.5-turbo': { inputPer1M: 0.50, outputPer1M: 1.50 },
+    'o1': { inputPer1M: 15.00, outputPer1M: 60.00 },
+    'o1-mini': { inputPer1M: 3.00, outputPer1M: 12.00 },
+    'o1-preview': { inputPer1M: 15.00, outputPer1M: 60.00 },
+    // OpenRouter passes through various model pricing
+    // These are common models accessed through OpenRouter
+    'anthropic/claude-3.5-sonnet': { inputPer1M: 3.00, outputPer1M: 15.00 },
+    'anthropic/claude-3-opus': { inputPer1M: 15.00, outputPer1M: 75.00 },
+    'openai/gpt-4o': { inputPer1M: 2.50, outputPer1M: 10.00 },
+    'openai/gpt-4o-mini': { inputPer1M: 0.15, outputPer1M: 0.60 },
+    'google/gemini-pro-1.5': { inputPer1M: 1.25, outputPer1M: 5.00 },
+    'meta-llama/llama-3.1-405b-instruct': { inputPer1M: 3.00, outputPer1M: 3.00 },
+    'meta-llama/llama-3.1-70b-instruct': { inputPer1M: 0.52, outputPer1M: 0.75 },
+    // Ollama (local) - free
+    // Ollama models are free since they run locally
+    // Google Gemini image generation models
+    // Note: Image generation is priced per image, not per token
+    // These are approximate costs (actual pricing may vary)
+    'gemini-2.5-flash-image': { inputPer1M: 0.00, outputPer1M: 0.00 }, // Nano Banana
+    'gemini-3-pro-image-preview': { inputPer1M: 0.00, outputPer1M: 0.00 }, // Nano Banana Pro
+};
+/**
+ * Image generation pricing (per image in USD)
+ * Separate from token-based pricing for LLMs
+ */
+exports.IMAGE_GENERATION_PRICING = {
+    'gemini-2.5-flash-image': 0.02, // Nano Banana - ~$0.02 per image
+    'gemini-3-pro-image-preview': 0.04, // Nano Banana Pro - ~$0.04 per image
+    'nano-banana': 0.02, // Alias
+    'nano-banana-pro': 0.04, // Alias
+};
+/**
+ * Calculate the cost of an LLM API call
+ * @param modelId The model identifier
+ * @param inputTokens Number of input tokens
+ * @param outputTokens Number of output tokens
+ * @returns Cost in USD
+ */
+function calculateCost(modelId, inputTokens, outputTokens) {
+    // Try exact match first
+    let pricing = exports.MODEL_PRICING[modelId];
+    // If no exact match, try to find a partial match
+    if (!pricing) {
+        const modelIdLower = modelId.toLowerCase();
+        for (const [key, value] of Object.entries(exports.MODEL_PRICING)) {
+            if (modelIdLower.includes(key.toLowerCase()) || key.toLowerCase().includes(modelIdLower)) {
+                pricing = value;
+                break;
+            }
+        }
+    }
+    // If still no match, return 0 (unknown model or local model)
+    if (!pricing) {
+        return 0;
+    }
+    const inputCost = (inputTokens / 1000000) * pricing.inputPer1M;
+    const outputCost = (outputTokens / 1000000) * pricing.outputPer1M;
+    return inputCost + outputCost;
+}
+/**
+ * Get pricing info for a model (for display)
+ * @param modelId The model identifier
+ * @returns Pricing info or null if unknown
+ */
+function getModelPricing(modelId) {
+    // Try exact match first
+    if (exports.MODEL_PRICING[modelId]) {
+        return exports.MODEL_PRICING[modelId];
+    }
+    // Try partial match
+    const modelIdLower = modelId.toLowerCase();
+    for (const [key, value] of Object.entries(exports.MODEL_PRICING)) {
+        if (modelIdLower.includes(key.toLowerCase()) || key.toLowerCase().includes(modelIdLower)) {
+            return value;
+        }
+    }
+    return null;
+}
+/**
+ * Format cost for display
+ */
+function formatCost(cost) {
+    if (cost < 0.01) {
+        return `$${cost.toFixed(4)}`;
+    }
+    return `$${cost.toFixed(2)}`;
+}
+/**
+ * Calculate the cost of image generation
+ * @param modelId The image model identifier (e.g., 'nano-banana', 'imagen-3.0-fast-generate-001')
+ * @param numberOfImages Number of images generated
+ * @returns Cost in USD
+ */
+function calculateImageCost(modelId, numberOfImages) {
+    const pricePerImage = exports.IMAGE_GENERATION_PRICING[modelId] || exports.IMAGE_GENERATION_PRICING[modelId.toLowerCase()];
+    if (!pricePerImage) {
+        // Default to Nano Banana pricing if unknown model
+        return 0.03 * numberOfImages;
+    }
+    return pricePerImage * numberOfImages;
+}
+/**
+ * Get image generation pricing info for a model
+ * @param modelId The image model identifier
+ * @returns Price per image in USD, or null if unknown
+ */
+function getImagePricing(modelId) {
+    return exports.IMAGE_GENERATION_PRICING[modelId] || exports.IMAGE_GENERATION_PRICING[modelId.toLowerCase()] || null;
+}