centaurus-cli 3.0.1 → 3.1.0

package/dist/services/ai-service-client.js

@@ -1,484 +1,541 @@
-/**
- * AI Service Client
- *
- * Handles communication with the backend AI proxy service for streaming
- * AI chat requests. Replaces direct Gemini SDK usage in the CLI.
- */
-import { apiClient } from './api-client.js';
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import { IS_DEV_BUILD, DEV_BACKEND_URL, PRODUCTION_BACKEND_URL } from '../config/build-config.js';
-import { logWarning } from '../utils/logger.js';
-import { ollamaService, OllamaService } from './ollama-service.js';
-import { quickLog } from '../utils/conversation-logger.js';
-/**
- * AI Service Client for streaming chat requests to backend
- */
-export class AIServiceClient {
-    baseURL;
-    maxRetries = 3;
-    retryDelay = 1000; // Start with 1 second
-    constructor() {
-        // Don't set baseURL yet - lazy load it when first used
-        // This allows environment variables to be loaded first
-        this.baseURL = '';
+import { apiClient } from "./api-client.js";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { IS_DEV_BUILD, DEV_BACKEND_URL, PRODUCTION_BACKEND_URL } from "../config/build-config.js";
+import { logWarning } from "../utils/logger.js";
+import { ollamaService, OllamaService } from "./ollama-service.js";
+import { quickLog } from "../utils/conversation-logger.js";
+class AIServiceClient {
+  baseURL;
+  maxRetries = 5;
+  retryDelay = 1e3;
+  // Start with 1 second
+  maxRetryDelay = 3e4;
+  maxRetryAfterDelay = 6e4;
+  highDemandMessage = "Very high demand right now. Please wait and retry after some time.";
+  constructor() {
+    this.baseURL = "";
+  }
+  /**
+   * Get the base URL for API requests
+   * Lazy-loaded to ensure environment variables are loaded first
+   */
+  getBaseURL() {
+    if (!this.baseURL) {
+      this.baseURL = IS_DEV_BUILD ? DEV_BACKEND_URL : PRODUCTION_BACKEND_URL;
     }
-    /**
-     * Get the base URL for API requests
-     * Lazy-loaded to ensure environment variables are loaded first
-     */
-    getBaseURL() {
-        if (!this.baseURL) {
-            // Import build config - values frozen at compile time for security
-            // SECURITY: This prevents malicious .env files from overriding production URLs
-            // Use production URL in production builds, localhost only in dev builds
-            this.baseURL = IS_DEV_BUILD ? DEV_BACKEND_URL : PRODUCTION_BACKEND_URL;
-        }
-        return this.baseURL;
-    }
-    /**
-     * Stream chat request to backend AI proxy
-     *
-     * @param model - The AI model to use (e.g., 'gemini-2.5-flash')
-     * @param messages - Conversation history including system, user, assistant, and tool messages
-     * @param tools - Available tool schemas for the AI to use
-     * @param environmentContext - Optional environment context (OS, shell, cwd, etc.)
-     * @param mode - Optional mode (default, plan, command)
-     * @yields Stream chunks (text, tool calls, done, or error events)
-     */
-    async *streamChat(model, messages, tools, environmentContext, mode, thinkingConfig, abortSignal) {
-        // Check if using a local Ollama model
-        if (this.isUsingLocalModel()) {
-            const localModel = this.getCurrentModel();
-            const supportsTools = OllamaService.modelSupportsTools(localModel);
-            quickLog(`[${new Date().toISOString()}] [AIServiceClient] Routing to local Ollama model: ${localModel}, supportsTools: ${supportsTools}\n`);
-            // Show warning only if tools are provided but model doesn't support them
-            if (tools.length > 0 && !supportsTools) {
-                yield {
-                    type: 'text',
-                    content: `⚠️ Note: Model "${localModel}" does not support tool calling. Running in text-only mode.\n\n`,
-                };
-            }
-            // Route to local Ollama with tools
-            yield* this.streamLocalChat(localModel, messages, tools);
-            return;
-        }
-        // Build request payload for cloud backend
-        const payload = {
-            model,
-            messages,
-            tools,
-            stream: true,
-            clientType: 'cli', // Tell backend this is a CLI request
-            environmentContext,
-            mode,
-            thinkingConfig,
+    return this.baseURL;
+  }
+  /**
+   * Stream chat request to backend AI proxy
+   * 
+   * @param model - The AI model to use (e.g., 'gemini-2.5-flash')
+   * @param messages - Conversation history including system, user, assistant, and tool messages
+   * @param tools - Available tool schemas for the AI to use
+   * @param environmentContext - Optional environment context (OS, shell, cwd, etc.)
+   * @param mode - Optional mode (default, plan, command)
+   * @yields Stream chunks (text, tool calls, done, or error events)
+   */
+  async *streamChat(model, messages, tools, environmentContext, mode, thinkingConfig, abortSignal) {
+    if (this.isUsingLocalModel()) {
+      const localModel = this.getCurrentModel();
+      const supportsTools = OllamaService.modelSupportsTools(localModel);
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [AIServiceClient] Routing to local Ollama model: ${localModel}, supportsTools: ${supportsTools}
+`);
+      if (tools.length > 0 && !supportsTools) {
+        yield {
+          type: "text",
+          content: `\u26A0\uFE0F Note: Model "${localModel}" does not support tool calling. Running in text-only mode.
+
+`
         };
-        // Get authentication token from api client
-        if (!apiClient.isAuthenticated()) {
+      }
+      yield* this.streamLocalChat(localModel, messages, tools);
+      return;
+    }
+    const payload = {
+      model,
+      messages,
+      tools,
+      stream: true,
+      clientType: "cli",
+      // Tell backend this is a CLI request
+      environmentContext,
+      mode,
+      thinkingConfig
+    };
+    if (!apiClient.isAuthenticated()) {
+      yield {
+        type: "error",
+        message: "Authentication required. Please sign in.",
+        code: "AUTH_REQUIRED"
+      };
+      return;
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        const response = await fetch(`${this.getBaseURL()}/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this.getSessionToken()}`
+          },
+          body: JSON.stringify(payload),
+          signal: abortSignal
+          // Only abort when user explicitly cancels
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          const parsedHttpError = this.parseHttpError(response.status, response.statusText, errorText);
+          if (response.status === 401) {
             yield {
-                type: 'error',
-                message: 'Authentication required. Please sign in.',
-                code: 'AUTH_REQUIRED',
+              type: "error",
+              message: "Session expired. Please sign in again.",
+              code: "AUTH_REQUIRED"
             };
             return;
+          }
+          lastError = parsedHttpError;
+          if (this.isRetryableError(parsedHttpError.code, parsedHttpError.message, response.status) && attempt < this.maxRetries - 1) {
+            const retryAfterMs = this.getRetryAfterMs(response.headers);
+            await this.sleep(this.getRetryDelayMs(attempt, retryAfterMs));
+            continue;
+          }
+          if (this.isRateLimitError(parsedHttpError.code, parsedHttpError.message, response.status)) {
+            yield this.createHighDemandError();
+            return;
+          }
+          yield parsedHttpError;
+          return;
         }
-        // Retry logic for transient errors
-        let lastError = null;
-        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
-            try {
-                // Make fetch request to backend AI endpoint
-                // NOTE: We intentionally do NOT set a timeout here because:
-                // 1. Tool execution happens during streaming (in-stream execution)
-                // 2. Interactive commands may require user input for arbitrary duration
-                // 3. The only timeout should be explicit user cancellation via abortSignal
-                // Connection issues will manifest as network errors, not timeouts
-                const response = await fetch(`${this.getBaseURL()}/ai/chat`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${this.getSessionToken()}`,
-                    },
-                    body: JSON.stringify(payload),
-                    signal: abortSignal, // Only abort when user explicitly cancels
-                });
-                // Check for HTTP errors
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-                    let errorCode = 'HTTP_ERROR';
-                    try {
-                        const errorData = JSON.parse(errorText);
-                        if (errorData.error) {
-                            errorMessage = errorData.error.message || errorMessage;
-                            errorCode = errorData.error.code || errorCode;
-                        }
-                    }
-                    catch {
-                        // If response is not JSON, use the text as message
-                        if (errorText) {
-                            errorMessage = errorText;
-                        }
-                    }
-                    // Handle specific error codes
-                    if (response.status === 401) {
-                        yield {
-                            type: 'error',
-                            message: 'Session expired. Please sign in again.',
-                            code: 'AUTH_REQUIRED',
-                        };
-                        return;
-                    }
-                    if (response.status === 429) {
-                        // Rate limit - don't retry immediately
-                        yield {
-                            type: 'error',
-                            message: 'Service temporarily unavailable due to high demand. Please try again in a moment.',
-                            code: 'RATE_LIMIT',
-                        };
-                        return;
-                    }
-                    if (response.status === 504) {
-                        // Timeout error - retryable
-                        lastError = {
-                            type: 'error',
-                            message: 'Request timed out. Retrying...',
-                            code: 'TIMEOUT',
-                        };
-                        if (attempt < this.maxRetries - 1) {
-                            await this.sleep(this.retryDelay * Math.pow(2, attempt));
-                            continue;
-                        }
-                    }
-                    // For other errors, yield and return
-                    yield {
-                        type: 'error',
-                        message: errorMessage,
-                        code: errorCode,
-                    };
-                    return;
-                }
-                // Parse SSE stream
-                // We iterate manually to catch retryable errors from the stream
-                let contentReceived = false;
-                let shouldRetry = false;
-                for await (const chunk of this.parseSSEStream(response.body)) {
-                    if (chunk.type === 'error') {
-                        // Check if this is a retryable error (like rate limit) AND we haven't sent partial content yet
-                        if (this.isRetryableError(chunk.code) && !contentReceived) {
-                            lastError = chunk;
-                            shouldRetry = true;
-                            break; // Break the stream loop to trigger retry
-                        }
-                        // Not retryable or content already sent - yield error and stop
-                        yield chunk;
-                        return;
-                    }
-                    // Mark that we've received content
-                    if (chunk.type !== 'done' && chunk.type !== 'thought' && chunk.type !== 'thinking_signature') {
-                        contentReceived = true;
-                    }
-                    yield chunk;
-                }
-                // If stream finished cleanly (without error chunk), we are done
-                if (!shouldRetry) {
-                    return;
-                }
-                // If we need to retry, check attempts and wait
-                if (attempt < this.maxRetries - 1) {
-                    // We're going to retry, so we need to wait for the backoff period
-                    await this.sleep(this.retryDelay * Math.pow(2, attempt));
-                    continue;
-                }
-                // If we've exhausted retries, we'll fall through to the end of the loop 
-                // and yield the lastError below
-            }
-            catch (error) {
-                // Handle network errors
-                if (error.name === 'TypeError' && error.message.includes('fetch')) {
-                    lastError = {
-                        type: 'error',
-                        message: 'Backend service is unreachable. Please check your connection.',
-                        code: 'NETWORK_ERROR',
-                    };
-                }
-                else if (error.name === 'AbortError' || error.name === 'TimeoutError') {
-                    lastError = {
-                        type: 'error',
-                        message: 'Request timed out. Please try again.',
-                        code: 'TIMEOUT',
-                    };
-                }
-                else {
-                    lastError = {
-                        type: 'error',
-                        message: error.message || 'Unknown error occurred',
-                        code: error.code || 'UNKNOWN_ERROR',
-                    };
-                }
-                // Retry for transient errors
-                if (this.isRetryableError(lastError.code) && attempt < this.maxRetries - 1) {
-                    await this.sleep(this.retryDelay * Math.pow(2, attempt));
-                    continue;
-                }
-                // If not retryable or max retries reached, yield error and return
-                break;
+        let contentReceived = false;
+        let shouldRetry = false;
+        for await (const chunk of this.parseSSEStream(response.body)) {
+          if (chunk.type === "error") {
+            const normalizedChunk = this.normalizeErrorChunk(chunk);
+            if (this.isRetryableError(normalizedChunk.code, normalizedChunk.message) && !contentReceived) {
+              lastError = normalizedChunk;
+              shouldRetry = true;
+              break;
             }
+            yield normalizedChunk;
+            return;
+          }
+          if (chunk.type !== "done" && chunk.type !== "thought" && chunk.type !== "thinking_signature" && chunk.type !== "file_descriptions") {
+            contentReceived = true;
+          }
+          yield chunk;
         }
-        // If we get here, we've exhausted retries
-        if (lastError) {
-            yield lastError;
+        if (!shouldRetry) {
+          return;
         }
-    }
-    /**
-     * Check if an error code is retryable
-     */
-    isRetryableError(code) {
-        const retryableCodes = ['NETWORK_ERROR', 'TIMEOUT', 'UNKNOWN_ERROR', 'RATE_LIMIT'];
-        return retryableCodes.includes(code);
-    }
-    /**
-     * Sleep for specified milliseconds
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Get session token from apiClient
-     * This is a workaround since sessionToken is private
-     */
-    getSessionToken() {
-        // Read session token from the same location apiClient uses
-        const configPath = join(homedir(), '.centaurus', 'session.json');
-        try {
-            if (existsSync(configPath)) {
-                const data = readFileSync(configPath, 'utf-8');
-                const session = JSON.parse(data);
-                return session.sessionToken || '';
-            }
+        if (attempt < this.maxRetries - 1) {
+          await this.sleep(this.getRetryDelayMs(attempt));
+          continue;
         }
-        catch (error) {
-            // Return empty string if unable to read
+      } catch (error) {
+        lastError = this.normalizeThrownError(error);
+        const wasIntentionalAbort = (error?.name === "AbortError" || error?.name === "TimeoutError") && !!abortSignal?.aborted;
+        if (wasIntentionalAbort) {
+          break;
         }
-        return '';
-    }
-    /**
-     * Check if the current configuration is using a local Ollama model
-     */
-    isUsingLocalModel() {
-        const configPath = join(homedir(), '.centaurus', 'config.json');
-        try {
-            if (existsSync(configPath)) {
-                const data = readFileSync(configPath, 'utf-8');
-                const config = JSON.parse(data);
-                return config.isLocalModel === true;
-            }
-        }
-        catch (error) {
-            // Return false if unable to read
+        if (this.isRetryableError(lastError.code, lastError.message) && attempt < this.maxRetries - 1) {
+          await this.sleep(this.getRetryDelayMs(attempt));
+          continue;
         }
-        return false;
+        break;
+      }
     }
-    /**
-     * Get the current model name from config
-     */
-    getCurrentModel() {
-        const configPath = join(homedir(), '.centaurus', 'config.json');
-        try {
-            if (existsSync(configPath)) {
-                const data = readFileSync(configPath, 'utf-8');
-                const config = JSON.parse(data);
-                return config.model || 'gemini-2.5-flash';
-            }
-        }
-        catch (error) {
-            // Return default if unable to read
+    if (lastError) {
+      if (this.isRateLimitError(lastError.code, lastError.message)) {
+        yield this.createHighDemandError();
+        return;
+      }
+      yield lastError;
+    }
+  }
+  /**
+   * Create a normalized high-demand error response.
+   */
+  createHighDemandError() {
+    return {
+      type: "error",
+      message: this.highDemandMessage,
+      code: "RATE_LIMIT"
+    };
+  }
+  /**
+   * Parse backend HTTP error body into a normalized error chunk.
+   */
+  parseHttpError(status, statusText, errorText) {
+    let errorMessage = `HTTP ${status}: ${statusText}`;
+    let errorCode = "HTTP_ERROR";
+    if (errorText) {
+      try {
+        const parsed = JSON.parse(errorText);
+        const rootError = Array.isArray(parsed) ? parsed[0]?.error ?? parsed[0] : parsed?.error ?? parsed;
+        if (rootError) {
+          if (typeof rootError.message === "string" && rootError.message.trim()) {
+            errorMessage = rootError.message;
+          }
+          if (typeof rootError.code === "string" || typeof rootError.code === "number") {
+            errorCode = String(rootError.code);
+          } else if (typeof rootError.status === "string") {
+            errorCode = rootError.status;
+          }
         }
-        return 'gemini-2.5-flash';
+      } catch {
+        errorMessage = errorText;
+      }
     }
-    /**
-     * Convert internal message format to Ollama format (with tool support)
-     */
-    convertToOllamaMessages(messages) {
-        return messages.map(msg => {
-            if (msg.role === 'tool') {
-                // Tool results - convert to Ollama's tool message format
-                return {
-                    role: 'tool',
-                    content: msg.content,
-                    tool_name: msg.tool_call_id || 'unknown', // Use tool_call_id as tool_name
-                };
-            }
-            if (msg.role === 'assistant' && msg.tool_calls?.length) {
-                // Assistant message with tool calls
-                return {
-                    role: 'assistant',
-                    content: msg.content || '',
-                    tool_calls: msg.tool_calls.map(tc => ({
-                        function: {
-                            name: tc.name,
-                            arguments: tc.arguments,
-                        }
-                    })),
-                };
-            }
-            // Regular message
-            return {
-                role: msg.role,
-                content: msg.content,
-            };
-        });
+    if (status === 504) {
+      return {
+        type: "error",
+        message: "Request timed out. Please try again.",
+        code: "TIMEOUT"
+      };
     }
-    /**
-     * Convert ToolSchema array to Ollama tool format
-     */
-    convertToolsToOllamaFormat(tools) {
-        return tools.map(tool => ({
-            type: 'function',
-            function: {
-                name: tool.name,
-                description: tool.description,
-                parameters: {
-                    type: 'object',
-                    properties: tool.parameters.properties,
-                    required: tool.parameters.required,
-                },
-            },
-        }));
+    if (this.isRateLimitError(errorCode, errorMessage, status)) {
+      return this.createHighDemandError();
     }
-    /**
-     * Stream chat request to local Ollama instance with tool calling support
-     *
-     * @param model - The local Ollama model to use (e.g., 'llama3.2:latest')
-     * @param messages - Conversation history
-     * @param tools - Available tools (will be converted to Ollama format)
-     * @yields Stream chunks (text, tool_call, or done events)
-     */
-    async *streamLocalChat(model, messages, tools = []) {
-        try {
-            const supportsTools = OllamaService.modelSupportsTools(model);
-            const effectiveTools = supportsTools ? tools : [];
-            quickLog(`[${new Date().toISOString()}] [AIServiceClient] Starting local chat with model: ${model}, tools: ${effectiveTools.length}, supportsTools: ${supportsTools}\n`);
-            // Convert messages to Ollama format
-            const ollamaMessages = this.convertToOllamaMessages(messages);
-            // Convert tools to Ollama format if model supports them
-            const ollamaTools = effectiveTools.length > 0
-                ? this.convertToolsToOllamaFormat(effectiveTools)
-                : undefined;
-            // Send request to Ollama with tools
-            const response = await ollamaService.sendChatMessage(model, ollamaMessages, ollamaTools);
-            // Check for tool calls in response
-            if (response.message?.tool_calls?.length) {
-                quickLog(`[${new Date().toISOString()}] [AIServiceClient] Received ${response.message.tool_calls.length} tool calls from Ollama\n`);
-                // Yield each tool call
-                for (const toolCall of response.message.tool_calls) {
-                    yield {
-                        type: 'tool_call',
-                        toolCall: {
-                            id: `ollama-${Date.now()}-${toolCall.function.name}`, // Generate unique ID
-                            name: toolCall.function.name,
-                            arguments: toolCall.function.arguments,
-                        },
-                    };
-                }
-                // Signal completion (tool execution will happen in cli-adapter)
-                yield { type: 'done' };
-                return;
-            }
-            // No tool calls - yield text response
-            if (response.message.content) {
-                yield {
-                    type: 'text',
-                    content: response.message.content,
-                };
+    return {
+      type: "error",
+      message: errorMessage,
+      code: errorCode
+    };
+  }
+  /**
+   * Normalize streamed error chunks to stable internal codes/messages.
+   */
+  normalizeErrorChunk(chunk) {
+    const normalizedCode = chunk.code ? String(chunk.code) : "UNKNOWN_ERROR";
+    const normalizedMessage = chunk.message || "Unknown error occurred";
+    if (this.isRateLimitError(normalizedCode, normalizedMessage)) {
+      return this.createHighDemandError();
+    }
+    if (normalizedCode === "504") {
+      return {
+        type: "error",
+        message: "Request timed out. Please try again.",
+        code: "TIMEOUT"
+      };
+    }
+    return {
+      type: "error",
+      message: normalizedMessage,
+      code: normalizedCode
+    };
+  }
+  /**
+   * Normalize thrown errors from fetch/network/runtime paths.
+   */
+  normalizeThrownError(error) {
+    const rawMessage = error?.message || "Unknown error occurred";
+    const rawCode = error?.code ? String(error.code) : "UNKNOWN_ERROR";
+    if (this.isRateLimitError(rawCode, rawMessage, error?.status)) {
+      return this.createHighDemandError();
+    }
+    if (error?.name === "TypeError" && rawMessage.includes("fetch")) {
+      return {
+        type: "error",
+        message: "Backend service is unreachable. Please check your connection.",
+        code: "NETWORK_ERROR"
+      };
+    }
+    if (error?.name === "AbortError" || error?.name === "TimeoutError") {
+      return {
+        type: "error",
+        message: "Request timed out. Please try again.",
+        code: "TIMEOUT"
+      };
+    }
+    return {
+      type: "error",
+      message: rawMessage,
+      code: rawCode
+    };
+  }
+  /**
+   * Check if an error is a rate-limit/resource-exhausted signal.
+   */
+  isRateLimitError(code, message = "", status) {
+    const normalizedCode = (code || "").toString().toLowerCase();
+    const normalizedMessage = message.toLowerCase();
+    return status === 429 || normalizedCode === "429" || normalizedCode === "8" || normalizedCode === "rate_limit" || normalizedCode === "resource_exhausted" || normalizedMessage.includes("rate limit") || normalizedMessage.includes("too many requests") || normalizedMessage.includes("quota") || normalizedMessage.includes("resource exhausted") || normalizedMessage.includes("resource_exhausted") || normalizedMessage.includes("maas api returned 429");
+  }
+  /**
+   * Check if HTTP status is retryable.
+   */
+  isRetryableStatus(status) {
+    if (typeof status !== "number") {
+      return false;
+    }
+    return [408, 425, 429, 500, 502, 503, 504].includes(status);
+  }
+  /**
+   * Check if an error should be retried.
+   */
+  isRetryableError(code, message = "", status) {
+    if (this.isRateLimitError(code, message, status)) {
+      return true;
+    }
+    if (this.isRetryableStatus(status)) {
+      return true;
+    }
+    const retryableCodes = ["NETWORK_ERROR", "TIMEOUT", "UNKNOWN_ERROR", "RATE_LIMIT"];
+    if (retryableCodes.includes(code)) {
+      return true;
+    }
+    const normalizedMessage = message.toLowerCase();
+    return normalizedMessage.includes("timeout") || normalizedMessage.includes("timed out") || normalizedMessage.includes("temporarily unavailable") || normalizedMessage.includes("network error");
+  }
+  /**
+   * Parse Retry-After from response headers.
+   */
+  getRetryAfterMs(headers) {
+    const retryAfterValue = headers.get("retry-after");
+    if (!retryAfterValue) {
+      return void 0;
+    }
+    const seconds = Number(retryAfterValue);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return seconds * 1e3;
+    }
+    const retryAfterDate = Date.parse(retryAfterValue);
+    if (!Number.isNaN(retryAfterDate)) {
+      return Math.max(0, retryAfterDate - Date.now());
+    }
+    return void 0;
+  }
+  /**
+   * Compute retry delay with exponential backoff + jitter.
+   */
+  getRetryDelayMs(attempt, retryAfterMs) {
+    const exponentialDelay = this.retryDelay * Math.pow(2, attempt);
+    const cappedDelay = Math.min(exponentialDelay, this.maxRetryDelay);
+    const jitteredDelay = Math.round(Math.min(cappedDelay * (0.5 + Math.random()), this.maxRetryDelay));
+    if (retryAfterMs === void 0) {
+      return jitteredDelay;
+    }
+    const cappedRetryAfter = Math.min(Math.max(0, retryAfterMs), this.maxRetryAfterDelay);
+    return Math.max(jitteredDelay, cappedRetryAfter);
+  }
+  /**
+   * Sleep for specified milliseconds
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get session token from apiClient
+   * This is a workaround since sessionToken is private
+   */
+  getSessionToken() {
+    const configPath = join(homedir(), ".centaurus", "session.json");
+    try {
+      if (existsSync(configPath)) {
+        const data = readFileSync(configPath, "utf-8");
+        const session = JSON.parse(data);
+        return session.sessionToken || "";
+      }
+    } catch (error) {
+    }
+    return "";
+  }
+  /**
+   * Check if the current configuration is using a local Ollama model
+   */
+  isUsingLocalModel() {
+    const configPath = join(homedir(), ".centaurus", "config.json");
+    try {
+      if (existsSync(configPath)) {
+        const data = readFileSync(configPath, "utf-8");
+        const config = JSON.parse(data);
+        return config.isLocalModel === true;
+      }
+    } catch (error) {
+    }
+    return false;
+  }
+  /**
+   * Get the current model name from config
+   */
+  getCurrentModel() {
+    const configPath = join(homedir(), ".centaurus", "config.json");
+    try {
+      if (existsSync(configPath)) {
+        const data = readFileSync(configPath, "utf-8");
+        const config = JSON.parse(data);
+        return config.model || "gemini-2.5-flash";
+      }
+    } catch (error) {
+    }
+    return "gemini-2.5-flash";
+  }
+  /**
+   * Convert internal message format to Ollama format (with tool support)
+   */
+  convertToOllamaMessages(messages) {
+    return messages.map((msg) => {
+      if (msg.role === "tool") {
+        return {
+          role: "tool",
+          content: msg.content,
+          tool_name: msg.tool_call_id || "unknown"
+          // Use tool_call_id as tool_name
+        };
+      }
+      if (msg.role === "assistant" && msg.tool_calls?.length) {
+        return {
+          role: "assistant",
+          content: msg.content || "",
+          tool_calls: msg.tool_calls.map((tc) => ({
+            function: {
+              name: tc.name,
+              arguments: tc.arguments
             }
-            // Signal completion
-            yield { type: 'done' };
-            quickLog(`[${new Date().toISOString()}] [AIServiceClient] Local chat completed\n`);
+          }))
+        };
+      }
+      return {
+        role: msg.role,
+        content: msg.content
+      };
+    });
+  }
+  /**
+   * Convert ToolSchema array to Ollama tool format
+   */
+  convertToolsToOllamaFormat(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: "object",
+          properties: tool.parameters.properties,
+          required: tool.parameters.required
         }
-        catch (error) {
-            quickLog(`[${new Date().toISOString()}] [AIServiceClient] Local chat error: ${error.message}\n`);
-            yield {
-                type: 'error',
-                message: error.message || 'Failed to communicate with Ollama',
-                code: 'OLLAMA_ERROR',
-            };
+      }
+    }));
+  }
+  /**
+   * Stream chat request to local Ollama instance with tool calling support
+   * 
+   * @param model - The local Ollama model to use (e.g., 'llama3.2:latest')
+   * @param messages - Conversation history
+   * @param tools - Available tools (will be converted to Ollama format)
+   * @yields Stream chunks (text, tool_call, or done events)
+   */
+  async *streamLocalChat(model, messages, tools = []) {
+    try {
+      const supportsTools = OllamaService.modelSupportsTools(model);
+      const effectiveTools = supportsTools ? tools : [];
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [AIServiceClient] Starting local chat with model: ${model}, tools: ${effectiveTools.length}, supportsTools: ${supportsTools}
+`);
+      const ollamaMessages = this.convertToOllamaMessages(messages);
+      const ollamaTools = effectiveTools.length > 0 ? this.convertToolsToOllamaFormat(effectiveTools) : void 0;
+      const response = await ollamaService.sendChatMessage(model, ollamaMessages, ollamaTools);
+      if (response.message?.tool_calls?.length) {
+        quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [AIServiceClient] Received ${response.message.tool_calls.length} tool calls from Ollama
+`);
+        for (const toolCall of response.message.tool_calls) {
+          yield {
+            type: "tool_call",
+            toolCall: {
+              id: `ollama-${Date.now()}-${toolCall.function.name}`,
+              // Generate unique ID
+              name: toolCall.function.name,
+              arguments: toolCall.function.arguments
+            }
+          };
         }
+        yield { type: "done" };
+        return;
+      }
+      if (response.message.content) {
+        yield {
+          type: "text",
+          content: response.message.content
+        };
+      }
+      yield { type: "done" };
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [AIServiceClient] Local chat completed
+`);
+    } catch (error) {
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [AIServiceClient] Local chat error: ${error.message}
+`);
+      yield {
+        type: "error",
+        message: error.message || "Failed to communicate with Ollama",
+        code: "OLLAMA_ERROR"
+      };
     }
-    /**
-     * Parse Server-Sent Events stream from response body
-     *
-     * @param body - ReadableStream from fetch response
-     * @yields Parsed stream chunks
-     */
-    async *parseSSEStream(body) {
-        const reader = body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = '';
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    // Process any remaining data in buffer before exiting
-                    if (buffer.trim()) {
-                        // Split remaining buffer and process
-                        const remainingLines = buffer.split('\n');
-                        for (const line of remainingLines) {
-                            if (line.startsWith('data: ')) {
-                                const dataStr = line.slice(6);
-                                if (dataStr.trim()) {
-                                    try {
-                                        const chunk = JSON.parse(dataStr);
-                                        yield chunk;
-                                    }
-                                    catch (error) {
-                                        // Skip malformed JSON
-                                        logWarning(`Failed to parse SSE data (in buffer): ${dataStr}`);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    break;
-                }
-                // Decode chunk and add to buffer
-                buffer += decoder.decode(value, { stream: true });
-                // Process complete lines in buffer
-                const lines = buffer.split('\n');
-                // Keep the last incomplete line in buffer
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    // SSE format: "data: {json}"
-                    if (line.startsWith('data: ')) {
-                        const dataStr = line.slice(6); // Remove "data: " prefix
-                        // Skip empty data lines
-                        if (!dataStr.trim()) {
-                            continue;
-                        }
-                        try {
-                            const chunk = JSON.parse(dataStr);
-                            yield chunk;
-                            // Stop if we receive a done or error event
-                            if (chunk.type === 'done' || chunk.type === 'error') {
-                                return;
-                            }
-                        }
-                        catch (error) {
-                            // Skip malformed JSON
-                            logWarning(`Failed to parse SSE data: ${dataStr}`);
-                        }
-                    }
-                    // SSE event type line: "event: chunk"
-                    // We don't need to process these separately since the data contains the type
+  }
+  /**
+   * Parse Server-Sent Events stream from response body
+   * 
+   * @param body - ReadableStream from fetch response
+   * @yields Parsed stream chunks
+   */
+  async *parseSSEStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          if (buffer.trim()) {
+            const remainingLines = buffer.split("\n");
+            for (const line of remainingLines) {
+              if (line.startsWith("data: ")) {
+                const dataStr = line.slice(6);
+                if (dataStr.trim()) {
+                  try {
+                    const chunk = JSON.parse(dataStr);
+                    yield chunk;
+                  } catch (error) {
+                    logWarning(`Failed to parse SSE data (in buffer): ${dataStr}`);
+                  }
                 }
+              }
             }
+          }
+          break;
         }
-        finally {
-            reader.releaseLock();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const dataStr = line.slice(6);
+            if (!dataStr.trim()) {
+              continue;
+            }
+            try {
+              const chunk = JSON.parse(dataStr);
+              yield chunk;
+              if (chunk.type === "done" || chunk.type === "error") {
+                return;
+              }
+            } catch (error) {
+              logWarning(`Failed to parse SSE data: ${dataStr}`);
+            }
+          }
         }
+      }
+    } finally {
+      reader.releaseLock();
     }
+  }
 }
-// Export singleton instance
-export const aiServiceClient = new AIServiceClient();
+const aiServiceClient = new AIServiceClient();
+export {
+  AIServiceClient,
+  aiServiceClient
+};
 //# sourceMappingURL=ai-service-client.js.map