@usejarvis/brain 0.1.0

package/src/llm/ollama.ts

@@ -0,0 +1,307 @@
+import type {
+  LLMProvider,
+  LLMMessage,
+  LLMOptions,
+  LLMResponse,
+  LLMStreamEvent,
+  LLMTool,
+  LLMToolCall,
+} from './provider.ts';
+
+type OllamaMessage = {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+  images?: string[];
+};
+
+type OllamaToolDef = {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+};
+
+type OllamaResponse = {
+  model: string;
+  created_at: string;
+  message: {
+    role: 'assistant';
+    content: string;
+    tool_calls?: Array<{
+      function: {
+        name: string;
+        arguments: Record<string, unknown>;
+      };
+    }>;
+  };
+  done: boolean;
+  total_duration?: number;
+  load_duration?: number;
+  prompt_eval_count?: number;
+  eval_count?: number;
+};
+
+type OllamaStreamChunk = {
+  model: string;
+  created_at: string;
+  message?: {
+    role: 'assistant';
+    content: string;
+    tool_calls?: Array<{
+      function: {
+        name: string;
+        arguments: Record<string, unknown>;
+      };
+    }>;
+  };
+  done: boolean;
+  total_duration?: number;
+  prompt_eval_count?: number;
+  eval_count?: number;
+};
+
+type OllamaModelInfo = {
+  name: string;
+  model: string;
+  modified_at: string;
+  size: number;
+  digest: string;
+};
+
+export class OllamaProvider implements LLMProvider {
+  name = 'ollama';
+  private baseUrl: string;
+  private defaultModel: string;
+
+  constructor(baseUrl = 'http://localhost:11434', defaultModel = 'llama3') {
+    this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+    this.defaultModel = defaultModel;
+  }
+
+  async chat(messages: LLMMessage[], options: LLMOptions = {}): Promise<LLMResponse> {
+    const { model = this.defaultModel, temperature, tools } = options;
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: this.convertMessages(messages),
+      stream: false,
+    };
+
+    if (temperature !== undefined) {
+      body.options = { temperature };
+    }
+
+    if (tools && tools.length > 0) {
+      body.tools = this.convertTools(tools);
+    }
+
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Ollama API error (${response.status}): ${errorText}`);
+    }
+
+    const data = await response.json() as OllamaResponse;
+    return this.convertResponse(data);
+  }
+
+  async *stream(messages: LLMMessage[], options: LLMOptions = {}): AsyncIterable<LLMStreamEvent> {
+    const { model = this.defaultModel, temperature, tools } = options;
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: this.convertMessages(messages),
+      stream: true,
+    };
+
+    if (temperature !== undefined) {
+      body.options = { temperature };
+    }
+
+    if (tools && tools.length > 0) {
+      body.tools = this.convertTools(tools);
+    }
+
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      yield { type: 'error', error: `Ollama API error (${response.status}): ${errorText}` };
+      return;
+    }
+
+    if (!response.body) {
+      yield { type: 'error', error: 'No response body' };
+      return;
+    }
+
+    let accumulatedText = '';
+    const toolCalls: LLMToolCall[] = [];
+    let responseModel = model;
+    let inputTokens = 0;
+    let outputTokens = 0;
+
+    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()) continue;
+
+          try {
+            const chunk = JSON.parse(line) as OllamaStreamChunk;
+            responseModel = chunk.model;
+
+            if (chunk.message?.content) {
+              accumulatedText += chunk.message.content;
+              yield { type: 'text', text: chunk.message.content };
+            }
+
+            if (chunk.message?.tool_calls) {
+              for (const toolCall of chunk.message.tool_calls) {
+                const id = `ollama_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+                const call: LLMToolCall = {
+                  id,
+                  name: toolCall.function.name,
+                  arguments: toolCall.function.arguments,
+                };
+                toolCalls.push(call);
+                yield { type: 'tool_call', tool_call: call };
+              }
+            }
+
+            if (chunk.done) {
+              inputTokens = chunk.prompt_eval_count || 0;
+              outputTokens = chunk.eval_count || 0;
+
+              yield {
+                type: 'done',
+                response: {
+                  content: accumulatedText,
+                  tool_calls: toolCalls,
+                  usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+                  model: responseModel,
+                  finish_reason: toolCalls.length > 0 ? 'tool_use' : 'stop',
+                },
+              };
+            }
+          } catch (err) {
+            console.error('Failed to parse Ollama chunk:', err);
+          }
+        }
+      }
+    } catch (err) {
+      yield { type: 'error', error: `Stream error: ${err}` };
+    }
+  }
+
+  async listModels(): Promise<string[]> {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`);
+
+      if (!response.ok) {
+        throw new Error(`Failed to list models: ${response.status}`);
+      }
+
+      const data = await response.json() as { models: OllamaModelInfo[] };
+      return data.models.map(m => m.name).sort();
+    } catch (err) {
+      // Fallback to common models if API call fails
+      return ['llama3', 'llama2', 'mistral', 'mixtral', 'codellama'];
+    }
+  }
+
+  private convertMessages(messages: LLMMessage[]): OllamaMessage[] {
+    return messages.map(m => {
+      if (typeof m.content === 'string') {
+        return {
+          role: m.role as 'system' | 'user' | 'assistant',
+          content: m.content,
+        };
+      }
+
+      // ContentBlock[] — extract text and images separately
+      let text = '';
+      const images: string[] = [];
+
+      for (const block of m.content) {
+        if (block.type === 'text') {
+          text += (text ? '\n' : '') + block.text;
+        } else if (block.type === 'image') {
+          images.push(block.source.data);
+        }
+      }
+
+      const msg: OllamaMessage = {
+        role: m.role as 'system' | 'user' | 'assistant',
+        content: text,
+      };
+      if (images.length > 0) {
+        msg.images = images;
+      }
+      return msg;
+    });
+  }
+
+  private convertTools(tools: LLMTool[]): OllamaToolDef[] {
+    return tools.map(tool => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+      },
+    }));
+  }
+
+  private convertResponse(response: OllamaResponse): LLMResponse {
+    const content = response.message.content;
+    const tool_calls: LLMToolCall[] = [];
+
+    if (response.message.tool_calls) {
+      for (const toolCall of response.message.tool_calls) {
+        const id = `ollama_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        tool_calls.push({
+          id,
+          name: toolCall.function.name,
+          arguments: toolCall.function.arguments,
+        });
+      }
+    }
+
+    return {
+      content,
+      tool_calls,
+      usage: {
+        input_tokens: response.prompt_eval_count || 0,
+        output_tokens: response.eval_count || 0,
+      },
+      model: response.model,
+      finish_reason: tool_calls.length > 0 ? 'tool_use' : 'stop',
+    };
+  }
+}

package/src/llm/openai.ts

@@ -0,0 +1,350 @@
+import type {
+  LLMProvider,
+  LLMMessage,
+  LLMOptions,
+  LLMResponse,
+  LLMStreamEvent,
+  LLMTool,
+  LLMToolCall,
+} from './provider.ts';
+
+type OpenAIMessage = {
+  role: 'system' | 'user' | 'assistant';
+  content: 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;
+  }>;
+};
+
+export class OpenAIProvider implements LLMProvider {
+  name = 'openai';
+  private apiKey: string;
+  private defaultModel: string;
+  private apiUrl = 'https://api.openai.com/v1/chat/completions';
+
+  constructor(apiKey: string, defaultModel = 'gpt-4o') {
+    this.apiKey = apiKey;
+    this.defaultModel = defaultModel;
+  }
+
+  async chat(messages: LLMMessage[], options: LLMOptions = {}): Promise<LLMResponse> {
+    const { model = this.defaultModel, temperature, max_tokens, tools } = options;
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: this.convertMessages(messages),
+    };
+
+    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);
+    }
+
+    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 } = options;
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: this.convertMessages(messages),
+      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);
+    }
+
+    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('https://api.openai.com/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)
+        .filter(id => id.startsWith('gpt-'))
+        .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 => ({
+      role: m.role as 'system' | 'user' | 'assistant',
+      content: m.content as string,
+    }));
+  }
+
+  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';
+    }
+  }
+}