@shykaruu/jarvis-brain 0.4.0

package/src/llm/openrouter.ts

@@ -0,0 +1,390 @@
+import type {
+  LLMProvider,
+  LLMMessage,
+  LLMOptions,
+  LLMResponse,
+  LLMStreamEvent,
+  LLMTool,
+  LLMToolCall,
+} from './provider.ts';
+import { compactHistory, calculateHistoryBudget } from './history.ts';
+
+type OpenRouterMessage = {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string | null;
+  tool_call_id?: string;
+  tool_calls?: OpenRouterToolCall[];
+};
+
+type OpenRouterToolDef = {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+};
+
+type OpenRouterToolCall = {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+};
+
+type OpenRouterResponse = {
+  id: string;
+  object: 'chat.completion';
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: {
+      role: 'assistant';
+      content: string | null;
+      tool_calls?: OpenRouterToolCall[];
+    };
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;
+  }>;
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+};
+
+type OpenRouterStreamChunk = {
+  id: string;
+  object: 'chat.completion.chunk';
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    delta: {
+      role?: 'assistant';
+      content?: string;
+      tool_calls?: Array<{
+        index: number;
+        id?: string;
+        type?: 'function';
+        function?: {
+          name?: string;
+          arguments?: string;
+        };
+      }>;
+    };
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;
+  }>;
+};
+
+export class OpenRouterProvider implements LLMProvider {
+  name = 'openrouter';
+  private apiKey: string;
+  private defaultModel: string;
+  private apiUrl = 'https://openrouter.ai/api/v1/chat/completions';
+
+  constructor(apiKey: string, defaultModel = 'anthropic/claude-sonnet-4') {
+    this.apiKey = apiKey;
+    this.defaultModel = defaultModel;
+  }
+
+  async chat(messages: LLMMessage[], options: LLMOptions = {}): Promise<LLMResponse> {
+    const { model = this.defaultModel, temperature, max_tokens, tools, tool_choice } = options;
+
+    // Compact history for better reliability across routed models
+    const budget = calculateHistoryBudget(100000);
+    const compactedMessages = compactHistory(messages, budget);
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: this.convertMessages(compactedMessages),
+    };
+
+    if (temperature !== undefined) body.temperature = temperature;
+    if (max_tokens !== undefined) body.max_tokens = max_tokens;
+    if (tools && tools.length > 0) {
+      body.tools = this.convertTools(tools);
+      body.tool_choice = tool_choice || 'auto';
+    }
+
+    const response = await fetch(this.apiUrl, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+        'HTTP-Referer': 'https://github.com/jarvis-assistant',
+        'X-Title': 'Jarvis Assistant',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`OpenRouter API error (${response.status}): ${errorText}`);
+    }
+
+    const data = await response.json() as OpenRouterResponse;
+    return this.convertResponse(data);
+  }
+
+  async *stream(messages: LLMMessage[], options: LLMOptions = {}): AsyncIterable<LLMStreamEvent> {
+    const { model = this.defaultModel, temperature, max_tokens, tools, tool_choice } = options;
+
+    // Compact history for better reliability across routed models
+    const budget = calculateHistoryBudget(100000);
+    const compactedMessages = compactHistory(messages, budget);
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: this.convertMessages(compactedMessages),
+      stream: true,
+    };
+
+    if (temperature !== undefined) body.temperature = temperature;
+    if (max_tokens !== undefined) body.max_tokens = max_tokens;
+    if (tools && tools.length > 0) {
+      body.tools = this.convertTools(tools);
+      body.tool_choice = tool_choice || 'auto';
+    }
+
+    const response = await fetch(this.apiUrl, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+        'HTTP-Referer': 'https://github.com/jarvis-assistant',
+        'X-Title': 'Jarvis Assistant',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      yield { type: 'error', error: `OpenRouter API error (${response.status}): ${errorText}` };
+      return;
+    }
+
+    if (!response.body) {
+      yield { type: 'error', error: 'No response body' };
+      return;
+    }
+
+    let accumulatedText = '';
+    const toolCalls: LLMToolCall[] = [];
+    const toolCallBuilders: Map<number, { id: string; name: string; arguments: string }> = new Map();
+    let finishReason: string | null = null;
+    let responseModel = model;
+
+    try {
+      const reader = response.body.getReader();
+      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() || !line.startsWith('data: ')) continue;
+
+          const data = line.slice(6);
+          if (data === '[DONE]') continue;
+
+          try {
+            const chunk = JSON.parse(data) as OpenRouterStreamChunk;
+            if (chunk.choices && chunk.choices.length > 0) {
+              const choice = chunk.choices[0];
+              responseModel = chunk.model;
+
+              if (choice!.delta.content) {
+                accumulatedText += choice!.delta.content;
+                yield { type: 'text', text: choice!.delta.content };
+              }
+
+              if (choice!.delta.tool_calls) {
+                for (const toolCallDelta of choice!.delta.tool_calls) {
+                  const index = toolCallDelta.index;
+                  let builder = toolCallBuilders.get(index);
+
+                  if (!builder) {
+                    builder = {
+                      id: toolCallDelta.id || '',
+                      name: toolCallDelta.function?.name || '',
+                      arguments: '',
+                    };
+                    toolCallBuilders.set(index, builder);
+                  }
+
+                  if (toolCallDelta.id) builder.id = toolCallDelta.id;
+                  if (toolCallDelta.function?.name) builder.name = toolCallDelta.function.name;
+                  if (toolCallDelta.function?.arguments) {
+                    builder.arguments += toolCallDelta.function.arguments;
+                  }
+                }
+              }
+
+              if (choice!.finish_reason) {
+                finishReason = choice!.finish_reason;
+              }
+            }
+          } catch (err) {
+            // Skip invalid JSON lines
+            console.error('Failed to parse SSE chunk:', err);
+          }
+        }
+      }
+
+      // Convert accumulated tool calls
+      for (const builder of toolCallBuilders.values()) {
+        try {
+          const toolCall: LLMToolCall = {
+            id: builder.id,
+            name: builder.name,
+            arguments: JSON.parse(builder.arguments),
+          };
+          toolCalls.push(toolCall);
+          yield { type: 'tool_call', tool_call: toolCall };
+        } catch (err) {
+          yield { type: 'error', error: `Failed to parse tool call arguments: ${err}` };
+        }
+      }
+
+      const mappedFinishReason = this.mapFinishReason(finishReason);
+      yield {
+        type: 'done',
+        response: {
+          content: accumulatedText,
+          tool_calls: toolCalls,
+          usage: { input_tokens: 0, output_tokens: 0 }, // OpenRouter doesn't provide usage in stream
+          model: responseModel,
+          finish_reason: mappedFinishReason,
+        },
+      };
+    } catch (err) {
+      yield { type: 'error', error: `Stream error: ${err}` };
+    }
+  }
+
+  async listModels(): Promise<string[]> {
+    try {
+      const response = await fetch('https://openrouter.ai/api/v1/models', {
+        headers: {
+          'Authorization': `Bearer ${this.apiKey}`,
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error(`Failed to list models: ${response.status}`);
+      }
+
+      const data = await response.json() as { data: Array<{ id: string }> };
+      return data.data
+        .map(m => m.id)
+        .sort();
+    } catch (err) {
+      // Fallback to known popular models if API call fails
+      return [
+        'anthropic/claude-sonnet-4',
+        'anthropic/claude-haiku-4',
+        'google/gemini-2.5-pro-preview',
+        'google/gemini-2.5-flash-preview',
+        'meta-llama/llama-4-maverick',
+        'openai/gpt-4o',
+        'openai/gpt-4o-mini',
+        'mistralai/mistral-large',
+      ];
+    }
+  }
+
+  private convertMessages(messages: LLMMessage[]): OpenRouterMessage[] {
+    return messages.map((m) => {
+      const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+
+      const converted: OpenRouterMessage = {
+        role: m.role,
+        content: m.role === 'assistant' && m.tool_calls?.length ? (content || null) : content,
+      };
+
+      if (m.role === 'assistant' && m.tool_calls?.length) {
+        converted.tool_calls = m.tool_calls.map((tc) => ({
+          id: tc.id,
+          type: 'function',
+          function: {
+            name: tc.name,
+            arguments: JSON.stringify(tc.arguments),
+          },
+        }));
+      }
+
+      if (m.role === 'tool' && m.tool_call_id) {
+        converted.tool_call_id = m.tool_call_id;
+      }
+
+      return converted;
+    });
+  }
+
+  private convertTools(tools: LLMTool[]): OpenRouterToolDef[] {
+    return tools.map(tool => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+      },
+    }));
+  }
+
+  private convertResponse(response: OpenRouterResponse): LLMResponse {
+    const choice = response.choices[0]!;
+    const message = choice.message;
+    const content = message.content || '';
+    const tool_calls: LLMToolCall[] = [];
+
+    if (message.tool_calls) {
+      for (const toolCall of message.tool_calls) {
+        try {
+          tool_calls.push({
+            id: toolCall.id,
+            name: toolCall.function.name,
+            arguments: JSON.parse(toolCall.function.arguments),
+          });
+        } catch (err) {
+          console.error('Failed to parse tool call arguments:', err);
+        }
+      }
+    }
+
+    return {
+      content,
+      tool_calls,
+      usage: {
+        input_tokens: response.usage.prompt_tokens,
+        output_tokens: response.usage.completion_tokens,
+      },
+      model: response.model,
+      finish_reason: this.mapFinishReason(choice!.finish_reason),
+    };
+  }
+
+  private mapFinishReason(finishReason: string | null): 'stop' | 'tool_use' | 'length' | 'error' {
+    switch (finishReason) {
+      case 'stop':
+        return 'stop';
+      case 'tool_calls':
+        return 'tool_use';
+      case 'length':
+        return 'length';
+      case 'content_filter':
+        return 'error';
+      default:
+        return 'stop';
+    }
+  }
+}