@shykaruu/jarvis-brain 0.4.0

package/src/llm/manager.ts

@@ -0,0 +1,226 @@
+import type {
+  LLMProvider,
+  LLMMessage,
+  LLMOptions,
+  LLMResponse,
+  LLMStreamEvent,
+} from './provider.ts';
+
+export class LLMManager {
+  private providers: Map<string, LLMProvider> = new Map();
+  private primaryProvider = '';
+  private fallbackChain: string[] = [];
+  private static readonly MAX_RETRIES_PER_PROVIDER = 3;
+  private static readonly REQUEST_TIMEOUT_MS = 90000; // 90 second timeout for LLM calls
+  private static readonly isDebugging = process.env.JARVIS_LOG_LEVEL === 'debug' || process.env.DEBUG_LLM === 'true';
+
+  constructor() {}
+
+  registerProvider(provider: LLMProvider): void {
+    this.providers.set(provider.name, provider);
+
+    // Set as primary if it's the first provider
+    if (!this.primaryProvider) {
+      this.primaryProvider = provider.name;
+    }
+  }
+
+  setPrimary(name: string): void {
+    if (!this.providers.has(name)) {
+      throw new Error(`Provider '${name}' not registered`);
+    }
+    this.primaryProvider = name;
+  }
+
+  setFallbackChain(names: string[]): void {
+    for (const name of names) {
+      if (!this.providers.has(name)) {
+        throw new Error(`Provider '${name}' not registered`);
+      }
+    }
+    this.fallbackChain = names;
+  }
+
+  getProvider(name: string): LLMProvider | undefined {
+    return this.providers.get(name);
+  }
+
+  getPrimary(): string {
+    return this.primaryProvider;
+  }
+
+  getFallbackChain(): string[] {
+    return [...this.fallbackChain];
+  }
+
+  getProviderNames(): string[] {
+    return [...this.providers.keys()];
+  }
+
+  /**
+   * Atomically replace all providers. Safe for in-flight requests because
+   * JS is single-threaded and the map assignment is atomic.
+   */
+  replaceProviders(providers: LLMProvider[], primary: string, fallback: string[]): void {
+    const newMap = new Map<string, LLMProvider>();
+    for (const p of providers) {
+      newMap.set(p.name, p);
+    }
+    this.providers = newMap;
+    this.primaryProvider = newMap.has(primary) ? primary : (providers[0]?.name ?? '');
+    this.fallbackChain = fallback.filter(n => newMap.has(n));
+  }
+
+  /**
+   * Add request timeout wrapper for network resilience
+   */
+  private async withTimeout<T>(promise: Promise<T>, provider: string): Promise<T> {
+    return Promise.race([
+      promise,
+      new Promise<T>((_, reject) =>
+        setTimeout(
+          () => reject(new Error(`LLM request to ${provider} timed out after ${LLMManager.REQUEST_TIMEOUT_MS}ms`)),
+          LLMManager.REQUEST_TIMEOUT_MS
+        )
+      )
+    ]);
+  }
+
+  /**
+   * Classify error for better retry logic
+   */
+  private shouldRetry(error: unknown): boolean {
+    if (!(error instanceof Error)) return false;
+    
+    const msg = error.message.toLowerCase();
+    // Retry on network/timeout errors, not on auth/validation errors
+    return msg.includes('timeout') || 
+           msg.includes('econnrefused') || 
+           msg.includes('enotfound') ||
+           msg.includes('network') ||
+           msg.includes('temporarily unavailable') ||
+           msg.includes('429') ||  // rate limit
+           msg.includes('503');    // service unavailable
+  }
+
+  /**
+   * Temporarily override the primary provider for a single call.
+   * Used for per-message LLM selection from chat dashboard.
+   */
+  async chatWithOverride(
+    messages: LLMMessage[],
+    overridePrimary: string | null,
+    options?: LLMOptions
+  ): Promise<LLMResponse> {
+    const providerName = overridePrimary && this.providers.has(overridePrimary) ? overridePrimary : this.primaryProvider;
+    const provider = this.providers.get(providerName);
+    if (!provider) {
+      throw new Error(`Provider '${providerName}' not registered`);
+    }
+
+    const errors: string[] = [];
+    for (let attempt = 1; attempt <= LLMManager.MAX_RETRIES_PER_PROVIDER; attempt++) {
+      try {
+        const result = await this.withTimeout(provider.chat(messages, options), providerName);
+        if (LLMManager.isDebugging && attempt > 1) {
+          console.log(`[DEBUG] LLM ${providerName} succeeded on retry attempt ${attempt}`);
+        }
+        return result;
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        errors.push(`attempt ${attempt}: ${errorMsg}`);
+        
+        const shouldRetry = this.shouldRetry(err);
+        console.error(
+          `[LLM] Provider ${providerName} failed (attempt ${attempt}/${LLMManager.MAX_RETRIES_PER_PROVIDER})${!shouldRetry ? ' [no retry]' : ''}: ${errorMsg}`
+        );
+        
+        // Don't retry on fatal errors (auth, validation)
+        if (!shouldRetry && attempt > 1) break;
+      }
+    }
+
+    throw new Error(
+      `Provider '${providerName}' failed after ${LLMManager.MAX_RETRIES_PER_PROVIDER} attempts:\n${errors.map(e => `  ${e}`).join('\n')}`
+    );
+  }
+
+  async chat(messages: LLMMessage[], options?: LLMOptions): Promise<LLMResponse> {
+    const providerName = this.primaryProvider;
+    const provider = this.providers.get(providerName);
+    if (!provider) {
+      throw new Error(`Provider '${providerName}' not registered`);
+    }
+
+    const errors: string[] = [];
+    for (let attempt = 1; attempt <= LLMManager.MAX_RETRIES_PER_PROVIDER; attempt++) {
+      try {
+        const result = await this.withTimeout(provider.chat(messages, options), providerName);
+        if (LLMManager.isDebugging && attempt > 1) {
+          console.log(`[DEBUG] LLM ${providerName} succeeded on retry attempt ${attempt}`);
+        }
+        return result;
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        errors.push(`attempt ${attempt}: ${errorMsg}`);
+        
+        const shouldRetry = this.shouldRetry(err);
+        console.error(
+          `[LLM] Provider ${providerName} failed (attempt ${attempt}/${LLMManager.MAX_RETRIES_PER_PROVIDER})${!shouldRetry ? ' [no retry]' : ''}: ${errorMsg}`
+        );
+        
+        if (!shouldRetry && attempt > 1) break;
+      }
+    }
+
+    throw new Error(
+      `Provider '${providerName}' failed after ${LLMManager.MAX_RETRIES_PER_PROVIDER} attempts:\n${errors.map(e => `  ${e}`).join('\n')}`
+    );
+  }
+
+  async *stream(messages: LLMMessage[], options?: LLMOptions): AsyncIterable<LLMStreamEvent> {
+    const providerName = this.primaryProvider;
+    const provider = this.providers.get(providerName);
+    if (!provider) {
+      yield { type: 'error', error: `Provider '${providerName}' not registered` };
+      return;
+    }
+
+    const errors: string[] = [];
+    for (let attempt = 1; attempt <= LLMManager.MAX_RETRIES_PER_PROVIDER; attempt++) {
+      try {
+        let hasError = false;
+        for await (const event of provider.stream(messages, options)) {
+          if (event.type === 'error') {
+            hasError = true;
+            errors.push(`attempt ${attempt}: ${event.error}`);
+            console.error(
+              `[LLM] Provider ${providerName} stream error (attempt ${attempt}/${LLMManager.MAX_RETRIES_PER_PROVIDER}): ${event.error}`
+            );
+            break;
+          }
+          yield event;
+        }
+
+        if (!hasError) {
+          return;
+        }
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        errors.push(`attempt ${attempt}: ${errorMsg}`);
+        
+        const shouldRetry = this.shouldRetry(err);
+        console.error(
+          `[LLM] Provider ${providerName} stream failed (attempt ${attempt}/${LLMManager.MAX_RETRIES_PER_PROVIDER})${!shouldRetry ? ' [no retry]' : ''}: ${errorMsg}`
+        );
+        
+        if (!shouldRetry && attempt > 1) break;
+      }
+    }
+
+    yield {
+      type: 'error',
+      error: `Provider '${providerName}' failed after ${LLMManager.MAX_RETRIES_PER_PROVIDER} attempts:\n${errors.map(e => `  ${e}`).join('\n')}`,
+    };
+  }
+}

package/src/llm/ollama.ts

@@ -0,0 +1,316 @@
+import type {
+  LLMProvider,
+  LLMMessage,
+  LLMOptions,
+  LLMResponse,
+  LLMStreamEvent,
+  LLMTool,
+  LLMToolCall,
+} from './provider.ts';
+import { compactHistory, calculateHistoryBudget } from './history.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, tool_choice } = options;
+    
+    // Compact history for Ollama's context limits
+    const budget = calculateHistoryBudget(32000);
+    const compactedMessages = compactHistory(messages, budget);
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: this.convertMessages(compactedMessages),
+      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, tool_choice } = options;
+    
+    // Compact history for Ollama's context limits
+    const budget = calculateHistoryBudget(32000);
+    const compactedMessages = compactHistory(messages, budget);
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: this.convertMessages(compactedMessages),
+      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',
+    };
+  }
+}