@shykaruu/jarvis-brain 0.4.0

package/src/llm/openai.ts

@@ -0,0 +1,411 @@
+import type {
+  LLMProvider,
+  LLMMessage,
+  LLMOptions,
+  LLMResponse,
+  LLMStreamEvent,
+  LLMTool,
+  LLMToolCall,
+} from './provider.ts';
+import { compactHistory, calculateHistoryBudget } from './history.ts';
+
+type OpenAIMessage = {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string;
+  tool_calls?: OpenAIToolCall[];
+  tool_call_id?: string;
+};
+
+type OpenAIToolDef = {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+};
+
+type OpenAIToolCall = {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+};
+
+type OpenAIResponse = {
+  id: string;
+  object: 'chat.completion';
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: {
+      role: 'assistant';
+      content: string | null;
+      tool_calls?: OpenAIToolCall[];
+    };
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;
+  }>;
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+};
+
+type OpenAIStreamChunk = {
+  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;
+  }>;
+};
+
+const DEFAULT_OPENAI_BASE_URL = 'https://api.openai.com/v1/';
+const OFFICIAL_OPENAI_HOSTNAME = 'api.openai.com';
+
+export function resolveOpenAIBaseUrl(baseUrl?: string): URL {
+  const trimmed = baseUrl?.trim();
+  const rawBaseUrl = trimmed && trimmed.length > 0 ? trimmed : DEFAULT_OPENAI_BASE_URL;
+  const resolved = new URL(rawBaseUrl);
+
+  if (!resolved.pathname.endsWith('/')) {
+    resolved.pathname = `${resolved.pathname}/`;
+  }
+
+  return resolved;
+}
+
+export function isOfficialOpenAI(baseUrl?: string): boolean {
+  const trimmed = baseUrl?.trim();
+  if (!trimmed) return true;
+
+  try {
+    return resolveOpenAIBaseUrl(trimmed).hostname === OFFICIAL_OPENAI_HOSTNAME;
+  } catch {
+    return false;
+  }
+}
+
+export class OpenAIProvider implements LLMProvider {
+  name = 'openai';
+  private apiKey: string;
+  private defaultModel: string;
+  private baseUrl: string;
+  private apiUrl: string;
+  private modelsUrl: string;
+
+  constructor(apiKey: string, defaultModel = 'gpt-4o', baseUrl?: string) {
+    this.apiKey = apiKey;
+    this.defaultModel = defaultModel;
+    const resolvedBaseUrl = resolveOpenAIBaseUrl(baseUrl);
+    this.baseUrl = resolvedBaseUrl.toString();
+    this.apiUrl = new URL('chat/completions', resolvedBaseUrl).toString();
+    this.modelsUrl = new URL('models', resolvedBaseUrl).toString();
+  }
+
+  async chat(messages: LLMMessage[], options: LLMOptions = {}): Promise<LLMResponse> {
+    const { model = this.defaultModel, temperature, max_tokens, tools, tool_choice } = options;
+
+    // Compact history for large contexts (128k token limit)
+    const budget = calculateHistoryBudget(128000);
+    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';  // Enable tool calling
+    }
+
+    const response = await fetch(this.apiUrl, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`OpenAI API error (${response.status}): ${errorText}`);
+    }
+
+    const data = await response.json() as OpenAIResponse;
+    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 large contexts (128k token limit)
+    const budget = calculateHistoryBudget(128000);
+    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';  // Enable tool calling
+    }
+
+    const response = await fetch(this.apiUrl, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      yield { type: 'error', error: `OpenAI 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 OpenAIStreamChunk;
+            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 }, // OpenAI 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(this.modelsUrl, {
+        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 models if API call fails
+      return [
+        'gpt-4o',
+        'gpt-4o-mini',
+        'gpt-4-turbo',
+        'gpt-4',
+        'gpt-3.5-turbo',
+      ];
+    }
+  }
+
+  private convertMessages(messages: LLMMessage[]): OpenAIMessage[] {
+    return messages.map(m => {
+      const text = typeof m.content === 'string'
+        ? m.content
+        : m.content.map((b) => b.type === 'text' ? b.text : '[image]').join('\n');
+      const msg: OpenAIMessage = {
+        role: m.role as 'system' | 'user' | 'assistant' | 'tool',
+        // When assistant made tool calls, content must be null (not empty string)
+        content: (m.tool_calls && m.tool_calls.length > 0) ? '' : text,
+      };
+      if (m.tool_calls && m.tool_calls.length > 0) {
+        msg.tool_calls = m.tool_calls.map(tc => ({
+          id: tc.id,
+          type: 'function' as const,
+          function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+        }));
+      }
+      if (m.tool_call_id) {
+        msg.tool_call_id = m.tool_call_id;
+      }
+      return msg;
+    });
+  }
+
+  private convertTools(tools: LLMTool[]): OpenAIToolDef[] {
+    return tools.map(tool => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+      },
+    }));
+  }
+
+  private convertResponse(response: OpenAIResponse): 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';
+    }
+  }
+}