autohand-cli 0.7.13 → 0.8.0

package/dist/chunk-2JYIR3EC.cjs

@@ -0,0 +1,1176 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/providers/OllamaProvider.ts
+var OllamaProvider = class {
+  constructor(config) {
+    this.disableTools = false;
+    this.baseUrl = config.baseUrl || "http://localhost:11434";
+    this.model = config.model || "llama3.2:latest";
+  }
+  getName() {
+    return "ollama";
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  async listModels() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`);
+      if (!response.ok) {
+        return [];
+      }
+      const data = await response.json();
+      return data.models.map((m) => m.name);
+    } catch (e) {
+      return [];
+    }
+  }
+  async isAvailable() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`);
+      return response.ok;
+    } catch (e2) {
+      return false;
+    }
+  }
+  async complete(request) {
+    const messages = request.messages.map((msg) => {
+      const mapped = {
+        role: msg.role,
+        content: _nullishCoalesce(msg.content, () => ( ""))
+      };
+      if (msg.name) {
+        mapped.name = msg.name;
+      }
+      if (msg.role === "tool" && msg.tool_call_id) {
+        mapped.tool_call_id = msg.tool_call_id;
+      }
+      if (msg.role === "assistant" && msg.tool_calls) {
+        mapped.tool_calls = msg.tool_calls;
+      }
+      return mapped;
+    });
+    const body = {
+      model: request.model || this.model,
+      messages,
+      stream: request.stream || false
+    };
+    if (request.temperature !== void 0) {
+      body.options = { temperature: request.temperature };
+    }
+    if (!this.disableTools && request.tools && request.tools.length > 0) {
+      body.tools = request.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: _nullishCoalesce(tool.parameters, () => ( { type: "object", properties: {} }))
+        }
+      }));
+    }
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: request.signal
+    });
+    if (!response.ok) {
+      let errorDetail = "";
+      try {
+        const errorBody = await response.text();
+        errorDetail = errorBody ? `: ${errorBody}` : "";
+        if (errorBody.includes("does not support tools") && body.tools) {
+          console.warn(`Model ${body.model} does not support tools. Retrying without tool support.`);
+          this.disableTools = true;
+          delete body.tools;
+          return this.complete(request);
+        }
+      } catch (e3) {
+      }
+      throw new Error(`Ollama API error: ${response.status} ${response.statusText}${errorDetail}`);
+    }
+    if (request.stream) {
+      return this.handleStreamingResponse(response);
+    }
+    const data = await response.json();
+    let toolCalls;
+    if (data.message.tool_calls && Array.isArray(data.message.tool_calls)) {
+      toolCalls = data.message.tool_calls.map((tc, index) => ({
+        id: `ollama-tool-${Date.now()}-${index}`,
+        type: "function",
+        function: {
+          name: tc.function.name,
+          // Ollama returns arguments as object, convert to JSON string for consistency
+          arguments: JSON.stringify(tc.function.arguments)
+        }
+      }));
+    }
+    let usage;
+    if (data.prompt_eval_count !== void 0 || data.eval_count !== void 0) {
+      usage = {
+        promptTokens: _nullishCoalesce(data.prompt_eval_count, () => ( 0)),
+        completionTokens: _nullishCoalesce(data.eval_count, () => ( 0)),
+        totalTokens: (_nullishCoalesce(data.prompt_eval_count, () => ( 0))) + (_nullishCoalesce(data.eval_count, () => ( 0)))
+      };
+    }
+    return {
+      id: `ollama-${Date.now()}`,
+      created: Math.floor(new Date(data.created_at).getTime() / 1e3),
+      content: data.message.content,
+      toolCalls,
+      finishReason: _optionalChain([toolCalls, 'optionalAccess', _ => _.length]) ? "tool_calls" : "stop",
+      usage,
+      raw: data
+    };
+  }
+  async handleStreamingResponse(response) {
+    const reader = _optionalChain([response, 'access', _2 => _2.body, 'optionalAccess', _3 => _3.getReader, 'call', _4 => _4()]);
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let fullContent = "";
+    let lastData = null;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        const lines = chunk.split("\n").filter((line) => line.trim());
+        for (const line of lines) {
+          try {
+            const data = JSON.parse(line);
+            fullContent += data.message.content;
+            lastData = data;
+          } catch (e4) {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return {
+      id: `ollama-${Date.now()}`,
+      created: lastData ? Math.floor(new Date(lastData.created_at).getTime() / 1e3) : Date.now(),
+      content: fullContent,
+      raw: lastData
+    };
+  }
+};
+
+// src/providers/OpenAIProvider.ts
+var OpenAIProvider = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
+    this.apiKey = config.apiKey || "";
+    this.model = config.model || "gpt-4o";
+  }
+  getName() {
+    return "openai";
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  async listModels() {
+    return [
+      "gpt-4o",
+      "gpt-4o-mini",
+      "gpt-4-turbo",
+      "gpt-4",
+      "gpt-3.5-turbo"
+    ];
+  }
+  async isAvailable() {
+    try {
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`
+        }
+      });
+      return response.ok;
+    } catch (e5) {
+      return false;
+    }
+  }
+  async complete(request) {
+    const body = {
+      model: request.model || this.model,
+      messages: request.messages.map((msg) => {
+        const mapped = {
+          role: msg.role === "system" ? "system" : msg.role === "user" ? "user" : msg.role === "tool" ? "tool" : "assistant",
+          content: msg.content
+        };
+        if (msg.role === "tool" && msg.tool_call_id) {
+          mapped.tool_call_id = msg.tool_call_id;
+        }
+        if (msg.name) {
+          mapped.name = msg.name;
+        }
+        return mapped;
+      }),
+      temperature: request.temperature || 0.7,
+      max_tokens: request.maxTokens
+    };
+    if (request.tools && request.tools.length > 0) {
+      body.tools = request.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: _nullishCoalesce(tool.parameters, () => ( { type: "object", properties: {} }))
+        }
+      }));
+      if (request.toolChoice) {
+        body.tool_choice = request.toolChoice;
+      }
+    }
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal: request.signal
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} ${error}`);
+    }
+    const data = await response.json();
+    const message = data.choices[0].message;
+    const finishReason = data.choices[0].finish_reason;
+    let toolCalls;
+    if (message.tool_calls && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.function.name,
+          arguments: tc.function.arguments
+        }
+      }));
+    }
+    let usage;
+    if (data.usage) {
+      usage = {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens
+      };
+    }
+    return {
+      id: data.id,
+      created: data.created,
+      content: _nullishCoalesce(message.content, () => ( "")),
+      toolCalls,
+      finishReason,
+      usage,
+      raw: data
+    };
+  }
+};
+
+// src/providers/LlamaCppProvider.ts
+var LlamaCppProvider = class {
+  constructor(config) {
+    const port = config.port || 8080;
+    this.baseUrl = config.baseUrl || `http://localhost:${port}`;
+    this.model = config.model || "llama-model";
+  }
+  getName() {
+    return "llamacpp";
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  async listModels() {
+    try {
+      const response = await fetch(`${this.baseUrl}/v1/models`);
+      if (!response.ok) {
+        return this.model ? [this.model] : [];
+      }
+      const data = await response.json();
+      return _nullishCoalesce(_optionalChain([data, 'access', _5 => _5.data, 'optionalAccess', _6 => _6.map, 'call', _7 => _7((m) => m.id)]), () => ( [this.model]));
+    } catch (e6) {
+      return this.model ? [this.model] : [];
+    }
+  }
+  async isAvailable() {
+    try {
+      const response = await fetch(`${this.baseUrl}/health`);
+      return response.ok;
+    } catch (e7) {
+      return false;
+    }
+  }
+  async complete(request) {
+    const body = {
+      model: request.model || this.model,
+      messages: request.messages.map((msg) => {
+        const mapped = {
+          role: msg.role,
+          content: msg.content
+        };
+        if (msg.name) mapped.name = msg.name;
+        if (msg.role === "tool" && msg.tool_call_id) mapped.tool_call_id = msg.tool_call_id;
+        if (msg.role === "assistant" && msg.tool_calls) mapped.tool_calls = msg.tool_calls;
+        return mapped;
+      }),
+      temperature: _nullishCoalesce(request.temperature, () => ( 0.7)),
+      max_tokens: _nullishCoalesce(request.maxTokens, () => ( 4096)),
+      stream: false
+    };
+    if (request.tools && request.tools.length > 0) {
+      body.tools = request.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: _nullishCoalesce(tool.parameters, () => ( { type: "object", properties: {} }))
+        }
+      }));
+    }
+    const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: request.signal
+    });
+    if (!response.ok) {
+      throw new Error(`llama.cpp API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const choice = data.choices[0];
+    let toolCalls;
+    if (_optionalChain([choice, 'optionalAccess', _8 => _8.message, 'access', _9 => _9.tool_calls, 'optionalAccess', _10 => _10.length])) {
+      toolCalls = choice.message.tool_calls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.function.name,
+          arguments: tc.function.arguments
+        }
+      }));
+    }
+    let usage;
+    if (data.usage) {
+      usage = {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens
+      };
+    }
+    const finishReason = _optionalChain([toolCalls, 'optionalAccess', _11 => _11.length]) ? "tool_calls" : _optionalChain([choice, 'optionalAccess', _12 => _12.finish_reason]) === "stop" || _optionalChain([choice, 'optionalAccess', _13 => _13.finish_reason]) === "length" || _optionalChain([choice, 'optionalAccess', _14 => _14.finish_reason]) === "content_filter" ? choice.finish_reason : "stop";
+    return {
+      id: data.id || `llamacpp-${Date.now()}`,
+      created: data.created || Math.floor(Date.now() / 1e3),
+      content: _nullishCoalesce(_optionalChain([choice, 'optionalAccess', _15 => _15.message, 'access', _16 => _16.content]), () => ( "")),
+      toolCalls,
+      finishReason,
+      usage,
+      raw: data
+    };
+  }
+};
+
+// src/providers/OpenRouterClient.ts
+function sanitizeMessages(messages) {
+  return messages.map((msg) => {
+    const sanitized = {
+      role: msg.role,
+      content: msg.content
+    };
+    if (msg.role === "tool" && msg.tool_call_id) {
+      sanitized.tool_call_id = msg.tool_call_id;
+    }
+    if (msg.role === "assistant" && _optionalChain([msg, 'access', _17 => _17.tool_calls, 'optionalAccess', _18 => _18.length])) {
+      sanitized.tool_calls = msg.tool_calls;
+    }
+    if (msg.name) {
+      sanitized.name = msg.name;
+    }
+    return sanitized;
+  });
+}
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_MAX_RETRIES = 3;
+var MAX_ALLOWED_RETRIES = 5;
+var DEFAULT_RETRY_DELAY = 1e3;
+var DEFAULT_TIMEOUT = 3e4;
+var FRIENDLY_ERRORS = {
+  400: "The request was malformed. This often happens when the context is too long. Try /undo to remove recent turns or /new to start fresh.",
+  401: "Authentication failed. Please verify your API key in ~/.autohand/config.json.",
+  402: "Payment required. Please check your account balance or billing settings.",
+  403: "Access denied. Your API key may not have permission for this model.",
+  404: "The requested model was not found. Use /model to select a different one.",
+  429: "Rate limit exceeded. Please wait a moment and try again, or choose a different model.",
+  500: "The AI service encountered an internal error. Please try again later.",
+  502: "The AI service is temporarily unavailable. Please try again in a few moments.",
+  503: "The AI service is currently overloaded. Please try again later.",
+  504: "The request timed out. The AI service may be experiencing high load."
+};
+var OpenRouterClient = class {
+  constructor(settings, networkSettings) {
+    this.apiKey = _nullishCoalesce(settings.apiKey, () => ( ""));
+    this.baseUrl = _nullishCoalesce(settings.baseUrl, () => ( DEFAULT_BASE_URL));
+    this.defaultModel = settings.model;
+    const configuredRetries = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _19 => _19.maxRetries]), () => ( DEFAULT_MAX_RETRIES));
+    this.maxRetries = Math.min(
+      Math.max(0, configuredRetries),
+      MAX_ALLOWED_RETRIES
+    );
+    this.retryDelay = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _20 => _20.retryDelay]), () => ( DEFAULT_RETRY_DELAY));
+    this.timeout = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _21 => _21.timeout]), () => ( DEFAULT_TIMEOUT));
+  }
+  setDefaultModel(model) {
+    this.defaultModel = model;
+  }
+  async complete(request) {
+    const payload = {
+      model: _nullishCoalesce(request.model, () => ( this.defaultModel)),
+      messages: sanitizeMessages(request.messages),
+      temperature: _nullishCoalesce(request.temperature, () => ( 0.2)),
+      max_tokens: _nullishCoalesce(request.maxTokens, () => ( 16e3)),
+      // Increased from 1000 to allow large file generation
+      stream: _nullishCoalesce(request.stream, () => ( false))
+    };
+    if (request.tools && request.tools.length > 0) {
+      payload.tools = request.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: _nullishCoalesce(tool.parameters, () => ( { type: "object", properties: {} }))
+        }
+      }));
+      if (request.toolChoice) {
+        payload.tool_choice = request.toolChoice;
+      }
+    }
+    const model = (_nullishCoalesce(request.model, () => ( this.defaultModel))).toLowerCase();
+    if (request.thinkingLevel && request.thinkingLevel !== "normal") {
+      if (model.includes("o1") || model.includes("o3")) {
+        if (request.thinkingLevel === "extended") {
+          payload.reasoning_effort = "high";
+        } else if (request.thinkingLevel === "none") {
+          payload.reasoning_effort = "low";
+        }
+      }
+      if (model.includes("claude") && request.thinkingLevel === "extended") {
+        payload.provider = {
+          anthropic: {
+            thinking: {
+              type: "enabled",
+              budget_tokens: 1e4
+            }
+          }
+        };
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "HTTP-Referer": "https://github.com/autohandai/code-cli",
+      "X-Title": "autohand-code-cli"
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    const payloadJson = JSON.stringify(payload);
+    const payloadSizeBytes = payloadJson.length;
+    const maxPayloadSize = 5 * 1024 * 1024;
+    if (payloadSizeBytes > maxPayloadSize) {
+      const sizeMB = (payloadSizeBytes / (1024 * 1024)).toFixed(2);
+      throw new Error(
+        `Request payload too large (${sizeMB}MB). This usually happens when the conversation history grows too long. Try using /undo to remove recent turns or /new to start fresh.`
+      );
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await this.makeRequest(
+          payload,
+          headers,
+          request.signal,
+          payloadJson
+        );
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (this.isNonRetryableError(error)) {
+          throw error;
+        }
+        if (attempt < this.maxRetries) {
+          const delay = this.retryDelay * Math.pow(2, attempt);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw _nullishCoalesce(lastError, () => ( new Error("Failed to communicate with the AI service. Please try again.")));
+  }
+  async makeRequest(payload, headers, signal, preSerializedBody) {
+    let response;
+    try {
+      const timeoutController = new AbortController();
+      const timeoutId = setTimeout(
+        () => timeoutController.abort(),
+        this.timeout
+      );
+      const combinedSignal = signal ? this.combineSignals(signal, timeoutController.signal) : timeoutController.signal;
+      try {
+        response = await fetch(`${this.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers,
+          body: _nullishCoalesce(preSerializedBody, () => ( JSON.stringify(payload))),
+          signal: combinedSignal
+        });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && _optionalChain([signal, 'optionalAccess', _22 => _22.aborted])) {
+        throw new Error("Request cancelled.");
+      }
+      if (err.name === "AbortError") {
+        throw new Error(
+          "Request timed out. The AI service may be experiencing high load."
+        );
+      }
+      throw new Error(
+        "Unable to connect to the AI service. Please check your internet connection."
+      );
+    }
+    if (!response.ok) {
+      throw new Error(await this.buildFriendlyError(response));
+    }
+    const json = await response.json();
+    const message = _optionalChain([json, 'optionalAccess', _23 => _23.choices, 'optionalAccess', _24 => _24[0], 'optionalAccess', _25 => _25.message]);
+    const text = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _26 => _26.content]), () => ( ""));
+    const finishReason = _optionalChain([json, 'optionalAccess', _27 => _27.choices, 'optionalAccess', _28 => _28[0], 'optionalAccess', _29 => _29.finish_reason]);
+    let toolCalls;
+    if (_optionalChain([message, 'optionalAccess', _30 => _30.tool_calls]) && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => {
+        const rawArgs = _optionalChain([tc, 'access', _31 => _31.function, 'optionalAccess', _32 => _32.arguments]);
+        return {
+          id: tc.id,
+          type: "function",
+          function: {
+            name: _nullishCoalesce(_optionalChain([tc, 'access', _33 => _33.function, 'optionalAccess', _34 => _34.name]), () => ( "")),
+            arguments: _nullishCoalesce(rawArgs, () => ( "{}"))
+          }
+        };
+      });
+    }
+    let usage;
+    if (_optionalChain([json, 'optionalAccess', _35 => _35.usage])) {
+      usage = {
+        promptTokens: _nullishCoalesce(json.usage.prompt_tokens, () => ( 0)),
+        completionTokens: _nullishCoalesce(json.usage.completion_tokens, () => ( 0)),
+        totalTokens: _nullishCoalesce(json.usage.total_tokens, () => ( 0))
+      };
+    }
+    return {
+      id: _nullishCoalesce(json.id, () => ( "autohand-local")),
+      created: _nullishCoalesce(json.created, () => ( Date.now())),
+      content: text,
+      toolCalls,
+      finishReason,
+      usage,
+      raw: json
+    };
+  }
+  async buildFriendlyError(response) {
+    const status = response.status;
+    let errorDetail = "";
+    try {
+      const body = await response.json();
+      errorDetail = _optionalChain([body, 'optionalAccess', _36 => _36.error, 'optionalAccess', _37 => _37.message]) || _optionalChain([body, 'optionalAccess', _38 => _38.error]) || _optionalChain([body, 'optionalAccess', _39 => _39.message]) || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch (e8) {
+      try {
+        errorDetail = await response.text();
+      } catch (e9) {
+      }
+    }
+    const friendlyMessage = FRIENDLY_ERRORS[status];
+    if (friendlyMessage) {
+      return errorDetail ? `${friendlyMessage}
+${errorDetail}` : friendlyMessage;
+    }
+    if (status >= 500) {
+      const base = "The AI service is temporarily unavailable. Please try again later.";
+      return errorDetail ? `${base}
+(${status}: ${errorDetail})` : base;
+    }
+    if (status >= 400) {
+      const base = "The request could not be processed.";
+      return errorDetail ? `${base} (${status}: ${errorDetail})` : `${base} (HTTP ${status}) Please try again or adjust your prompt.`;
+    }
+    return errorDetail ? `An unexpected error occurred: ${errorDetail}` : "An unexpected error occurred. Please try again.";
+  }
+  isNonRetryableError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("cancelled") || message.includes("aborted")) {
+      return true;
+    }
+    if (message.includes("authentication") || message.includes("api key")) {
+      return true;
+    }
+    if (message.includes("payment") || message.includes("access denied")) {
+      return true;
+    }
+    if (message.includes("not found")) {
+      return true;
+    }
+    return false;
+  }
+  combineSignals(signal1, signal2) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal1.addEventListener("abort", abort);
+    signal2.addEventListener("abort", abort);
+    if (signal1.aborted || signal2.aborted) {
+      controller.abort();
+    }
+    return controller.signal;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/providers/OpenRouterProvider.ts
+var OpenRouterProvider = class {
+  constructor(config, networkSettings) {
+    this.client = new OpenRouterClient(config, networkSettings);
+    this.model = config.model;
+  }
+  getName() {
+    return "openrouter";
+  }
+  setModel(model) {
+    this.model = model;
+    this.client.setDefaultModel(model);
+  }
+  async listModels() {
+    return [
+      "anthropic/claude-3.5-sonnet",
+      "anthropic/claude-3-opus",
+      "google/gemini-pro-1.5",
+      "openai/gpt-4o",
+      "x-ai/grok-2-latest",
+      "meta-llama/llama-3.1-70b-instruct"
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+  async complete(request) {
+    return this.client.complete(request);
+  }
+};
+
+// src/utils/platform.ts
+function isAppleSilicon() {
+  return process.platform === "darwin" && process.arch === "arm64";
+}
+function isMLXSupported() {
+  return isAppleSilicon();
+}
+
+// src/providers/MLXProvider.ts
+var MLXProvider = class {
+  constructor(config) {
+    const port = config.port || 8080;
+    this.baseUrl = config.baseUrl || `http://localhost:${port}`;
+    this.model = config.model || "mlx-model";
+  }
+  getName() {
+    return "mlx";
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  async listModels() {
+    if (!isMLXSupported()) {
+      return [];
+    }
+    try {
+      const response = await fetch(`${this.baseUrl}/v1/models`);
+      if (!response.ok) {
+        return this.model ? [this.model] : [];
+      }
+      const data = await response.json();
+      return _nullishCoalesce(_optionalChain([data, 'access', _40 => _40.data, 'optionalAccess', _41 => _41.map, 'call', _42 => _42((m) => m.id)]), () => ( (this.model ? [this.model] : [])));
+    } catch (e10) {
+      return this.model ? [this.model] : [];
+    }
+  }
+  async isAvailable() {
+    if (!isMLXSupported()) {
+      return false;
+    }
+    try {
+      const response = await fetch(`${this.baseUrl}/v1/models`);
+      return response.ok;
+    } catch (e11) {
+      return false;
+    }
+  }
+  async complete(request) {
+    if (!isMLXSupported()) {
+      throw new Error("MLX is only supported on macOS with Apple Silicon");
+    }
+    const body = {
+      model: request.model || this.model,
+      messages: request.messages.map((msg) => {
+        const mapped = {
+          role: msg.role,
+          content: msg.content
+        };
+        if (msg.name) mapped.name = msg.name;
+        if (msg.role === "tool" && msg.tool_call_id) mapped.tool_call_id = msg.tool_call_id;
+        if (msg.role === "assistant" && msg.tool_calls) mapped.tool_calls = msg.tool_calls;
+        return mapped;
+      }),
+      temperature: _nullishCoalesce(request.temperature, () => ( 0.7)),
+      max_tokens: _nullishCoalesce(request.maxTokens, () => ( 4096)),
+      stream: false
+    };
+    if (request.tools && request.tools.length > 0) {
+      body.tools = request.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: _nullishCoalesce(tool.parameters, () => ( { type: "object", properties: {} }))
+        }
+      }));
+    }
+    const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: request.signal
+    });
+    if (!response.ok) {
+      throw new Error(`MLX API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const choice = data.choices[0];
+    let toolCalls;
+    if (_optionalChain([choice, 'optionalAccess', _43 => _43.message, 'access', _44 => _44.tool_calls, 'optionalAccess', _45 => _45.length])) {
+      toolCalls = choice.message.tool_calls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.function.name,
+          arguments: tc.function.arguments
+        }
+      }));
+    }
+    let usage;
+    if (data.usage) {
+      usage = {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens
+      };
+    }
+    const finishReason = _optionalChain([toolCalls, 'optionalAccess', _46 => _46.length]) ? "tool_calls" : _optionalChain([choice, 'optionalAccess', _47 => _47.finish_reason]) === "stop" || _optionalChain([choice, 'optionalAccess', _48 => _48.finish_reason]) === "length" || _optionalChain([choice, 'optionalAccess', _49 => _49.finish_reason]) === "content_filter" ? choice.finish_reason : "stop";
+    return {
+      id: data.id || `mlx-${Date.now()}`,
+      created: data.created || Math.floor(Date.now() / 1e3),
+      content: _nullishCoalesce(_optionalChain([choice, 'optionalAccess', _50 => _50.message, 'access', _51 => _51.content]), () => ( "")),
+      toolCalls,
+      finishReason,
+      usage,
+      raw: data
+    };
+  }
+};
+
+// src/providers/LLMGatewayClient.ts
+function sanitizeMessages2(messages) {
+  return messages.map((msg) => {
+    const sanitized = {
+      role: msg.role,
+      content: msg.content
+    };
+    if (msg.role === "tool" && msg.tool_call_id) {
+      sanitized.tool_call_id = msg.tool_call_id;
+    }
+    if (msg.role === "assistant" && _optionalChain([msg, 'access', _52 => _52.tool_calls, 'optionalAccess', _53 => _53.length])) {
+      sanitized.tool_calls = msg.tool_calls;
+    }
+    if (msg.name) {
+      sanitized.name = msg.name;
+    }
+    return sanitized;
+  });
+}
+var DEFAULT_BASE_URL2 = "https://api.llmgateway.io/v1";
+var DEFAULT_MAX_RETRIES2 = 3;
+var MAX_ALLOWED_RETRIES2 = 5;
+var DEFAULT_RETRY_DELAY2 = 1e3;
+var DEFAULT_TIMEOUT2 = 3e4;
+var FRIENDLY_ERRORS2 = {
+  400: "The request was malformed. This often happens when the context is too long. Try /undo to remove recent turns or /new to start fresh.",
+  401: "Authentication failed. Please verify your LLM Gateway API key in ~/.autohand/config.json.",
+  402: "Payment required. Please check your LLM Gateway account balance or billing settings.",
+  403: "Access denied. Your API key may not have permission for this model.",
+  404: "The requested model was not found. Use /model to select a different one.",
+  429: "Rate limit exceeded. Please wait a moment and try again, or choose a different model.",
+  500: "The LLM Gateway service encountered an internal error. Please try again later.",
+  502: "The LLM Gateway service is temporarily unavailable. Please try again in a few moments.",
+  503: "The LLM Gateway service is currently overloaded. Please try again later.",
+  504: "The request timed out. The service may be experiencing high load."
+};
+var LLMGatewayClient = class {
+  constructor(settings, networkSettings) {
+    this.apiKey = _nullishCoalesce(settings.apiKey, () => ( ""));
+    this.baseUrl = _nullishCoalesce(settings.baseUrl, () => ( DEFAULT_BASE_URL2));
+    this.defaultModel = settings.model;
+    const configuredRetries = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _54 => _54.maxRetries]), () => ( DEFAULT_MAX_RETRIES2));
+    this.maxRetries = Math.min(
+      Math.max(0, configuredRetries),
+      MAX_ALLOWED_RETRIES2
+    );
+    this.retryDelay = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _55 => _55.retryDelay]), () => ( DEFAULT_RETRY_DELAY2));
+    this.timeout = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _56 => _56.timeout]), () => ( DEFAULT_TIMEOUT2));
+  }
+  setDefaultModel(model) {
+    this.defaultModel = model;
+  }
+  async complete(request) {
+    const payload = {
+      model: _nullishCoalesce(request.model, () => ( this.defaultModel)),
+      messages: sanitizeMessages2(request.messages),
+      temperature: _nullishCoalesce(request.temperature, () => ( 0.2)),
+      max_tokens: _nullishCoalesce(request.maxTokens, () => ( 16e3)),
+      stream: _nullishCoalesce(request.stream, () => ( false))
+    };
+    if (request.tools && request.tools.length > 0) {
+      payload.tools = request.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: _nullishCoalesce(tool.parameters, () => ( { type: "object", properties: {} }))
+        }
+      }));
+      if (request.toolChoice) {
+        payload.tool_choice = request.toolChoice;
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    const payloadJson = JSON.stringify(payload);
+    const payloadSizeBytes = payloadJson.length;
+    const maxPayloadSize = 5 * 1024 * 1024;
+    if (payloadSizeBytes > maxPayloadSize) {
+      const sizeMB = (payloadSizeBytes / (1024 * 1024)).toFixed(2);
+      throw new Error(
+        `Request payload too large (${sizeMB}MB). This usually happens when the conversation history grows too long. Try using /undo to remove recent turns or /new to start fresh.`
+      );
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await this.makeRequest(
+          payload,
+          headers,
+          request.signal,
+          payloadJson
+        );
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (this.isNonRetryableError(error)) {
+          throw error;
+        }
+        if (attempt < this.maxRetries) {
+          const delay = this.retryDelay * Math.pow(2, attempt);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw _nullishCoalesce(lastError, () => ( new Error("Failed to communicate with LLM Gateway. Please try again.")));
+  }
+  async makeRequest(payload, headers, signal, preSerializedBody) {
+    let response;
+    try {
+      const timeoutController = new AbortController();
+      const timeoutId = setTimeout(
+        () => timeoutController.abort(),
+        this.timeout
+      );
+      const combinedSignal = signal ? this.combineSignals(signal, timeoutController.signal) : timeoutController.signal;
+      try {
+        response = await fetch(`${this.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers,
+          body: _nullishCoalesce(preSerializedBody, () => ( JSON.stringify(payload))),
+          signal: combinedSignal
+        });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && _optionalChain([signal, 'optionalAccess', _57 => _57.aborted])) {
+        throw new Error("Request cancelled.");
+      }
+      if (err.name === "AbortError") {
+        throw new Error(
+          "Request timed out. The LLM Gateway service may be experiencing high load."
+        );
+      }
+      throw new Error(
+        "Unable to connect to LLM Gateway. Please check your internet connection."
+      );
+    }
+    if (!response.ok) {
+      throw new Error(await this.buildFriendlyError(response));
+    }
+    const json = await response.json();
+    const message = _optionalChain([json, 'optionalAccess', _58 => _58.choices, 'optionalAccess', _59 => _59[0], 'optionalAccess', _60 => _60.message]);
+    const text = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _61 => _61.content]), () => ( ""));
+    const finishReason = _optionalChain([json, 'optionalAccess', _62 => _62.choices, 'optionalAccess', _63 => _63[0], 'optionalAccess', _64 => _64.finish_reason]);
+    let toolCalls;
+    if (_optionalChain([message, 'optionalAccess', _65 => _65.tool_calls]) && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => {
+        const rawArgs = _optionalChain([tc, 'access', _66 => _66.function, 'optionalAccess', _67 => _67.arguments]);
+        return {
+          id: tc.id,
+          type: "function",
+          function: {
+            name: _nullishCoalesce(_optionalChain([tc, 'access', _68 => _68.function, 'optionalAccess', _69 => _69.name]), () => ( "")),
+            arguments: _nullishCoalesce(rawArgs, () => ( "{}"))
+          }
+        };
+      });
+    }
+    let usage;
+    if (_optionalChain([json, 'optionalAccess', _70 => _70.usage])) {
+      usage = {
+        promptTokens: _nullishCoalesce(json.usage.prompt_tokens, () => ( 0)),
+        completionTokens: _nullishCoalesce(json.usage.completion_tokens, () => ( 0)),
+        totalTokens: _nullishCoalesce(json.usage.total_tokens, () => ( 0))
+      };
+    }
+    return {
+      id: _nullishCoalesce(json.id, () => ( "llmgateway-response")),
+      created: _nullishCoalesce(json.created, () => ( Date.now())),
+      content: text,
+      toolCalls,
+      finishReason,
+      usage,
+      raw: json
+    };
+  }
+  async buildFriendlyError(response) {
+    const status = response.status;
+    let errorDetail = "";
+    try {
+      const body = await response.json();
+      errorDetail = _optionalChain([body, 'optionalAccess', _71 => _71.error, 'optionalAccess', _72 => _72.message]) || _optionalChain([body, 'optionalAccess', _73 => _73.error]) || _optionalChain([body, 'optionalAccess', _74 => _74.message]) || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch (e12) {
+      try {
+        errorDetail = await response.text();
+      } catch (e13) {
+      }
+    }
+    const friendlyMessage = FRIENDLY_ERRORS2[status];
+    if (friendlyMessage) {
+      return errorDetail ? `${friendlyMessage}
+${errorDetail}` : friendlyMessage;
+    }
+    if (status >= 500) {
+      const base = "The LLM Gateway service is temporarily unavailable. Please try again later.";
+      return errorDetail ? `${base}
+(${status}: ${errorDetail})` : base;
+    }
+    if (status >= 400) {
+      const base = "The request could not be processed.";
+      return errorDetail ? `${base} (${status}: ${errorDetail})` : `${base} (HTTP ${status}) Please try again or adjust your prompt.`;
+    }
+    return errorDetail ? `An unexpected error occurred: ${errorDetail}` : "An unexpected error occurred. Please try again.";
+  }
+  isNonRetryableError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("cancelled") || message.includes("aborted")) {
+      return true;
+    }
+    if (message.includes("authentication") || message.includes("api key")) {
+      return true;
+    }
+    if (message.includes("payment") || message.includes("access denied")) {
+      return true;
+    }
+    if (message.includes("not found")) {
+      return true;
+    }
+    return false;
+  }
+  combineSignals(signal1, signal2) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal1.addEventListener("abort", abort);
+    signal2.addEventListener("abort", abort);
+    if (signal1.aborted || signal2.aborted) {
+      controller.abort();
+    }
+    return controller.signal;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/providers/LLMGatewayProvider.ts
+var LLMGatewayProvider = class {
+  constructor(config, networkSettings) {
+    this.client = new LLMGatewayClient(config, networkSettings);
+    this.model = config.model;
+  }
+  getName() {
+    return "llmgateway";
+  }
+  setModel(model) {
+    this.model = model;
+    this.client.setDefaultModel(model);
+  }
+  async listModels() {
+    return [
+      "gpt-4o",
+      "gpt-4o-mini",
+      "gpt-4-turbo",
+      "claude-3-5-sonnet-20241022",
+      "claude-3-5-haiku-20241022",
+      "gemini-1.5-pro",
+      "gemini-1.5-flash"
+    ];
+  }
+  async isAvailable() {
+    return true;
+  }
+  async complete(request) {
+    return this.client.complete(request);
+  }
+};
+
+// src/providers/ProviderFactory.ts
+var ProviderNotConfiguredError = class extends Error {
+  constructor(providerName) {
+    super(`PROVIDER_NOT_CONFIGURED:${providerName}`);
+    this.providerName = providerName;
+    this.name = "ProviderNotConfiguredError";
+  }
+};
+var UnconfiguredProvider = class {
+  constructor(providerName) {
+    this.providerName = providerName;
+  }
+  getName() {
+    return "unconfigured";
+  }
+  async complete(_request) {
+    throw new ProviderNotConfiguredError(this.providerName);
+  }
+  async listModels() {
+    return [];
+  }
+  async isAvailable() {
+    return false;
+  }
+  setModel(_model) {
+  }
+};
+var ProviderFactory = class {
+  /**
+   * Create an LLM provider based on configuration.
+   * Returns an UnconfiguredProvider if the selected provider is not configured,
+   * allowing the agent to handle it gracefully instead of crashing.
+   */
+  static create(config) {
+    const providerName = config.provider || "openrouter";
+    switch (providerName) {
+      case "ollama":
+        if (!config.ollama) {
+          return new UnconfiguredProvider("ollama");
+        }
+        return new OllamaProvider(config.ollama);
+      case "openai":
+        if (!config.openai) {
+          return new UnconfiguredProvider("openai");
+        }
+        return new OpenAIProvider(config.openai);
+      case "llamacpp":
+        if (!config.llamacpp) {
+          return new UnconfiguredProvider("llamacpp");
+        }
+        return new LlamaCppProvider(config.llamacpp);
+      case "mlx":
+        if (!config.mlx) {
+          return new UnconfiguredProvider("mlx");
+        }
+        return new MLXProvider(config.mlx);
+      case "llmgateway":
+        if (!config.llmgateway) {
+          return new UnconfiguredProvider("llmgateway");
+        }
+        return new LLMGatewayProvider(config.llmgateway, config.network);
+      case "openrouter":
+      default:
+        if (!config.openrouter) {
+          return new UnconfiguredProvider("openrouter");
+        }
+        return new OpenRouterProvider(config.openrouter);
+    }
+  }
+  /**
+   * Get all available provider names.
+   * MLX is only included on Apple Silicon (macOS + arm64).
+   */
+  static getProviderNames() {
+    const providers = ["openrouter", "ollama", "openai", "llamacpp", "llmgateway"];
+    if (isMLXSupported()) {
+      providers.push("mlx");
+    }
+    return providers;
+  }
+  /**
+   * Check if a provider name is valid.
+   * Note: This checks if the name is a valid provider type, not if it's available on this platform.
+   * MLX is always a valid provider name, but may not be available on non-Apple Silicon systems.
+   */
+  static isValidProvider(name) {
+    const allProviders = ["openrouter", "ollama", "openai", "llamacpp", "mlx", "llmgateway"];
+    return allProviders.includes(name);
+  }
+};
+
+
+
+
+exports.ProviderNotConfiguredError = ProviderNotConfiguredError; exports.ProviderFactory = ProviderFactory;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */