cowork-os 0.3.21

package/src/electron/agent/llm/openrouter-provider.ts

@@ -0,0 +1,273 @@
+import {
+  LLMProvider,
+  LLMProviderConfig,
+  LLMRequest,
+  LLMResponse,
+  LLMContent,
+  LLMMessage,
+  LLMTool,
+} from './types';
+
+/**
+ * OpenRouter API provider implementation
+ * OpenRouter provides access to multiple LLM providers through a unified API
+ */
+export class OpenRouterProvider implements LLMProvider {
+  readonly type = 'openrouter' as const;
+  private apiKey: string;
+  private baseUrl = 'https://openrouter.ai/api/v1';
+  private defaultModel: string;
+
+  constructor(config: LLMProviderConfig) {
+    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: LLMRequest): Promise<LLMResponse> {
+    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(() => ({})) as { error?: { message?: string } };
+        throw new Error(
+          `OpenRouter API error: ${response.status} ${response.statusText}` +
+          (errorData.error?.message ? ` - ${errorData.error.message}` : '')
+        );
+      }
+
+      const data = await response.json() as any;
+      return this.convertResponse(data);
+    } catch (error: any) {
+      // 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(): Promise<{ success: boolean; error?: string }> {
+    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(() => ({})) as { error?: { message?: string } };
+        return {
+          success: false,
+          error: errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`,
+        };
+      }
+
+      return { success: true };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message || 'Failed to connect to OpenRouter API',
+      };
+    }
+  }
+
+  private convertMessages(
+    messages: LLMMessage[],
+    system?: string
+  ): Array<{ role: string; content: any; tool_call_id?: string }> {
+    const result: Array<{ role: string; content: any; tool_call_id?: string }> = [];
+
+    // 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),
+                },
+              }],
+            } as any);
+          } else if (item.type === 'text') {
+            result.push({ role: msg.role, content: item.text });
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
+  private convertTools(tools: LLMTool[]): Array<{
+    type: 'function';
+    function: {
+      name: string;
+      description: string;
+      parameters: any;
+    };
+  }> {
+    return tools.map((tool) => ({
+      type: 'function' as const,
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema,
+      },
+    }));
+  }
+
+  private convertResponse(response: any): LLMResponse {
+    const content: LLMContent[] = [];
+    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,
+    };
+  }
+
+  private mapStopReason(finishReason?: string): LLMResponse['stopReason'] {
+    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(): Promise<Array<{ id: string; name: string; context_length: number }>> {
+    try {
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers: {
+          'Authorization': `Bearer ${this.apiKey}`,
+        },
+      });
+
+      if (!response.ok) {
+        return [];
+      }
+
+      const data = await response.json() as { data?: any[] };
+      return (data.data || []).map((model: any) => ({
+        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 [];
+    }
+  }
+}

package/src/electron/agent/llm/pricing.ts

@@ -0,0 +1,180 @@
+/**
+ * Model Pricing Table
+ *
+ * Contains pricing information for various LLM models.
+ * Prices are per 1 million tokens in USD.
+ */
+
+export interface ModelPricing {
+  inputPer1M: number;  // Cost per 1M input tokens in USD
+  outputPer1M: number; // Cost per 1M output tokens in USD
+}
+
+/**
+ * Model pricing table (per 1M tokens in USD)
+ * Updated as of January 2025
+ */
+export const MODEL_PRICING: Record<string, ModelPricing> = {
+  // 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
+ */
+export const IMAGE_GENERATION_PRICING: Record<string, number> = {
+  '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
+ */
+export function calculateCost(
+  modelId: string,
+  inputTokens: number,
+  outputTokens: number
+): number {
+  // Try exact match first
+  let pricing = 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(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 / 1_000_000) * pricing.inputPer1M;
+  const outputCost = (outputTokens / 1_000_000) * 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
+ */
+export function getModelPricing(modelId: string): ModelPricing | null {
+  // Try exact match first
+  if (MODEL_PRICING[modelId]) {
+    return MODEL_PRICING[modelId];
+  }
+
+  // Try partial match
+  const modelIdLower = modelId.toLowerCase();
+  for (const [key, value] of Object.entries(MODEL_PRICING)) {
+    if (modelIdLower.includes(key.toLowerCase()) || key.toLowerCase().includes(modelIdLower)) {
+      return value;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Format cost for display
+ */
+export function formatCost(cost: number): string {
+  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
+ */
+export function calculateImageCost(modelId: string, numberOfImages: number): number {
+  const pricePerImage = IMAGE_GENERATION_PRICING[modelId] || 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
+ */
+export function getImagePricing(modelId: string): number | null {
+  return IMAGE_GENERATION_PRICING[modelId] || IMAGE_GENERATION_PRICING[modelId.toLowerCase()] || null;
+}