autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-WRTXCQ3V.cjs

@@ -0,0 +1,4291 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } 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; } var _class; var _class2; var _class3;
+
+var _chunkUWFG2R2Icjs = require('./chunk-UWFG2R2I.cjs');
+
+
+
+var _chunk3OF56EMAcjs = require('./chunk-3OF56EMA.cjs');
+
+// src/providers/OllamaProvider.ts
+var DEFAULT_TIMEOUT = 12e4;
+var DEFAULT_CHUNK_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var MAX_ALLOWED_RETRIES = 5;
+var DEFAULT_RETRY_DELAY = 1e3;
+var AVAILABILITY_TIMEOUT = 5e3;
+var OllamaProvider = (_class = class {
+  
+  
+  __init() {this.disableTools = false}
+  
+  
+  
+  
+  constructor(config, networkSettings) {;_class.prototype.__init.call(this);
+    this.baseUrl = config.baseUrl || "http://localhost:11434";
+    this.model = config.model || "llama3.2:latest";
+    const configuredRetries = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _ => _.maxRetries]), () => ( DEFAULT_MAX_RETRIES));
+    this.maxRetries = Math.min(Math.max(0, configuredRetries), MAX_ALLOWED_RETRIES);
+    this.retryDelay = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _2 => _2.retryDelay]), () => ( DEFAULT_RETRY_DELAY));
+    this.timeout = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _3 => _3.timeout]), () => ( DEFAULT_TIMEOUT));
+    this.chunkTimeout = DEFAULT_CHUNK_TIMEOUT;
+  }
+  getName() {
+    return "ollama";
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  async listModels() {
+    try {
+      const controller = new AbortController();
+      const timerId = setTimeout(() => controller.abort(), AVAILABILITY_TIMEOUT);
+      try {
+        const response = await fetch(`${this.baseUrl}/api/tags`, {
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          return [];
+        }
+        const data = await response.json();
+        return data.models.map((m) => m.name);
+      } finally {
+        clearTimeout(timerId);
+      }
+    } catch (e) {
+      return [];
+    }
+  }
+  async isAvailable() {
+    try {
+      const controller = new AbortController();
+      const timerId = setTimeout(() => controller.abort(), AVAILABILITY_TIMEOUT);
+      try {
+        const response = await fetch(`${this.baseUrl}/api/tags`, {
+          signal: controller.signal
+        });
+        return response.ok;
+      } finally {
+        clearTimeout(timerId);
+      }
+    } catch (e2) {
+      return false;
+    }
+  }
+  async complete(request) {
+    const body = {
+      model: request.model || this.model,
+      messages: this.buildMessages(request.messages, !this.disableTools),
+      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: {} }))
+        }
+      }));
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await this.makeRequest(body, request);
+      } 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 (0, _chunk3OF56EMAcjs.ApiError)(
+      "Failed to communicate with Ollama. Please try again.",
+      "network_error",
+      0,
+      true
+    )));
+  }
+  async makeRequest(body, request) {
+    let response;
+    try {
+      const timeoutController = new AbortController();
+      const timerId = setTimeout(() => timeoutController.abort(), this.timeout);
+      const combinedSignal = request.signal ? this.combineSignals(request.signal, timeoutController.signal) : timeoutController.signal;
+      try {
+        response = await fetch(`${this.baseUrl}/api/chat`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(body),
+          signal: combinedSignal
+        });
+      } finally {
+        clearTimeout(timerId);
+      }
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && _optionalChain([request, 'access', _4 => _4.signal, 'optionalAccess', _5 => _5.aborted])) {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)(
+          `Ollama request timed out after ${this.timeout / 1e3}s. Local inference can be slow \u2014 consider increasing the timeout in your config.`,
+          "timeout",
+          0,
+          true
+        );
+      }
+      throw new (0, _chunk3OF56EMAcjs.ApiError)(
+        `Cannot connect to Ollama at ${this.baseUrl}. Make sure Ollama is running (try 'ollama serve').`,
+        "network_error",
+        0,
+        true
+      );
+    }
+    if (!response.ok) {
+      const apiError = await this.buildApiError(response, body);
+      if (apiError === null) {
+        return this.makeRequest(body, request);
+      }
+      throw apiError;
+    }
+    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) => {
+        let argumentsStr;
+        try {
+          argumentsStr = JSON.stringify(tc.function.arguments);
+        } catch (error) {
+          console.warn("Failed to stringify tool call arguments, using fallback:", error);
+          argumentsStr = String(tc.function.arguments);
+        }
+        return {
+          id: `ollama-tool-${Date.now()}-${index}`,
+          type: "function",
+          function: {
+            name: tc.function.name,
+            arguments: argumentsStr
+          }
+        };
+      });
+    }
+    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', _6 => _6.length]) ? "tool_calls" : "stop",
+      usage,
+      raw: data
+    };
+  }
+  /**
+   * Build an ApiError from a non-ok response.
+   *
+   * Returns `null` as a sentinel when the request was retried internally
+   * (e.g., disableTools retry). The caller must re-run makeRequest in
+   * that case.
+   */
+  async buildApiError(response, body) {
+    let errorBody = "";
+    try {
+      errorBody = await response.text();
+    } catch (e3) {
+    }
+    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;
+      if (Array.isArray(body.messages)) {
+        body.messages = this.sanitizeMessagesForToollessMode(body.messages);
+      }
+      return null;
+    }
+    if (this.isToolParserError(errorBody) && (body.tools || this.hasToolMetadata(body.messages))) {
+      console.warn(`Model ${body.model} rejected tool metadata. Retrying without tool support.`);
+      this.disableTools = true;
+      delete body.tools;
+      if (Array.isArray(body.messages)) {
+        body.messages = this.sanitizeMessagesForToollessMode(body.messages);
+      }
+      return null;
+    }
+    if (response.status === 429 || this.isOllamaCloudRateLimitError(errorBody)) {
+      const baseError = _chunk3OF56EMAcjs.classifyApiError.call(void 0, 
+        response.status === 429 ? response.status : 429,
+        errorBody,
+        response.headers
+      );
+      return new (0, _chunk3OF56EMAcjs.ApiError)(
+        "Ollama Cloud has paused this session because you hit a usage limit. This is expected on hosted Ollama plans. Wait a bit and try again, switch to another model, or upgrade your Ollama plan if you need higher limits.",
+        "rate_limited",
+        baseError.httpStatus,
+        true,
+        baseError.retryAfterMs,
+        errorBody
+      );
+    }
+    if (response.status === 400) {
+      const baseError = _chunk3OF56EMAcjs.classifyApiError.call(void 0, response.status, errorBody, response.headers);
+      return new (0, _chunk3OF56EMAcjs.ApiError)(
+        `Ollama rejected the request. This can happen when message content confuses the model's parser. Try simplifying your prompt or using a different model.
+${errorBody}`,
+        baseError.code,
+        baseError.httpStatus,
+        baseError.retryable,
+        baseError.retryAfterMs,
+        errorBody
+      );
+    }
+    if (response.status === 404) {
+      const baseError = _chunk3OF56EMAcjs.classifyApiError.call(void 0, response.status, errorBody, response.headers);
+      return new (0, _chunk3OF56EMAcjs.ApiError)(
+        `Model not found. Run 'ollama pull ${String(body.model)}' to download it.
+${errorBody}`,
+        baseError.code,
+        baseError.httpStatus,
+        baseError.retryable,
+        baseError.retryAfterMs,
+        errorBody
+      );
+    }
+    return _chunk3OF56EMAcjs.classifyApiError.call(void 0, response.status, errorBody, response.headers);
+  }
+  buildMessages(messages, includeToolMetadata) {
+    if (!includeToolMetadata) {
+      return this.sanitizeMessagesForToollessMode(messages);
+    }
+    return 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" && _optionalChain([msg, 'access', _7 => _7.tool_calls, 'optionalAccess', _8 => _8.length])) {
+        mapped.tool_calls = this.normalizeToolCallsForRequest(msg.tool_calls);
+      }
+      return mapped;
+    });
+  }
+  normalizeToolCallsForRequest(toolCalls) {
+    return toolCalls.map((toolCall) => ({
+      function: {
+        name: toolCall.function.name,
+        arguments: this.parseToolArguments(toolCall.function.arguments)
+      }
+    }));
+  }
+  parseToolArguments(rawArguments) {
+    try {
+      const parsed = JSON.parse(rawArguments);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch (e4) {
+    }
+    return { __raw_arguments: rawArguments };
+  }
+  sanitizeMessagesForToollessMode(messages) {
+    return messages.map((msg) => {
+      const role = typeof msg.role === "string" ? msg.role : "user";
+      const content = typeof msg.content === "string" ? msg.content : "";
+      const name = typeof msg.name === "string" ? msg.name : void 0;
+      const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : void 0;
+      if (role === "tool") {
+        return {
+          role: "user",
+          content: name ? `[Tool result: ${name}]
+${content}` : `[Tool result]
+${content}`
+        };
+      }
+      if (role === "assistant" && _optionalChain([toolCalls, 'optionalAccess', _9 => _9.length])) {
+        const toolNames = toolCalls.map((call) => {
+          const fn = call && typeof call === "object" ? call.function : void 0;
+          return typeof _optionalChain([fn, 'optionalAccess', _10 => _10.name]) === "string" ? fn.name : void 0;
+        }).filter((value) => Boolean(value));
+        const toolSummary = toolNames.length > 0 ? `
+[Assistant requested tools: ${toolNames.join(", ")}]` : "";
+        return {
+          role: "assistant",
+          content: `${content}${toolSummary}`.trim()
+        };
+      }
+      return {
+        role,
+        content,
+        ...name ? { name } : {}
+      };
+    });
+  }
+  hasToolMetadata(messages) {
+    if (!Array.isArray(messages)) {
+      return false;
+    }
+    return messages.some((msg) => {
+      if (!msg || typeof msg !== "object") {
+        return false;
+      }
+      const candidate = msg;
+      return candidate.role === "tool" || candidate.tool_call_id !== void 0 || candidate.tool_calls !== void 0;
+    });
+  }
+  isToolParserError(errorBody) {
+    const lower = errorBody.toLowerCase();
+    return lower.includes("value looks like object, but can't find closing '}' symbol") || lower.includes("value looks like object, but can't find closing") || lower.includes("tool") && lower.includes("parse") || lower.includes("function") && lower.includes("arguments") && lower.includes("closing");
+  }
+  isOllamaCloudRateLimitError(errorBody) {
+    const lower = errorBody.toLowerCase();
+    return lower.includes("session usage limit") || lower.includes("rate limit exceeded") || lower.includes("upgrade for higher limits") && lower.includes("ollama.com/upgrade");
+  }
+  async handleStreamingResponse(response) {
+    const reader = _optionalChain([response, 'access', _11 => _11.body, 'optionalAccess', _12 => _12.getReader, 'call', _13 => _13()]);
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let fullContent = "";
+    let lastData = null;
+    let streamEndedWithDone = false;
+    try {
+      while (true) {
+        const chunkResult = await this.readWithTimeout(reader, this.chunkTimeout, fullContent);
+        if ("timedOut" in chunkResult) {
+          if (fullContent) {
+            return {
+              id: `ollama-${Date.now()}`,
+              created: lastData ? Math.floor(new Date(lastData.created_at).getTime() / 1e3) : Math.floor(Date.now() / 1e3),
+              content: fullContent,
+              finishReason: "length",
+              raw: lastData
+            };
+          }
+          throw new (0, _chunk3OF56EMAcjs.ApiError)(
+            `Ollama stream timed out after ${this.chunkTimeout / 1e3}s with no data. Make sure Ollama is running and the model is loaded.`,
+            "timeout",
+            0,
+            true
+          );
+        }
+        const { done, value } = chunkResult;
+        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;
+            if (data.done) {
+              streamEndedWithDone = true;
+            }
+          } catch (e5) {
+          }
+        }
+        if (streamEndedWithDone) {
+          break;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const finishReason = streamEndedWithDone ? "stop" : "length";
+    return {
+      id: `ollama-${Date.now()}`,
+      created: lastData ? Math.floor(new Date(lastData.created_at).getTime() / 1e3) : Math.floor(Date.now() / 1e3),
+      content: fullContent,
+      finishReason,
+      raw: lastData
+    };
+  }
+  /**
+   * Read one chunk from the stream with a timeout.
+   * Returns `{ timedOut: true }` if the timeout fires before a chunk arrives.
+   */
+  async readWithTimeout(reader, timeoutMs, _partialContent) {
+    let timerId;
+    const timeoutPromise = new Promise((resolve) => {
+      timerId = setTimeout(() => resolve({ timedOut: true }), timeoutMs);
+    });
+    try {
+      const result = await Promise.race([
+        reader.read(),
+        timeoutPromise
+      ]);
+      if ("timedOut" in result) {
+        return result;
+      }
+      return { done: result.done, value: result.value || new Uint8Array() };
+    } finally {
+      clearTimeout(timerId);
+    }
+  }
+  isNonRetryableError(error) {
+    if (error instanceof _chunk3OF56EMAcjs.ApiError) {
+      return !error.retryable;
+    }
+    const classified = _chunk3OF56EMAcjs.classifyApiError.call(void 0, 0, error.message);
+    return !classified.retryable;
+  }
+  combineSignals(signal1, signal2) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal1.addEventListener("abort", abort, { once: true });
+    signal2.addEventListener("abort", abort, { once: true });
+    if (signal1.aborted || signal2.aborted) {
+      controller.abort();
+    }
+    return controller.signal;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}, _class);
+
+// src/providers/openaiAuth.ts
+var _crypto = require('crypto');
+var _http = require('http');
+var OPENAI_AUTH_BASE_URL = "https://auth.openai.com";
+var OPENAI_OAUTH_AUTHORIZE_URL = `${OPENAI_AUTH_BASE_URL}/oauth/authorize`;
+var OPENAI_OAUTH_TOKEN_URL = `${OPENAI_AUTH_BASE_URL}/oauth/token`;
+var OPENAI_DEVICE_USER_CODE_URL = `${OPENAI_AUTH_BASE_URL}/api/accounts/deviceauth/usercode`;
+var OPENAI_DEVICE_TOKEN_URL = `${OPENAI_AUTH_BASE_URL}/api/accounts/deviceauth/token`;
+var OPENAI_DEVICE_VERIFICATION_URL = `${OPENAI_AUTH_BASE_URL}/codex/device`;
+var OPENAI_DEVICE_CALLBACK_URL = `${OPENAI_AUTH_BASE_URL}/deviceauth/callback`;
+var OPENAI_CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var OPENAI_AUTH_REQUEST_TIMEOUT_MS = 15e3;
+var OPENAI_BROWSER_AUTH_TIMEOUT_MS = 5 * 6e4;
+var OPENAI_BROWSER_AUTH_SCOPE = "openid profile email offline_access";
+var OPENAI_BROWSER_CALLBACK_HOST = "127.0.0.1";
+var OPENAI_BROWSER_CALLBACK_URL_HOST = "localhost";
+var OPENAI_BROWSER_CALLBACK_PORT = 1455;
+var OPENAI_BROWSER_CALLBACK_PATH = "/auth/callback";
+var OPENAI_BROWSER_OAUTH_ORIGINATOR = "autohand-code";
+function decodeJwtPayload(token) {
+  const parts = token.split(".");
+  if (parts.length < 2) return null;
+  try {
+    const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64.padEnd(base64.length + (4 - base64.length % 4) % 4, "=");
+    return JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+  } catch (e6) {
+    return null;
+  }
+}
+function decodeJwtExpiry(token) {
+  const payload = decodeJwtPayload(token);
+  if (!_optionalChain([payload, 'optionalAccess', _14 => _14.exp])) return void 0;
+  return new Date(payload.exp * 1e3).toISOString();
+}
+function buildTokenBody(params) {
+  return new URLSearchParams(params).toString();
+}
+function toBase64Url(buffer) {
+  return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function generatePkceVerifier() {
+  return toBase64Url(_crypto.randomBytes.call(void 0, 32));
+}
+function generatePkceChallenge(verifier) {
+  return toBase64Url(_crypto.createHash.call(void 0, "sha256").update(verifier).digest());
+}
+function createState() {
+  return _crypto.randomBytes.call(void 0, 16).toString("hex");
+}
+async function fetchWithTimeout(input, init, context, timeoutMs = OPENAI_AUTH_REQUEST_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(input, {
+      ...init,
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`${context} timed out. Check your connection and try again.`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function extractErrorDetail(payload) {
+  if (!payload || typeof payload !== "object") return void 0;
+  const candidate = payload;
+  const direct = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(candidate.error_description, () => ( candidate.error)), () => ( candidate.message)), () => ( candidate.detail));
+  if (typeof direct === "string" && direct.trim()) {
+    return direct.trim();
+  }
+  const nestedError = candidate.error;
+  if (nestedError && typeof nestedError === "object") {
+    const nested = nestedError;
+    for (const key of ["message", "error_description", "detail", "code"]) {
+      const value = nested[key];
+      if (typeof value === "string" && value.trim()) {
+        return value.trim();
+      }
+    }
+  }
+  return void 0;
+}
+async function parseJsonResponse(response, context) {
+  const { payload, detail } = await parseResponseBody(response);
+  if (!response.ok) {
+    throw new Error(
+      detail ? `${context} failed with status ${response.status}: ${detail}` : `${context} failed with status ${response.status}.`
+    );
+  }
+  if (payload === void 0) {
+    throw new Error(`${context} returned an empty response.`);
+  }
+  return payload;
+}
+async function parseResponseBody(response) {
+  const rawText = await response.text();
+  let payload;
+  if (rawText.trim()) {
+    try {
+      payload = JSON.parse(rawText);
+    } catch (e7) {
+      payload = rawText;
+    }
+  }
+  const detail = _nullishCoalesce(extractErrorDetail(payload), () => ( (typeof payload === "string" && payload.trim() ? payload.trim() : void 0)));
+  return { payload, detail };
+}
+async function openBrowser(url) {
+  try {
+    const open = await Promise.resolve().then(() => _interopRequireWildcard(require("open"))).then((mod) => mod.default);
+    await open(url);
+    return true;
+  } catch (e8) {
+    return false;
+  }
+}
+function callbackSuccessHtml() {
+  return "<!doctype html><html><body><h1>OpenAI sign-in complete.</h1><p>You can close this window.</p></body></html>";
+}
+function callbackErrorHtml(message) {
+  return `<!doctype html><html><body><h1>OpenAI sign-in failed.</h1><p>${message}</p></body></html>`;
+}
+async function listenForOAuthCallback(expectedState) {
+  const server = _http.createServer.call(void 0, (req, res) => {
+    try {
+      const url = new URL(req.url || "", `http://${OPENAI_BROWSER_CALLBACK_HOST}`);
+      if (url.pathname !== OPENAI_BROWSER_CALLBACK_PATH) {
+        res.statusCode = 404;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.end(callbackErrorHtml("Callback route not found."));
+        return;
+      }
+      const error = url.searchParams.get("error");
+      const errorDescription = url.searchParams.get("error_description");
+      if (error) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.end(callbackErrorHtml(errorDescription || error));
+        _optionalChain([settle, 'optionalCall', _15 => _15({
+          error,
+          errorDescription: errorDescription || void 0
+        })]);
+        return;
+      }
+      const state = url.searchParams.get("state");
+      if (state !== expectedState) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.end(callbackErrorHtml("State mismatch."));
+        _optionalChain([settle, 'optionalCall', _16 => _16({
+          error: "state_mismatch",
+          errorDescription: "State mismatch."
+        })]);
+        return;
+      }
+      const code = url.searchParams.get("code");
+      if (!code) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.end(callbackErrorHtml("Missing authorization code."));
+        _optionalChain([settle, 'optionalCall', _17 => _17({
+          error: "missing_code",
+          errorDescription: "Missing authorization code."
+        })]);
+        return;
+      }
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(callbackSuccessHtml());
+      _optionalChain([settle, 'optionalCall', _18 => _18({ code })]);
+    } catch (e9) {
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(callbackErrorHtml("Internal error while handling the callback."));
+      _optionalChain([settle, 'optionalCall', _19 => _19({
+        error: "callback_error",
+        errorDescription: "Internal error while handling the callback."
+      })]);
+    }
+  });
+  const timeoutId = setTimeout(() => {
+    _optionalChain([settle, 'optionalCall', _20 => _20({
+      error: "timeout",
+      errorDescription: "OpenAI sign-in timed out. Finish the browser sign-in and try again."
+    })]);
+  }, OPENAI_BROWSER_AUTH_TIMEOUT_MS);
+  let settle;
+  let settled = false;
+  const waitForResult = new Promise((resolve) => {
+    settle = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      resolve(result);
+    };
+  });
+  const listenOnPort = async (port) => new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, OPENAI_BROWSER_CALLBACK_HOST, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  try {
+    await listenOnPort(OPENAI_BROWSER_CALLBACK_PORT);
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "EADDRINUSE") {
+      throw error;
+    }
+    await listenOnPort(0);
+  }
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("Failed to determine OpenAI OAuth callback address.");
+  }
+  const callbackPort = address.port;
+  return {
+    redirectUri: `http://${OPENAI_BROWSER_CALLBACK_URL_HOST}:${callbackPort}${OPENAI_BROWSER_CALLBACK_PATH}`,
+    waitForResult: () => waitForResult,
+    close: async () => {
+      if (timeoutId) clearTimeout(timeoutId);
+      await new Promise((resolve) => {
+        server.close(() => resolve());
+      });
+    }
+  };
+}
+function extractChatGPTAccountId(token) {
+  const payload = decodeJwtPayload(token);
+  return _optionalChain([payload, 'optionalAccess', _21 => _21["https://api.openai.com/auth"], 'optionalAccess', _22 => _22.chatgpt_account_id]);
+}
+function isChatGPTAuthExpired(auth, leewayMs = 6e4) {
+  if (!auth.expiresAt) return false;
+  return new Date(auth.expiresAt).getTime() <= Date.now() + leewayMs;
+}
+async function authenticateOpenAIChatGPT(options = {}) {
+  const verifier = generatePkceVerifier();
+  const challenge = generatePkceChallenge(verifier);
+  const state = createState();
+  const callback = await listenForOAuthCallback(state);
+  try {
+    const authorizeUrl = new URL(OPENAI_OAUTH_AUTHORIZE_URL);
+    authorizeUrl.searchParams.set("response_type", "code");
+    authorizeUrl.searchParams.set("client_id", OPENAI_CODEX_CLIENT_ID);
+    authorizeUrl.searchParams.set("redirect_uri", callback.redirectUri);
+    authorizeUrl.searchParams.set("scope", OPENAI_BROWSER_AUTH_SCOPE);
+    authorizeUrl.searchParams.set("code_challenge", challenge);
+    authorizeUrl.searchParams.set("code_challenge_method", "S256");
+    authorizeUrl.searchParams.set("state", state);
+    authorizeUrl.searchParams.set("id_token_add_organizations", "true");
+    authorizeUrl.searchParams.set("codex_cli_simplified_flow", "true");
+    authorizeUrl.searchParams.set("originator", OPENAI_BROWSER_OAUTH_ORIGINATOR);
+    const browserOpened = await openBrowser(authorizeUrl.toString());
+    await _optionalChain([options, 'access', _23 => _23.onPrompt, 'optionalCall', _24 => _24({
+      authorizationUrl: authorizeUrl.toString(),
+      redirectUri: callback.redirectUri,
+      browserOpened
+    })]);
+    const result = await callback.waitForResult();
+    if (result.error) {
+      throw new Error(result.errorDescription || result.error);
+    }
+    if (!result.code) {
+      throw new Error("OpenAI sign-in did not return an authorization code.");
+    }
+    const tokenResponse = await fetchWithTimeout(OPENAI_OAUTH_TOKEN_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: buildTokenBody({
+        grant_type: "authorization_code",
+        client_id: OPENAI_CODEX_CLIENT_ID,
+        code: result.code,
+        redirect_uri: callback.redirectUri,
+        code_verifier: verifier
+      })
+    }, "OpenAI ChatGPT token exchange");
+    const tokenPayload = await parseJsonResponse(
+      tokenResponse,
+      "OpenAI ChatGPT token exchange"
+    );
+    const accessToken = tokenPayload.access_token;
+    const refreshToken = tokenPayload.refresh_token;
+    const idToken = tokenPayload.id_token;
+    const accountId = idToken && extractChatGPTAccountId(idToken) || accessToken && extractChatGPTAccountId(accessToken);
+    if (!accessToken || !accountId) {
+      throw new Error("OpenAI ChatGPT token exchange returned no usable account credentials.");
+    }
+    const expiresAt = tokenPayload.expires_in ? new Date(Date.now() + tokenPayload.expires_in * 1e3).toISOString() : idToken && decodeJwtExpiry(idToken) || decodeJwtExpiry(accessToken);
+    return {
+      accessToken,
+      refreshToken,
+      idToken,
+      accountId,
+      expiresAt,
+      lastRefresh: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } finally {
+    await callback.close();
+  }
+}
+async function refreshChatGPTAuth(auth) {
+  if (!auth.refreshToken) {
+    throw new Error("ChatGPT refresh token is missing. Sign in again.");
+  }
+  const response = await fetchWithTimeout(OPENAI_OAUTH_TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: buildTokenBody({
+      grant_type: "refresh_token",
+      client_id: OPENAI_CODEX_CLIENT_ID,
+      refresh_token: auth.refreshToken
+    })
+  }, "ChatGPT token refresh");
+  const payload = await parseJsonResponse(response, "ChatGPT token refresh");
+  if (!payload.access_token) {
+    throw new Error("ChatGPT token refresh returned no access token.");
+  }
+  const accountId = auth.accountId || payload.id_token && extractChatGPTAccountId(payload.id_token) || extractChatGPTAccountId(payload.access_token);
+  if (!accountId) {
+    throw new Error("ChatGPT token refresh returned no ChatGPT account ID.");
+  }
+  const expiresAt = payload.expires_in ? new Date(Date.now() + payload.expires_in * 1e3).toISOString() : payload.id_token && decodeJwtExpiry(payload.id_token) || decodeJwtExpiry(payload.access_token);
+  return {
+    accessToken: payload.access_token,
+    refreshToken: _nullishCoalesce(payload.refresh_token, () => ( auth.refreshToken)),
+    idToken: _nullishCoalesce(payload.id_token, () => ( auth.idToken)),
+    accountId,
+    expiresAt,
+    lastRefresh: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/providers/OpenAIProvider.ts
+var OPENAI_MODELS = [
+  "gpt-5.4",
+  "gpt-5.4-pro",
+  "gpt-5.4-mini",
+  "gpt-5.4-nano",
+  "gpt-5.3-codex",
+  "gpt-5.1-codex-max"
+];
+var VALID_REASONING_EFFORTS = /* @__PURE__ */ new Set(["none", "low", "medium", "high", "xhigh"]);
+var OPENAI_API_BASE_URL = "https://api.openai.com/v1";
+var OPENAI_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+var DEFAULT_CODEX_INSTRUCTIONS = "You are Autohand, a coding assistant. Follow the repository instructions and help the user complete software tasks.";
+var OPENAI_API_KEY_FRIENDLY_MESSAGES = {
+  auth_failed: "Authentication failed. Please verify your OpenAI API key in ~/.autohand/config.json.",
+  payment_required: "Payment required. Please check your OpenAI account balance or billing settings.",
+  access_denied: "Access denied. Your OpenAI API key may not have permission for this model.",
+  server_error: "The OpenAI service encountered an error. Please try again later.",
+  network_error: "Unable to connect to OpenAI. Please check your internet connection and OpenAI API configuration.",
+  timeout: "The request timed out. The OpenAI service may be experiencing high load."
+};
+var OPENAI_CHATGPT_FRIENDLY_MESSAGES = {
+  auth_failed: "ChatGPT authentication failed. Please sign in again.",
+  access_denied: "Access denied. Your ChatGPT account may not have access to this model or Codex backend.",
+  server_error: "The ChatGPT Codex service encountered an error. Please try again later.",
+  network_error: "Unable to connect to ChatGPT Codex. Please check your internet connection.",
+  timeout: "The request timed out. The ChatGPT Codex service may be experiencing high load."
+};
+var OpenAIProvider = class {
+  
+  
+  
+  
+  
+  
+  constructor(config) {
+    this.authMode = config.authMode === "chatgpt" ? "chatgpt" : "api-key";
+    this.baseUrl = this.resolveBaseUrl(config.baseUrl);
+    this.apiKey = config.apiKey || "";
+    this.model = config.model || "gpt-5.4";
+    this.reasoningEffort = config.reasoningEffort;
+    this.chatgptAuth = config.chatgptAuth;
+  }
+  getName() {
+    return "openai";
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  async listModels() {
+    return [...OPENAI_MODELS];
+  }
+  async isAvailable() {
+    if (this.authMode === "chatgpt") {
+      return !!_optionalChain([this, 'access', _25 => _25.chatgptAuth, 'optionalAccess', _26 => _26.accessToken]) && !!_optionalChain([this, 'access', _27 => _27.chatgptAuth, 'optionalAccess', _28 => _28.accountId]);
+    }
+    try {
+      const headers = await this.buildAuthHeaders();
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers
+      });
+      return response.ok;
+    } catch (e10) {
+      return false;
+    }
+  }
+  async complete(request) {
+    if (this.authMode === "chatgpt") {
+      return this.completeWithResponsesApi(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 === "assistant" && _optionalChain([msg, 'access', _29 => _29.tool_calls, 'optionalAccess', _30 => _30.length])) {
+          mapped.tool_calls = msg.tool_calls;
+        }
+        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,
+      // Newer OpenAI models (gpt-5.x, o-series) require max_completion_tokens
+      // instead of max_tokens. Use the correct parameter based on model.
+      ...this.usesMaxCompletionTokens(request.model || this.model) ? { max_completion_tokens: request.maxTokens } : { max_tokens: request.maxTokens }
+    };
+    if (this.reasoningEffort && VALID_REASONING_EFFORTS.has(this.reasoningEffort)) {
+      body.reasoning_effort = this.reasoningEffort;
+    }
+    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;
+      }
+    }
+    let response;
+    const headers = await this.buildAuthHeaders();
+    try {
+      response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify(body),
+        signal: request.signal
+      });
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && _optionalChain([request, 'access', _31 => _31.signal, 'optionalAccess', _32 => _32.aborted])) {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)(
+          "The request timed out. The OpenAI service may be experiencing high load.",
+          "timeout",
+          0,
+          true
+        );
+      }
+      throw new (0, _chunk3OF56EMAcjs.ApiError)(
+        `Unable to connect to ${this.baseUrl}. Please check the URL and your internet connection.`,
+        "network_error",
+        0,
+        true
+      );
+    }
+    if (!response.ok) {
+      throw await this.buildApiError(response);
+    }
+    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
+    };
+  }
+  async completeWithResponsesApi(request) {
+    const instructions = this.buildCodexInstructions(request.messages);
+    const body = {
+      model: request.model || this.model,
+      instructions,
+      store: false,
+      stream: true,
+      tool_choice: "auto",
+      parallel_tool_calls: true,
+      input: request.messages.flatMap((msg) => this.toResponsesInputItems(msg))
+    };
+    if (this.reasoningEffort && VALID_REASONING_EFFORTS.has(this.reasoningEffort)) {
+      body.reasoning = {
+        effort: this.reasoningEffort
+      };
+      body.include = ["reasoning.encrypted_content"];
+    }
+    if (request.tools && request.tools.length > 0) {
+      body.tools = request.tools.map((tool) => ({
+        type: "function",
+        name: tool.name,
+        description: tool.description,
+        parameters: _nullishCoalesce(tool.parameters, () => ( { type: "object", properties: {} }))
+      }));
+      if (request.toolChoice === "required") {
+        body.tool_choice = "required";
+      } else if (request.toolChoice === "none") {
+        body.tool_choice = "none";
+      } else if (request.toolChoice && typeof request.toolChoice === "object") {
+        body.tool_choice = {
+          type: "function",
+          name: request.toolChoice.function.name
+        };
+      }
+    }
+    const headers = await this.buildAuthHeaders();
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}/responses`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify(body),
+        signal: request.signal
+      });
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && _optionalChain([request, 'access', _33 => _33.signal, 'optionalAccess', _34 => _34.aborted])) {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)(
+          "The request timed out. The ChatGPT Codex service may be experiencing high load.",
+          "timeout",
+          0,
+          true
+        );
+      }
+      throw new (0, _chunk3OF56EMAcjs.ApiError)(
+        `Unable to connect to ${this.baseUrl}. Please check the URL and your internet connection.`,
+        "network_error",
+        0,
+        true
+      );
+    }
+    if (!response.ok) {
+      throw await this.buildApiError(response);
+    }
+    const data = await this.parseCodexStream(response);
+    const toolCalls = this.extractResponsesToolCalls(data.output);
+    const content = this.extractResponsesContent(data);
+    const usage = data.usage ? {
+      promptTokens: _nullishCoalesce(data.usage.input_tokens, () => ( 0)),
+      completionTokens: _nullishCoalesce(data.usage.output_tokens, () => ( 0)),
+      totalTokens: _nullishCoalesce(data.usage.total_tokens, () => ( (_nullishCoalesce(data.usage.input_tokens, () => ( 0))) + (_nullishCoalesce(data.usage.output_tokens, () => ( 0)))))
+    } : void 0;
+    return {
+      id: data.id,
+      created: _nullishCoalesce(data.created_at, () => ( Math.floor(Date.now() / 1e3))),
+      content,
+      toolCalls,
+      finishReason: toolCalls.length > 0 ? "tool_calls" : _optionalChain([data, 'access', _35 => _35.incomplete_details, 'optionalAccess', _36 => _36.reason]) === "max_output_tokens" ? "length" : "stop",
+      usage,
+      raw: data
+    };
+  }
+  async buildApiError(response) {
+    let errorDetail = "";
+    try {
+      const body = await response.json();
+      const errObj = _optionalChain([body, 'optionalAccess', _37 => _37.error]);
+      errorDetail = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([errObj, 'optionalAccess', _38 => _38.message]), () => ( _optionalChain([body, 'optionalAccess', _39 => _39.detail]))), () => ( _optionalChain([body, 'optionalAccess', _40 => _40.error]))), () => ( ""));
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch (e11) {
+      try {
+        errorDetail = await response.text();
+      } catch (e12) {
+      }
+    }
+    return this.withOpenAIMessage(_chunk3OF56EMAcjs.classifyApiError.call(void 0, response.status, errorDetail, response.headers));
+  }
+  withOpenAIMessage(error) {
+    const messages = this.authMode === "chatgpt" ? OPENAI_CHATGPT_FRIENDLY_MESSAGES : OPENAI_API_KEY_FRIENDLY_MESSAGES;
+    const friendlyMessage = messages[error.code];
+    if (!friendlyMessage) {
+      return error;
+    }
+    return new (0, _chunk3OF56EMAcjs.ApiError)(
+      error.rawDetail ? `${friendlyMessage}
+${error.rawDetail}` : friendlyMessage,
+      error.code,
+      error.httpStatus,
+      error.retryable,
+      error.retryAfterMs,
+      error.rawDetail
+    );
+  }
+  /**
+   * Parse an SSE stream from the ChatGPT Codex backend and extract the
+   * `response.completed` event payload as the full response object.
+   */
+  async parseCodexStream(response) {
+    const text = await response.text();
+    let currentEvent = "";
+    let completedData = null;
+    for (const line of text.split("\n")) {
+      if (line.startsWith("event: ")) {
+        currentEvent = line.slice(7).trim();
+        continue;
+      }
+      if (line.startsWith("data: ") && currentEvent === "response.completed") {
+        completedData = JSON.parse(line.slice(6));
+        break;
+      }
+    }
+    if (!completedData) {
+      throw new (0, _chunk3OF56EMAcjs.ApiError)(
+        "No response.completed event found in stream. The API response may be malformed.",
+        "invalid_request",
+        0,
+        false
+      );
+    }
+    return completedData;
+  }
+  async buildAuthHeaders() {
+    if (this.authMode === "chatgpt") {
+      if (!_optionalChain([this, 'access', _41 => _41.chatgptAuth, 'optionalAccess', _42 => _42.accessToken]) || !this.chatgptAuth.accountId) {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)("ChatGPT authentication is missing. Please sign in again.", "auth_failed", 401, false);
+      }
+      if (isChatGPTAuthExpired(this.chatgptAuth)) {
+        this.chatgptAuth = await refreshChatGPTAuth(this.chatgptAuth);
+      }
+      return {
+        Authorization: `Bearer ${this.chatgptAuth.accessToken}`,
+        "chatgpt-account-id": this.chatgptAuth.accountId
+      };
+    }
+    return {
+      Authorization: `Bearer ${this.apiKey}`
+    };
+  }
+  resolveBaseUrl(configBaseUrl) {
+    if (this.authMode === "chatgpt") {
+      if (!configBaseUrl || configBaseUrl === OPENAI_API_BASE_URL) {
+        return OPENAI_CODEX_BASE_URL;
+      }
+      return configBaseUrl.replace(/\/$/, "");
+    }
+    return (configBaseUrl || OPENAI_API_BASE_URL).replace(/\/$/, "");
+  }
+  toResponsesInputItems(msg) {
+    const items = [];
+    if (msg.role === "system") {
+      return items;
+    }
+    if (msg.role === "tool" && msg.tool_call_id) {
+      items.push({
+        type: "function_call_output",
+        call_id: msg.tool_call_id,
+        output: msg.content
+      });
+      return items;
+    }
+    if (msg.content) {
+      items.push({
+        type: "message",
+        role: msg.role === "tool" ? "user" : msg.role,
+        content: [{ type: "input_text", text: msg.content }]
+      });
+    }
+    if (msg.role === "assistant" && _optionalChain([msg, 'access', _43 => _43.tool_calls, 'optionalAccess', _44 => _44.length])) {
+      for (const toolCall of msg.tool_calls) {
+        items.push({
+          type: "function_call",
+          call_id: toolCall.id,
+          name: toolCall.function.name,
+          arguments: toolCall.function.arguments
+        });
+      }
+    }
+    return items;
+  }
+  buildCodexInstructions(messages) {
+    const systemMessages = messages.filter((msg) => msg.role === "system" && typeof msg.content === "string" && msg.content.trim()).map((msg) => msg.content.trim());
+    if (systemMessages.length === 0) {
+      return DEFAULT_CODEX_INSTRUCTIONS;
+    }
+    return [DEFAULT_CODEX_INSTRUCTIONS, ...systemMessages].join("\n\n");
+  }
+  extractResponsesToolCalls(output) {
+    if (!Array.isArray(output)) {
+      return [];
+    }
+    return output.filter((entry) => _optionalChain([entry, 'optionalAccess', _45 => _45.type]) === "function_call").map((toolCall, index) => ({
+      id: _nullishCoalesce(toolCall.call_id, () => ( `call_${index + 1}`)),
+      type: "function",
+      function: {
+        name: toolCall.name,
+        arguments: toolCall.arguments
+      }
+    }));
+  }
+  /**
+   * Determine if a model requires `max_completion_tokens` instead of `max_tokens`.
+   * OpenAI's newer models (gpt-5.x, o-series) reject `max_tokens` with a 400 error.
+   */
+  usesMaxCompletionTokens(model) {
+    const lower = model.toLowerCase();
+    return lower.startsWith("gpt-5") || lower.startsWith("o1") || lower.startsWith("o3") || lower.startsWith("o4");
+  }
+  extractResponsesContent(data) {
+    if (typeof data.output_text === "string" && data.output_text.trim()) {
+      return data.output_text;
+    }
+    if (!Array.isArray(data.output)) {
+      return "";
+    }
+    const parts = [];
+    for (const item of data.output) {
+      if (_optionalChain([item, 'optionalAccess', _46 => _46.type]) !== "message" || !Array.isArray(item.content)) {
+        continue;
+      }
+      for (const contentItem of item.content) {
+        if (_optionalChain([contentItem, 'optionalAccess', _47 => _47.type]) === "output_text" && typeof contentItem.text === "string") {
+          parts.push(contentItem.text);
+        }
+      }
+    }
+    return parts.join("\n").trim();
+  }
+};
+
+// src/providers/LlamaCppProvider.ts
+var LlamaCppProvider = (_class2 = class _LlamaCppProvider {
+  
+  
+  static __initStatic() {this.DEFAULT_MODEL = "local"}
+  constructor(config) {
+    const port = config.port || 8080;
+    this.baseUrl = config.baseUrl || `http://localhost:${port}`;
+    this.model = config.model || _LlamaCppProvider.DEFAULT_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', _48 => _48.data, 'optionalAccess', _49 => _49.map, 'call', _50 => _50((m) => m.id)]), () => ( [this.model]));
+    } catch (e13) {
+      return this.model ? [this.model] : [];
+    }
+  }
+  async isAvailable() {
+    try {
+      const response = await fetch(`${this.baseUrl}/health`);
+      return response.ok;
+    } catch (e14) {
+      return false;
+    }
+  }
+  async complete(request) {
+    const body = {
+      model: request.model || this.model || _LlamaCppProvider.DEFAULT_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 await this.buildApiError(response, body);
+    }
+    const data = await response.json();
+    const choice = data.choices[0];
+    let toolCalls;
+    if (_optionalChain([choice, 'optionalAccess', _51 => _51.message, 'access', _52 => _52.tool_calls, 'optionalAccess', _53 => _53.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', _54 => _54.length]) ? "tool_calls" : _optionalChain([choice, 'optionalAccess', _55 => _55.finish_reason]) === "stop" || _optionalChain([choice, 'optionalAccess', _56 => _56.finish_reason]) === "length" || _optionalChain([choice, 'optionalAccess', _57 => _57.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', _58 => _58.message, 'access', _59 => _59.content]), () => ( "")),
+      toolCalls,
+      finishReason,
+      usage,
+      raw: data
+    };
+  }
+  async buildApiError(response, body) {
+    let errorBody = "";
+    try {
+      errorBody = await response.text();
+    } catch (e15) {
+    }
+    const lowerBody = errorBody.toLowerCase();
+    if (body.tools && response.status === 400 && (lowerBody.includes("tool") || lowerBody.includes("function") || lowerBody.includes("schema"))) {
+      return new (0, _chunk3OF56EMAcjs.ApiError)(
+        `llama.cpp rejected tool-enabled requests. If you want tool support, start llama-server with function-calling settings such as '--jinja -fa' and, if needed, '--chat-template chatml' or '--chat-template-file /path/to/tool_use.jinja'.
+${errorBody}`,
+        "invalid_request",
+        response.status,
+        false,
+        void 0,
+        errorBody
+      );
+    }
+    const baseError = _chunk3OF56EMAcjs.classifyApiError.call(void 0, response.status, errorBody, response.headers);
+    return new (0, _chunk3OF56EMAcjs.ApiError)(
+      `llama.cpp API error: ${response.status} ${response.statusText}${errorBody ? `
+${errorBody}` : ""}`,
+      baseError.code,
+      baseError.httpStatus,
+      baseError.retryable,
+      baseError.retryAfterMs,
+      errorBody
+    );
+  }
+}, _class2.__initStatic(), _class2);
+
+// src/providers/modelCapabilities.ts
+var OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+var CACHE_TTL_MS = 30 * 60 * 1e3;
+var cache = null;
+function normalizeModelId(model) {
+  return model.trim().toLowerCase();
+}
+function getCachedModels() {
+  if (!cache) {
+    return null;
+  }
+  if (Date.now() - cache.fetchedAt >= CACHE_TTL_MS) {
+    return null;
+  }
+  return cache.models;
+}
+function findModelCapability(models, model) {
+  const normalizedModel = normalizeModelId(model);
+  const exactMatch = models.find((candidate) => {
+    const candidateIds = [
+      candidate.id,
+      candidate.canonical_slug,
+      candidate.name
+    ].filter((value) => Boolean(value)).map(normalizeModelId);
+    return candidateIds.includes(normalizedModel);
+  });
+  if (exactMatch) {
+    return exactMatch;
+  }
+  return models.find((candidate) => {
+    const candidateIds = [
+      candidate.id,
+      candidate.canonical_slug,
+      candidate.name
+    ].filter((value) => Boolean(value)).map(normalizeModelId);
+    return candidateIds.some(
+      (candidateId) => candidateId.includes(normalizedModel) || normalizedModel.includes(candidateId)
+    );
+  });
+}
+function getInputModalities(capability) {
+  if (!capability) {
+    return [];
+  }
+  if (Array.isArray(capability.input_modalities)) {
+    return capability.input_modalities;
+  }
+  if (Array.isArray(_optionalChain([capability, 'access', _60 => _60.architecture, 'optionalAccess', _61 => _61.input_modalities]))) {
+    return capability.architecture.input_modalities;
+  }
+  return [];
+}
+function getOpenRouterCapabilityContextWindow(capability) {
+  const contextWindow = _nullishCoalesce(_optionalChain([capability, 'optionalAccess', _62 => _62.top_provider, 'optionalAccess', _63 => _63.context_length]), () => ( _optionalChain([capability, 'optionalAccess', _64 => _64.context_length])));
+  return typeof contextWindow === "number" && Number.isFinite(contextWindow) && contextWindow > 0 ? Math.floor(contextWindow) : void 0;
+}
+async function getOpenRouterModelContextWindow(model) {
+  const capability = await findCapabilityForModel(model);
+  return getOpenRouterCapabilityContextWindow(capability);
+}
+async function findCapabilityForModel(model) {
+  const cachedModels = getCachedModels();
+  if (cachedModels) {
+    const cachedMatch = findModelCapability(cachedModels, model);
+    if (cachedMatch) {
+      return cachedMatch;
+    }
+    const refreshedModels = await fetchOpenRouterModelCapabilities(true);
+    return findModelCapability(refreshedModels, model);
+  }
+  const models = await fetchOpenRouterModelCapabilities();
+  return findModelCapability(models, model);
+}
+async function fetchOpenRouterModelCapabilities(forceRefresh = false) {
+  if (!forceRefresh && cache && Date.now() - cache.fetchedAt < CACHE_TTL_MS) {
+    return cache.models;
+  }
+  try {
+    const response = await fetch(OPENROUTER_MODELS_URL, {
+      headers: {
+        "Content-Type": "application/json"
+      },
+      signal: AbortSignal.timeout(1e4)
+      // 10s timeout
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch model capabilities: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const models = Array.isArray(_optionalChain([data, 'optionalAccess', _65 => _65.data])) ? data.data : [];
+    cache = {
+      models,
+      fetchedAt: Date.now()
+    };
+    return models;
+  } catch (error) {
+    if (cache) {
+      return cache.models;
+    }
+    throw error;
+  }
+}
+async function modelSupportsImages(model) {
+  const lowerModel = model.toLowerCase();
+  try {
+    const found = await findCapabilityForModel(model);
+    const inputModalities = getInputModalities(found);
+    if (inputModalities.length > 0) {
+      return inputModalities.includes("image");
+    }
+    if (found) {
+      return quickVisionCheck(found.id.toLowerCase());
+    }
+    return quickVisionCheck(lowerModel);
+  } catch (e16) {
+    return quickVisionCheck(lowerModel);
+  }
+}
+function quickVisionCheck(lowerModel) {
+  if (lowerModel.includes("claude-3") || lowerModel.includes("claude-4") || lowerModel.includes("claude-sonnet-4") || lowerModel.includes("claude-opus-4") || lowerModel.includes("claude-opus-4-7")) {
+    return true;
+  }
+  if (lowerModel.includes("gpt-4o") || lowerModel.includes("gpt-4-turbo") || lowerModel.includes("gpt-4-vision") || lowerModel.includes("gpt-4.5") || lowerModel.includes("chatgpt-4o")) {
+    return true;
+  }
+  if (lowerModel.includes("gemini") && !lowerModel.includes("gemini-pro")) {
+    return true;
+  }
+  if (lowerModel.includes("gemini-1.5") || lowerModel.includes("gemini-2.0") || lowerModel.includes("gemini-2.5") || lowerModel.includes("gemini-pro-vision")) {
+    return true;
+  }
+  if (lowerModel.includes("llama-3.2") || lowerModel.includes("llama-3.3") || lowerModel.includes("llama-4")) {
+    if (lowerModel.includes("vision") || lowerModel.includes("multimodal")) {
+      return true;
+    }
+  }
+  if (lowerModel.includes("pixtral")) {
+    return true;
+  }
+  if (lowerModel.includes("qwen") && lowerModel.includes("vl")) {
+    return true;
+  }
+  if (lowerModel.includes("minicpm") && lowerModel.includes("v")) {
+    return true;
+  }
+  if (lowerModel.includes("command-r") && lowerModel.includes("vision")) {
+    return true;
+  }
+  if (lowerModel.includes("deepseek") && lowerModel.includes("vl")) {
+    return true;
+  }
+  if (lowerModel.includes("vision") || lowerModel.includes("vl-") || lowerModel.includes("-vl") || lowerModel.includes("multimodal")) {
+    return true;
+  }
+  return false;
+}
+
+// src/providers/OpenRouterClient.ts
+function messageContainsImageContent(messages) {
+  return messages.some(
+    (msg) => Array.isArray(msg.content) && msg.content.some(
+      (part) => typeof part === "object" && part !== null && "type" in part && part.type === "image_url"
+    )
+  );
+}
+function getTextContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.filter(
+    (part) => typeof part === "object" && part !== null && "type" in part
+  ).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => _nullishCoalesce(part.text, () => ( ""))).join("\n");
+}
+function sanitizeMessages(messages, allowImageInputs) {
+  return messages.map((msg) => {
+    const sanitized = {
+      role: msg.role,
+      content: allowImageInputs || !Array.isArray(msg.content) ? msg.content : getTextContent(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', _66 => _66.tool_calls, 'optionalAccess', _67 => _67.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_RETRIES2 = 3;
+var MAX_ALLOWED_RETRIES2 = 5;
+var DEFAULT_RETRY_DELAY2 = 1e3;
+var DEFAULT_TIMEOUT2 = 3e4;
+var OPENROUTER_FRIENDLY_MESSAGES = {
+  auth_failed: "Authentication failed. Please verify your OpenRouter API key in ~/.autohand/config.json.",
+  payment_required: "Payment required. Please check your OpenRouter account balance or billing settings.",
+  access_denied: "Access denied. Your OpenRouter API key may not have permission for this model.",
+  server_error: "The OpenRouter service encountered an error. Please try again later.",
+  network_error: "Unable to connect to OpenRouter. Please check your internet connection.",
+  timeout: "The request timed out. The OpenRouter service may be experiencing high load."
+};
+function withOpenRouterMessage(error) {
+  const friendlyMessage = OPENROUTER_FRIENDLY_MESSAGES[error.code];
+  if (!friendlyMessage) {
+    return error;
+  }
+  return new (0, _chunk3OF56EMAcjs.ApiError)(
+    error.rawDetail ? `${friendlyMessage}
+${error.rawDetail}` : friendlyMessage,
+    error.code,
+    error.httpStatus,
+    error.retryable,
+    error.retryAfterMs,
+    error.rawDetail
+  );
+}
+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', _68 => _68.maxRetries]), () => ( DEFAULT_MAX_RETRIES2));
+    this.maxRetries = Math.min(
+      Math.max(0, configuredRetries),
+      MAX_ALLOWED_RETRIES2
+    );
+    this.retryDelay = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _69 => _69.retryDelay]), () => ( DEFAULT_RETRY_DELAY2));
+    this.timeout = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _70 => _70.timeout]), () => ( DEFAULT_TIMEOUT2));
+  }
+  setDefaultModel(model) {
+    this.defaultModel = model;
+  }
+  async complete(request) {
+    const selectedModel = _nullishCoalesce(request.model, () => ( this.defaultModel));
+    const allowImageInputs = messageContainsImageContent(request.messages) ? await modelSupportsImages(selectedModel) : false;
+    const payload = {
+      model: selectedModel,
+      messages: sanitizeMessages(request.messages, allowImageInputs),
+      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 = selectedModel.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://autohand.dev",
+      "X-OpenRouter-Title": "Autohand Code CLI",
+      "X-OpenRouter-Categories": "cli-agent"
+    };
+    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 (0, _chunk3OF56EMAcjs.ApiError)(
+        `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.`,
+        "context_overflow",
+        400,
+        true
+      );
+    }
+    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 retryAfterMs = error instanceof _chunk3OF56EMAcjs.ApiError ? error.retryAfterMs : void 0;
+          const delay = Math.max(
+            this.retryDelay * Math.pow(2, attempt),
+            _nullishCoalesce(retryAfterMs, () => ( 0))
+          );
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw _nullishCoalesce(lastError, () => ( new (0, _chunk3OF56EMAcjs.ApiError)("Failed to communicate with the AI service. Please try again.", "network_error", 0, true)));
+  }
+  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', _71 => _71.aborted])) {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)(
+          "The request timed out. The OpenRouter service may be experiencing high load.",
+          "timeout",
+          0,
+          true
+        );
+      }
+      throw new (0, _chunk3OF56EMAcjs.ApiError)(
+        "Unable to connect to OpenRouter. Please check your internet connection.",
+        "network_error",
+        0,
+        true
+      );
+    }
+    if (!response.ok) {
+      throw await this.buildApiError(response);
+    }
+    const json = await response.json();
+    const message = _optionalChain([json, 'optionalAccess', _72 => _72.choices, 'optionalAccess', _73 => _73[0], 'optionalAccess', _74 => _74.message]);
+    const text = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _75 => _75.content]), () => ( ""));
+    const finishReason = _optionalChain([json, 'optionalAccess', _76 => _76.choices, 'optionalAccess', _77 => _77[0], 'optionalAccess', _78 => _78.finish_reason]);
+    let toolCalls;
+    if (_optionalChain([message, 'optionalAccess', _79 => _79.tool_calls]) && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => {
+        const rawArgs = _optionalChain([tc, 'access', _80 => _80.function, 'optionalAccess', _81 => _81.arguments]);
+        return {
+          id: tc.id,
+          type: "function",
+          function: {
+            name: _nullishCoalesce(_optionalChain([tc, 'access', _82 => _82.function, 'optionalAccess', _83 => _83.name]), () => ( "")),
+            arguments: _nullishCoalesce(rawArgs, () => ( "{}"))
+          }
+        };
+      });
+    }
+    let usage;
+    if (_optionalChain([json, 'optionalAccess', _84 => _84.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 buildApiError(response) {
+    const status = response.status;
+    let errorDetail = "";
+    try {
+      const body = await response.json();
+      errorDetail = _optionalChain([body, 'optionalAccess', _85 => _85.error, 'optionalAccess', _86 => _86.message]) || _optionalChain([body, 'optionalAccess', _87 => _87.error]) || _optionalChain([body, 'optionalAccess', _88 => _88.message]) || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch (e17) {
+      try {
+        errorDetail = await response.text();
+      } catch (e18) {
+      }
+    }
+    return withOpenRouterMessage(_chunk3OF56EMAcjs.classifyApiError.call(void 0, status, errorDetail, response.headers));
+  }
+  isNonRetryableError(error) {
+    if (error instanceof _chunk3OF56EMAcjs.ApiError) {
+      return !error.retryable;
+    }
+    const classified = _chunk3OF56EMAcjs.classifyApiError.call(void 0, 0, error.message);
+    return !classified.retryable;
+  }
+  combineSignals(signal1, signal2) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal1.addEventListener("abort", abort, { once: true });
+    signal2.addEventListener("abort", abort, { once: true });
+    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() {
+    try {
+      const models = await fetchOpenRouterModelCapabilities();
+      const ids = models.map((model) => model.id).filter((id) => Boolean(id));
+      if (ids.length > 0) {
+        return ids;
+      }
+    } catch (e19) {
+    }
+    return [
+      "anthropic/claude-4-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 DEFAULT_TIMEOUT3 = 6e4;
+var DEFAULT_MAX_RETRIES3 = 2;
+var MAX_ALLOWED_RETRIES3 = 5;
+var DEFAULT_RETRY_DELAY3 = 1e3;
+var AVAILABILITY_TIMEOUT2 = 5e3;
+var MLXProvider = class {
+  
+  
+  
+  
+  
+  constructor(config, networkSettings) {
+    const port = config.port || 8080;
+    this.baseUrl = config.baseUrl || `http://localhost:${port}`;
+    this.model = config.model || "mlx-model";
+    const configuredRetries = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _89 => _89.maxRetries]), () => ( DEFAULT_MAX_RETRIES3));
+    this.maxRetries = Math.min(Math.max(0, configuredRetries), MAX_ALLOWED_RETRIES3);
+    this.retryDelay = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _90 => _90.retryDelay]), () => ( DEFAULT_RETRY_DELAY3));
+    this.timeout = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _91 => _91.timeout]), () => ( DEFAULT_TIMEOUT3));
+  }
+  getName() {
+    return "mlx";
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  async listModels() {
+    if (!isMLXSupported()) {
+      return [];
+    }
+    try {
+      const controller = new AbortController();
+      const timerId = setTimeout(() => controller.abort(), AVAILABILITY_TIMEOUT2);
+      try {
+        const response = await fetch(`${this.baseUrl}/v1/models`, {
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          return this.model ? [this.model] : [];
+        }
+        const data = await response.json();
+        return _nullishCoalesce(_optionalChain([data, 'access', _92 => _92.data, 'optionalAccess', _93 => _93.map, 'call', _94 => _94((m) => m.id)]), () => ( (this.model ? [this.model] : [])));
+      } finally {
+        clearTimeout(timerId);
+      }
+    } catch (e20) {
+      return this.model ? [this.model] : [];
+    }
+  }
+  async isAvailable() {
+    if (!isMLXSupported()) {
+      return false;
+    }
+    try {
+      const controller = new AbortController();
+      const timerId = setTimeout(() => controller.abort(), AVAILABILITY_TIMEOUT2);
+      try {
+        const response = await fetch(`${this.baseUrl}/v1/models`, {
+          signal: controller.signal
+        });
+        return response.ok;
+      } finally {
+        clearTimeout(timerId);
+      }
+    } catch (e21) {
+      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: {} }))
+        }
+      }));
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await this.makeRequest(body, request.signal);
+      } 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 (0, _chunk3OF56EMAcjs.ApiError)(
+      "Failed to communicate with the MLX server. Please try again.",
+      "network_error",
+      0,
+      true
+    )));
+  }
+  async makeRequest(body, userSignal) {
+    let response;
+    try {
+      const timeoutController = new AbortController();
+      const timerId = setTimeout(() => timeoutController.abort(), this.timeout);
+      const combinedSignal = userSignal ? this.combineSignals(userSignal, timeoutController.signal) : timeoutController.signal;
+      try {
+        response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(body),
+          signal: combinedSignal
+        });
+      } finally {
+        clearTimeout(timerId);
+      }
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && _optionalChain([userSignal, 'optionalAccess', _95 => _95.aborted])) {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)(
+          `MLX server request timed out after ${this.timeout / 1e3}s. Local inference can be slow \u2014 consider increasing the timeout in your config.`,
+          "timeout",
+          0,
+          true
+        );
+      }
+      throw new (0, _chunk3OF56EMAcjs.ApiError)(
+        `Cannot connect to MLX server at ${this.baseUrl}. Make sure it is running.`,
+        "network_error",
+        0,
+        true
+      );
+    }
+    if (!response.ok) {
+      throw await this.buildApiError(response);
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch (e22) {
+      let rawBody = "";
+      try {
+        rawBody = await response.text();
+      } catch (e23) {
+      }
+      throw new (0, _chunk3OF56EMAcjs.ApiError)(
+        `MLX server returned an invalid response. The model may have crashed or returned malformed output. Raw: ${rawBody.slice(0, 500)}`,
+        "invalid_request",
+        response.status,
+        false
+      );
+    }
+    const choice = data.choices[0];
+    let toolCalls;
+    if (_optionalChain([choice, 'optionalAccess', _96 => _96.message, 'access', _97 => _97.tool_calls, 'optionalAccess', _98 => _98.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', _99 => _99.length]) ? "tool_calls" : _optionalChain([choice, 'optionalAccess', _100 => _100.finish_reason]) === "stop" || _optionalChain([choice, 'optionalAccess', _101 => _101.finish_reason]) === "length" || _optionalChain([choice, 'optionalAccess', _102 => _102.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', _103 => _103.message, 'access', _104 => _104.content]), () => ( "")),
+      toolCalls,
+      finishReason,
+      usage,
+      raw: data
+    };
+  }
+  async buildApiError(response) {
+    let errorDetail = "";
+    try {
+      const body = await response.json();
+      const maybeError = _optionalChain([body, 'optionalAccess', _105 => _105.error]);
+      if (maybeError && typeof maybeError === "object") {
+        errorDetail = _nullishCoalesce(_optionalChain([maybeError, 'optionalAccess', _106 => _106.message]), () => ( ""));
+      } else if (typeof maybeError === "string") {
+        errorDetail = maybeError;
+      } else if (typeof _optionalChain([body, 'optionalAccess', _107 => _107.message]) === "string") {
+        errorDetail = body.message;
+      }
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch (e24) {
+      try {
+        errorDetail = await response.text();
+      } catch (e25) {
+      }
+    }
+    return _chunk3OF56EMAcjs.classifyApiError.call(void 0, response.status, errorDetail, response.headers);
+  }
+  isNonRetryableError(error) {
+    if (error instanceof _chunk3OF56EMAcjs.ApiError) {
+      return !error.retryable;
+    }
+    const classified = _chunk3OF56EMAcjs.classifyApiError.call(void 0, 0, error.message);
+    return !classified.retryable;
+  }
+  combineSignals(signal1, signal2) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    signal1.addEventListener("abort", abort, { once: true });
+    signal2.addEventListener("abort", abort, { once: true });
+    if (signal1.aborted || signal2.aborted) {
+      controller.abort();
+    }
+    return controller.signal;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// 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', _108 => _108.tool_calls, 'optionalAccess', _109 => _109.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_RETRIES4 = 3;
+var MAX_ALLOWED_RETRIES4 = 5;
+var DEFAULT_RETRY_DELAY4 = 1e3;
+var DEFAULT_TIMEOUT4 = 3e4;
+var DEFAULT_ERROR_LABELS = {
+  serviceName: "LLM Gateway",
+  credentialName: "LLM Gateway API key",
+  accountName: "LLM Gateway account"
+};
+function buildFriendlyErrors(labels) {
+  return {
+    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 ${labels.credentialName} in ~/.autohand/config.json.`,
+    402: `Payment required. Please check your ${labels.accountName} balance or billing settings.`,
+    403: `Access denied. Your ${labels.credentialName} 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 ${labels.serviceName} service encountered an internal error. Please try again later.`,
+    502: `The ${labels.serviceName} service is temporarily unavailable. Please try again in a few moments.`,
+    503: `The ${labels.serviceName} service is currently overloaded. Please try again later.`,
+    504: `The request timed out. The ${labels.serviceName} service may be experiencing high load.`
+  };
+}
+var LLMGatewayClient = class {
+  
+  
+  
+  
+  
+  
+  
+  constructor(settings, networkSettings, errorLabels = DEFAULT_ERROR_LABELS) {
+    this.apiKey = _nullishCoalesce(settings.apiKey, () => ( ""));
+    this.baseUrl = _nullishCoalesce(settings.baseUrl, () => ( DEFAULT_BASE_URL2));
+    this.defaultModel = settings.model;
+    this.errorLabels = errorLabels;
+    const configuredRetries = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _110 => _110.maxRetries]), () => ( DEFAULT_MAX_RETRIES4));
+    this.maxRetries = Math.min(
+      Math.max(0, configuredRetries),
+      MAX_ALLOWED_RETRIES4
+    );
+    this.retryDelay = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _111 => _111.retryDelay]), () => ( DEFAULT_RETRY_DELAY4));
+    this.timeout = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _112 => _112.timeout]), () => ( DEFAULT_TIMEOUT4));
+  }
+  setDefaultModel(model) {
+    this.defaultModel = model;
+  }
+  async complete(request) {
+    const payload = this.buildPayload(request);
+    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;
+      }
+    }
+    if (request.chatTemplateKwargs) {
+      payload.extra_body = {
+        chat_template_kwargs: this.buildChatTemplateKwargs(request.chatTemplateKwargs)
+      };
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "x-source": "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,
+          _nullishCoalesce(request.stream, () => ( false))
+        );
+        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.")));
+  }
+  buildPayload(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))
+    };
+    return payload;
+  }
+  buildChatTemplateKwargs(kwargs) {
+    const result = {};
+    if (kwargs.thinking !== void 0) result.thinking = kwargs.thinking;
+    if (kwargs.enable_thinking !== void 0) result.enable_thinking = kwargs.enable_thinking;
+    if (kwargs.reasoning_effort !== void 0) result.reasoning_effort = kwargs.reasoning_effort;
+    if (kwargs.clear_thinking !== void 0) result.clear_thinking = kwargs.clear_thinking;
+    return result;
+  }
+  async makeRequest(payload, headers, signal, preSerializedBody, isStreaming = false) {
+    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', _113 => _113.aborted])) {
+        throw new Error("Request cancelled.");
+      }
+      if (err.name === "AbortError") {
+        throw new Error(
+          `Request timed out. The ${this.errorLabels.serviceName} service may be experiencing high load.`
+        );
+      }
+      throw new Error(
+        `Unable to connect to ${this.errorLabels.serviceName}. Please check your internet connection.`
+      );
+    }
+    if (!response.ok) {
+      throw new Error(await this.buildFriendlyError(response));
+    }
+    if (isStreaming) {
+      return this.handleStreamingResponse(response);
+    }
+    const json = await response.json();
+    const message = _optionalChain([json, 'optionalAccess', _114 => _114.choices, 'optionalAccess', _115 => _115[0], 'optionalAccess', _116 => _116.message]);
+    const text = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _117 => _117.content]), () => ( ""));
+    const finishReason = _optionalChain([json, 'optionalAccess', _118 => _118.choices, 'optionalAccess', _119 => _119[0], 'optionalAccess', _120 => _120.finish_reason]);
+    let toolCalls;
+    if (_optionalChain([message, 'optionalAccess', _121 => _121.tool_calls]) && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => {
+        const rawArgs = _optionalChain([tc, 'access', _122 => _122.function, 'optionalAccess', _123 => _123.arguments]);
+        return {
+          id: tc.id,
+          type: "function",
+          function: {
+            name: _nullishCoalesce(_optionalChain([tc, 'access', _124 => _124.function, 'optionalAccess', _125 => _125.name]), () => ( "")),
+            arguments: _nullishCoalesce(rawArgs, () => ( "{}"))
+          }
+        };
+      });
+    }
+    let usage;
+    if (_optionalChain([json, 'optionalAccess', _126 => _126.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 handleStreamingResponse(response) {
+    const reader = _optionalChain([response, 'access', _127 => _127.body, 'optionalAccess', _128 => _128.getReader, 'call', _129 => _129()]);
+    if (!reader) {
+      throw new Error("No response body for streaming");
+    }
+    const decoder = new TextDecoder();
+    let fullContent = "";
+    let fullReasoning = "";
+    let lastChunk = null;
+    let finishReason = "stop";
+    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) {
+          if (line.startsWith("data: ")) {
+            const dataStr = line.slice(6).trim();
+            if (dataStr === "[DONE]") continue;
+            try {
+              const data = JSON.parse(dataStr);
+              lastChunk = data;
+              const delta = _optionalChain([data, 'access', _130 => _130.choices, 'optionalAccess', _131 => _131[0], 'optionalAccess', _132 => _132.delta]);
+              if (!delta) continue;
+              const reasoning = delta.reasoning || delta.reasoning_content;
+              if (reasoning) {
+                fullReasoning += reasoning;
+              }
+              if (delta.content) {
+                fullContent += delta.content;
+              }
+              if (_optionalChain([data, 'access', _133 => _133.choices, 'optionalAccess', _134 => _134[0], 'optionalAccess', _135 => _135.finish_reason])) {
+                finishReason = data.choices[0].finish_reason;
+              }
+            } catch (e26) {
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const finalContent = fullReasoning ? `<thinking>${fullReasoning}</thinking>
+
+${fullContent}` : fullContent;
+    return {
+      id: _nullishCoalesce(_optionalChain([lastChunk, 'optionalAccess', _136 => _136.id]), () => ( `llmgateway-stream-${Date.now()}`)),
+      created: _nullishCoalesce(_optionalChain([lastChunk, 'optionalAccess', _137 => _137.created]), () => ( Math.floor(Date.now() / 1e3))),
+      content: finalContent,
+      finishReason,
+      raw: { content: fullContent, reasoning: fullReasoning, chunks: lastChunk }
+    };
+  }
+  async buildFriendlyError(response) {
+    const status = response.status;
+    let errorDetail = "";
+    try {
+      const body = await response.json();
+      errorDetail = _optionalChain([body, 'optionalAccess', _138 => _138.error, 'optionalAccess', _139 => _139.message]) || _optionalChain([body, 'optionalAccess', _140 => _140.error]) || _optionalChain([body, 'optionalAccess', _141 => _141.message]) || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch (e27) {
+      try {
+        errorDetail = await response.text();
+      } catch (e28) {
+      }
+    }
+    const friendlyMessage = buildFriendlyErrors(this.errorLabels)[status];
+    if (friendlyMessage) {
+      return errorDetail ? `${friendlyMessage}
+${errorDetail}` : friendlyMessage;
+    }
+    if (status >= 500) {
+      const base = `The ${this.errorLabels.serviceName} 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/azure/tokenManager.ts
+var EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
+var IMDS_ENDPOINT = "http://169.254.169.254/metadata/identity/oauth2/token";
+var COGNITIVE_SCOPE = "https://cognitiveservices.azure.com/.default";
+var AzureTokenManager = (_class3 = class {constructor() { _class3.prototype.__init2.call(this); }
+  __init2() {this.cache = null}
+  async getToken(request) {
+    if (request.authMethod === "api-key") {
+      if (!request.apiKey) {
+        throw new Error("API key is required for api-key authentication.");
+      }
+      return request.apiKey;
+    }
+    if (this.cache && !this.isTokenExpired()) {
+      return this.cache.token;
+    }
+    if (request.authMethod === "entra-id") {
+      return this.acquireEntraIdToken(request);
+    }
+    if (request.authMethod === "managed-identity") {
+      return this.acquireManagedIdentityToken();
+    }
+    throw new Error(`Unsupported auth method: ${request.authMethod}`);
+  }
+  async getAuthHeaders(request) {
+    if (request.authMethod === "api-key") {
+      const key = await this.getToken(request);
+      return { "api-key": key };
+    }
+    const token = await this.getToken(request);
+    return { Authorization: `Bearer ${token}` };
+  }
+  async acquireEntraIdToken(request) {
+    if (!request.tenantId) {
+      throw new Error("tenantId is required for Entra ID authentication.");
+    }
+    if (!request.clientId) {
+      throw new Error("clientId is required for Entra ID authentication.");
+    }
+    if (!request.clientSecret) {
+      throw new Error("clientSecret is required for Entra ID authentication.");
+    }
+    const url = `https://login.microsoftonline.com/${request.tenantId}/oauth2/v2.0/token`;
+    const body = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: request.clientId,
+      client_secret: request.clientSecret,
+      scope: COGNITIVE_SCOPE
+    });
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      const description = error.error_description || error.error || `HTTP ${response.status}`;
+      throw new Error(`Entra ID authentication failed: ${description}`);
+    }
+    const data = await response.json();
+    this.cacheToken(data.access_token, data.expires_in);
+    return data.access_token;
+  }
+  async acquireManagedIdentityToken() {
+    const url = `${IMDS_ENDPOINT}?api-version=2018-02-01&resource=https://cognitiveservices.azure.com`;
+    let response;
+    try {
+      response = await fetch(url, {
+        headers: { Metadata: "true" }
+      });
+    } catch (e29) {
+      throw new Error(
+        "Managed Identity token acquisition failed. This auth method only works inside Azure VMs, App Service, or containers with managed identity enabled."
+      );
+    }
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(
+        `Managed Identity token error (${response.status}): ${error.error_description || error.error || "Unknown"}`
+      );
+    }
+    const data = await response.json();
+    this.cacheToken(data.access_token, data.expires_in);
+    return data.access_token;
+  }
+  cacheToken(token, expiresInSeconds) {
+    this.cache = {
+      token,
+      expiresAt: Date.now() + expiresInSeconds * 1e3
+    };
+  }
+  isTokenExpired() {
+    if (!this.cache) return true;
+    return Date.now() >= this.cache.expiresAt - EXPIRY_BUFFER_MS;
+  }
+}, _class3);
+
+// src/providers/AzureClient.ts
+function sanitizeMessages3(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', _142 => _142.tool_calls, 'optionalAccess', _143 => _143.length])) {
+      sanitized.tool_calls = msg.tool_calls;
+    }
+    if (msg.name) {
+      sanitized.name = msg.name;
+    }
+    return sanitized;
+  });
+}
+var DEFAULT_API_VERSION = "2024-10-21";
+var DEFAULT_MAX_RETRIES5 = 3;
+var MAX_ALLOWED_RETRIES5 = 5;
+var DEFAULT_RETRY_DELAY5 = 1e3;
+var DEFAULT_TIMEOUT5 = 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 Azure API key or credentials in ~/.autohand/config.json.",
+  402: "Payment required. Please check your Azure subscription and billing settings.",
+  403: "Access denied. Your credentials may not have permission for this Azure deployment.",
+  404: "The Azure deployment was not found. Verify your resourceName and deploymentName in ~/.autohand/config.json.",
+  429: "Rate limit exceeded. Please wait a moment and try again, or adjust your Azure deployment capacity.",
+  500: "Azure OpenAI encountered an internal error. Please try again later.",
+  502: "Azure OpenAI is temporarily unavailable. Please try again in a few moments.",
+  503: "Azure OpenAI is currently overloaded. Please try again later.",
+  504: "The request timed out. Azure OpenAI may be experiencing high load."
+};
+var AzureClient = class {
+  
+  
+  
+  
+  
+  
+  constructor(options, networkSettings) {
+    this.options = options;
+    this.tokenManager = new AzureTokenManager();
+    this.defaultModel = options.model;
+    const configuredRetries = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _144 => _144.maxRetries]), () => ( DEFAULT_MAX_RETRIES5));
+    this.maxRetries = Math.min(
+      Math.max(0, configuredRetries),
+      MAX_ALLOWED_RETRIES5
+    );
+    this.retryDelay = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _145 => _145.retryDelay]), () => ( DEFAULT_RETRY_DELAY5));
+    this.timeout = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _146 => _146.timeout]), () => ( DEFAULT_TIMEOUT5));
+  }
+  setDefaultModel(model) {
+    this.defaultModel = model;
+  }
+  /**
+   * Build the full Azure OpenAI endpoint URL.
+   *
+   * If baseUrl is provided:
+   *   {baseUrl}/chat/completions?api-version={apiVersion}
+   *
+   * If resourceName is a full URL (starts with https://):
+   *   {origin}/openai/deployments/{deploymentName}/chat/completions?api-version={apiVersion}
+   *   Supports all Azure endpoint domains:
+   *     - *.openai.azure.com (Azure OpenAI)
+   *     - *.services.ai.azure.com (Microsoft Foundry)
+   *     - *.cognitiveservices.azure.com (Azure AI Services)
+   *
+   * Otherwise, from resourceName + deploymentName:
+   *   https://{resourceName}.openai.azure.com/openai/deployments/{deploymentName}/chat/completions?api-version={apiVersion}
+   */
+  buildEndpointUrl() {
+    const apiVersion = _nullishCoalesce(this.options.apiVersion, () => ( DEFAULT_API_VERSION));
+    if (this.options.baseUrl) {
+      return `${this.options.baseUrl}/chat/completions?api-version=${apiVersion}`;
+    }
+    const { resourceName, deploymentName } = this.options;
+    if (!resourceName || !deploymentName) {
+      throw new Error(
+        "Azure OpenAI requires either baseUrl or both resourceName and deploymentName in ~/.autohand/config.json."
+      );
+    }
+    if (resourceName.startsWith("http://") || resourceName.startsWith("https://")) {
+      try {
+        const parsed = new URL(resourceName);
+        return `${parsed.origin}/openai/deployments/${deploymentName}/chat/completions?api-version=${apiVersion}`;
+      } catch (e30) {
+      }
+    }
+    return `https://${resourceName}.openai.azure.com/openai/deployments/${deploymentName}/chat/completions?api-version=${apiVersion}`;
+  }
+  async complete(request) {
+    const payload = {
+      messages: sanitizeMessages3(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 authHeaders = await this.tokenManager.getAuthHeaders({
+      authMethod: this.options.authMethod,
+      apiKey: this.options.apiKey,
+      tenantId: this.options.tenantId,
+      clientId: this.options.clientId,
+      clientSecret: this.options.clientSecret
+    });
+    const headers = {
+      "Content-Type": "application/json",
+      ...authHeaders
+    };
+    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 Azure OpenAI. Please try again."
+    )));
+  }
+  async makeRequest(payload, headers, signal, preSerializedBody) {
+    let response;
+    const url = this.buildEndpointUrl();
+    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(url, {
+          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', _147 => _147.aborted])) {
+        throw new Error("Request cancelled.");
+      }
+      if (err.name === "AbortError") {
+        throw new Error(
+          "Request timed out. Azure OpenAI may be experiencing high load."
+        );
+      }
+      throw new Error(
+        "Unable to connect to Azure OpenAI. Please check your internet connection and Azure configuration."
+      );
+    }
+    if (!response.ok) {
+      throw new Error(await this.buildFriendlyError(response));
+    }
+    const json = await response.json();
+    const message = _optionalChain([json, 'optionalAccess', _148 => _148.choices, 'optionalAccess', _149 => _149[0], 'optionalAccess', _150 => _150.message]);
+    const text = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _151 => _151.content]), () => ( ""));
+    const finishReason = _optionalChain([json, 'optionalAccess', _152 => _152.choices, 'optionalAccess', _153 => _153[0], 'optionalAccess', _154 => _154.finish_reason]);
+    let toolCalls;
+    if (_optionalChain([message, 'optionalAccess', _155 => _155.tool_calls]) && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => {
+        const rawArgs = _optionalChain([tc, 'access', _156 => _156.function, 'optionalAccess', _157 => _157.arguments]);
+        return {
+          id: tc.id,
+          type: "function",
+          function: {
+            name: _nullishCoalesce(_optionalChain([tc, 'access', _158 => _158.function, 'optionalAccess', _159 => _159.name]), () => ( "")),
+            arguments: _nullishCoalesce(rawArgs, () => ( "{}"))
+          }
+        };
+      });
+    }
+    let usage;
+    if (_optionalChain([json, 'optionalAccess', _160 => _160.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-azure")),
+      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', _161 => _161.error, 'optionalAccess', _162 => _162.message]) || _optionalChain([body, 'optionalAccess', _163 => _163.error]) || _optionalChain([body, 'optionalAccess', _164 => _164.message]) || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch (e31) {
+      try {
+        errorDetail = await response.text();
+      } catch (e32) {
+      }
+    }
+    const friendlyMessage = FRIENDLY_ERRORS[status];
+    if (friendlyMessage) {
+      return errorDetail ? `${friendlyMessage}
+${errorDetail}` : friendlyMessage;
+    }
+    if (status >= 500) {
+      const base = "Azure OpenAI is temporarily unavailable. Please try again later.";
+      return errorDetail ? `${base}
+(${status}: ${errorDetail})` : base;
+    }
+    if (status >= 400) {
+      const base = "The request could not be processed by Azure OpenAI.";
+      return errorDetail ? `${base} (${status}: ${errorDetail})` : `${base} (HTTP ${status}) Please try again or adjust your prompt.`;
+    }
+    return errorDetail ? `An unexpected Azure OpenAI error occurred: ${errorDetail}` : "An unexpected Azure OpenAI 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/AzureProvider.ts
+var AzureProvider = class {
+  
+  
+  constructor(config, networkSettings) {
+    this.client = new AzureClient(
+      {
+        model: config.model,
+        resourceName: config.resourceName,
+        deploymentName: config.deploymentName,
+        baseUrl: config.baseUrl,
+        apiVersion: config.apiVersion,
+        apiKey: config.apiKey,
+        authMethod: _nullishCoalesce(config.authMethod, () => ( "api-key")),
+        tenantId: config.tenantId,
+        clientId: config.clientId,
+        clientSecret: config.clientSecret
+      },
+      networkSettings
+    );
+    this.model = config.model;
+  }
+  getName() {
+    return "azure";
+  }
+  setModel(model) {
+    this.model = model;
+    this.client.setDefaultModel(model);
+  }
+  async listModels() {
+    return ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo"];
+  }
+  async isAvailable() {
+    return true;
+  }
+  async complete(request) {
+    return this.client.complete(request);
+  }
+};
+
+// src/providers/ZaiProvider.ts
+var ZAI_DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4";
+var ZAI_MODELS = [
+  "glm-4.5",
+  "glm-4.5v",
+  "glm-4.5-air",
+  "glm-4.5-prior",
+  "glm-4.5-flash",
+  "glm-4.5-air-2504",
+  "cogview-4.5"
+];
+var ZaiProvider = class {
+  
+  
+  constructor(config, networkSettings) {
+    const effectiveConfig = {
+      ...config,
+      baseUrl: _nullishCoalesce(config.baseUrl, () => ( ZAI_DEFAULT_BASE_URL))
+    };
+    this.client = new LLMGatewayClient(effectiveConfig, networkSettings, {
+      serviceName: "Z.ai",
+      credentialName: "Z.ai API key",
+      accountName: "Z.ai account"
+    });
+    this.model = config.model;
+  }
+  getName() {
+    return "zai";
+  }
+  setModel(model) {
+    this.model = model;
+    this.client.setDefaultModel(model);
+  }
+  async listModels() {
+    return [...ZAI_MODELS];
+  }
+  async isAvailable() {
+    return true;
+  }
+  async complete(request) {
+    return this.client.complete(request);
+  }
+};
+
+// src/utils/gcloudAuth.ts
+var _child_process = require('child_process');
+var _util = require('util');
+var execAsync = _util.promisify.call(void 0, _child_process.exec);
+var tokenCache = null;
+async function isGcloudInstalled() {
+  try {
+    await execAsync("gcloud --version", { timeout: 5e3 });
+    return true;
+  } catch (e33) {
+    return false;
+  }
+}
+async function getGcloudProject() {
+  try {
+    const { stdout } = await execAsync("gcloud config get-value project", { timeout: 5e3 });
+    const project = stdout.trim();
+    return project && project !== "(unset)" ? project : null;
+  } catch (e34) {
+    return null;
+  }
+}
+async function getGcloudAccessToken() {
+  if (tokenCache && Date.now() < tokenCache.expiresAt) {
+    return { token: tokenCache.token };
+  }
+  try {
+    const { stdout } = await execAsync("gcloud auth print-access-token", { timeout: 1e4 });
+    const token = stdout.trim();
+    if (!token || token.length < 10) {
+      return { token: "", error: "Failed to get access token. You may need to run: gcloud auth login" };
+    }
+    tokenCache = {
+      token,
+      expiresAt: Date.now() + 25 * 60 * 1e3
+      // 25 minutes
+    };
+    return { token };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("not found") || errorMessage.includes("command not found")) {
+      return {
+        token: "",
+        error: "gcloud CLI not found. Install it from: https://cloud.google.com/sdk/docs/install"
+      };
+    }
+    if (errorMessage.includes("Could not determine account")) {
+      return {
+        token: "",
+        error: "Not logged in. Run: gcloud auth login"
+      };
+    }
+    return {
+      token: "",
+      error: `Failed to get access token: ${errorMessage}`
+    };
+  }
+}
+function clearGcloudTokenCache() {
+  tokenCache = null;
+}
+async function getGcloudAccount() {
+  try {
+    const { stdout } = await execAsync("gcloud auth list --format=value(account)", { timeout: 5e3 });
+    const account = stdout.trim().split("\n")[0];
+    return account || null;
+  } catch (e35) {
+    return null;
+  }
+}
+
+// src/providers/VertexAIProvider.ts
+function sanitizeMessages4(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', _165 => _165.tool_calls, 'optionalAccess', _166 => _166.length])) {
+      sanitized.tool_calls = msg.tool_calls;
+    }
+    if (msg.name) {
+      sanitized.name = msg.name;
+    }
+    return sanitized;
+  });
+}
+var DEFAULT_ENDPOINT = "aiplatform.googleapis.com";
+var DEFAULT_REGION = "global";
+var DEFAULT_MAX_RETRIES6 = 3;
+var MAX_ALLOWED_RETRIES6 = 5;
+var DEFAULT_RETRY_DELAY6 = 1e3;
+var DEFAULT_TIMEOUT6 = 3e4;
+var VERTEX_AI_FRIENDLY_MESSAGES = {
+  auth_failed: "Authentication failed. Please verify your Google Cloud Vertex AI auth token in ~/.autohand/config.json. If it came from gcloud, refresh it with `gcloud auth print-access-token`.",
+  payment_required: "Payment required. Please check billing for the Google Cloud project configured for Vertex AI.",
+  access_denied: "Access denied. Your Google Cloud credentials may not have permission to use Vertex AI or this model.",
+  server_error: "The Google Cloud Vertex AI service encountered an error. Please try again later.",
+  network_error: "Unable to connect to Google Cloud Vertex AI. Please check your internet connection and Vertex AI endpoint.",
+  timeout: "The request timed out. The Google Cloud Vertex AI service may be experiencing high load."
+};
+function withVertexAIMessage(error) {
+  const friendlyMessage = VERTEX_AI_FRIENDLY_MESSAGES[error.code];
+  if (!friendlyMessage) {
+    return error;
+  }
+  return new (0, _chunk3OF56EMAcjs.ApiError)(
+    error.rawDetail ? `${friendlyMessage}
+${error.rawDetail}` : friendlyMessage,
+    error.code,
+    error.httpStatus,
+    error.retryable,
+    error.retryAfterMs,
+    error.rawDetail
+  );
+}
+var ANTHROPIC_MODELS = [
+  "claude-3-opus",
+  "claude-3-sonnet",
+  "claude-3-haiku",
+  "claude-3-5-sonnet",
+  "claude-3-5-haiku",
+  "claude-3.5-sonnet",
+  "claude-3.5-haiku",
+  "claude-4",
+  "claude-sonnet-4",
+  "claude-opus-4",
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  "claude-opus-4.7",
+  "claude-opus-4.6"
+];
+var VERTEX_AI_CODING_MODELS = [
+  // Anthropic Claude (coding-optimized)
+  "anthropic/claude-opus-4-7",
+  "anthropic/claude-opus-4-6",
+  "anthropic/claude-opus-4",
+  "anthropic/claude-sonnet-4",
+  "anthropic/claude-3-5-sonnet",
+  "anthropic/claude-3-opus",
+  "anthropic/claude-3-haiku",
+  // Google Gemini (coding-capable)
+  "google/gemini-3.1-pro",
+  "google/gemini-3.1-flash",
+  "google/gemini-1.5-pro",
+  "google/gemini-1.5-flash",
+  "google/gemini-1.0-pro",
+  // Z.ai models
+  "zai-org/glm-5-maas"
+];
+function isAnthropicModel(model) {
+  const lowerModel = model.toLowerCase();
+  return ANTHROPIC_MODELS.some((m) => lowerModel.includes(m.toLowerCase()));
+}
+function extractAnthropicModelId(model) {
+  const lowerModel = model.toLowerCase();
+  if (lowerModel.startsWith("anthropic/")) {
+    return model.substring("anthropic/".length);
+  }
+  return model;
+}
+var VertexAIProvider = class {
+  
+  // Changed from readonly to allow refresh
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  // Auto-refresh via gcloud CLI
+  constructor(settings, networkSettings) {
+    this.authToken = settings.authToken;
+    this.endpoint = _nullishCoalesce(settings.endpoint, () => ( DEFAULT_ENDPOINT));
+    this.region = _nullishCoalesce(settings.region, () => ( DEFAULT_REGION));
+    this.projectId = settings.projectId;
+    this.defaultModel = settings.model;
+    this.useGcloudRefresh = this.authToken.startsWith("ya29.") && this.authToken.length > 100;
+    this.baseUrl = `https://${this.endpoint}/v1/projects/${this.projectId}/locations/${this.region}/endpoints/openapi`;
+    const configuredRetries = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _167 => _167.maxRetries]), () => ( DEFAULT_MAX_RETRIES6));
+    this.maxRetries = Math.min(
+      Math.max(0, configuredRetries),
+      MAX_ALLOWED_RETRIES6
+    );
+    this.retryDelay = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _168 => _168.retryDelay]), () => ( DEFAULT_RETRY_DELAY6));
+    this.timeout = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _169 => _169.timeout]), () => ( DEFAULT_TIMEOUT6));
+  }
+  getName() {
+    return "vertexai";
+  }
+  setModel(model) {
+    this.defaultModel = model;
+  }
+  async listModels() {
+    return [...VERTEX_AI_CODING_MODELS];
+  }
+  async isAvailable() {
+    try {
+      const token = await this.getValidToken();
+      const response = await fetch(`${this.baseUrl}/models`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`
+        },
+        signal: AbortSignal.timeout(5e3)
+      });
+      return response.ok;
+    } catch (e36) {
+      return false;
+    }
+  }
+  /**
+   * Get a valid auth token, refreshing from gcloud if needed
+   */
+  async getValidToken() {
+    if (this.useGcloudRefresh) {
+      const result = await getGcloudAccessToken();
+      if (result.token) {
+        this.authToken = result.token;
+        return this.authToken;
+      }
+    }
+    return this.authToken;
+  }
+  /**
+   * Refresh the token after an auth error
+   */
+  async refreshToken() {
+    if (!this.useGcloudRefresh) {
+      return false;
+    }
+    clearGcloudTokenCache();
+    const result = await getGcloudAccessToken();
+    if (result.token) {
+      this.authToken = result.token;
+      return true;
+    }
+    return false;
+  }
+  async complete(request) {
+    const model = _nullishCoalesce(request.model, () => ( this.defaultModel));
+    const isAnthropic = isAnthropicModel(model);
+    let payload;
+    let url;
+    if (isAnthropic) {
+      const modelId = extractAnthropicModelId(model);
+      url = `https://${this.endpoint}/v1/projects/${this.projectId}/locations/${this.region}/publishers/anthropic/models/${modelId}:streamRawPredict`;
+      payload = {
+        anthropic_version: "vertex-2023-10-16",
+        messages: sanitizeMessages4(request.messages),
+        max_tokens: _nullishCoalesce(request.maxTokens, () => ( 16e3)),
+        stream: _nullishCoalesce(request.stream, () => ( false))
+      };
+      if (request.temperature !== void 0) {
+        payload.temperature = request.temperature;
+      }
+      if (request.tools && request.tools.length > 0) {
+        payload.tools = request.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          input_schema: _nullishCoalesce(tool.parameters, () => ( { type: "object", properties: {} }))
+        }));
+      }
+    } else {
+      payload = {
+        model,
+        messages: sanitizeMessages4(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;
+        }
+      }
+      url = `${this.baseUrl}/chat/completions`;
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${await this.getValidToken()}`
+    };
+    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 (0, _chunk3OF56EMAcjs.ApiError)(
+        `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.`,
+        "context_overflow",
+        400,
+        false
+      );
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await this.makeRequest(
+          url,
+          payload,
+          headers,
+          request.signal,
+          payloadJson,
+          isAnthropic
+        );
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (this.isAuthError(error) && await this.refreshToken()) {
+          headers.Authorization = `Bearer ${this.authToken}`;
+          continue;
+        }
+        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 Vertex AI. Please try again.")));
+  }
+  async makeRequest(url, payload, headers, signal, preSerializedBody, isAnthropic = false) {
+    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(url, {
+          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', _170 => _170.aborted])) {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)(
+          "Request timed out. The Vertex AI service may be experiencing high load.",
+          "timeout",
+          504,
+          true
+        );
+      }
+      const classified = _chunk3OF56EMAcjs.classifyApiError.call(void 0, 0, err.message);
+      throw withVertexAIMessage(classified);
+    }
+    if (!response.ok) {
+      throw await this.buildFriendlyError(response);
+    }
+    const json = await response.json();
+    if (isAnthropic) {
+      return this.parseAnthropicResponse(json);
+    }
+    const message = _optionalChain([json, 'optionalAccess', _171 => _171.choices, 'optionalAccess', _172 => _172[0], 'optionalAccess', _173 => _173.message]);
+    const text = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _174 => _174.content]), () => ( ""));
+    const finishReason = _optionalChain([json, 'optionalAccess', _175 => _175.choices, 'optionalAccess', _176 => _176[0], 'optionalAccess', _177 => _177.finish_reason]);
+    let toolCalls;
+    if (_optionalChain([message, 'optionalAccess', _178 => _178.tool_calls]) && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => {
+        const rawArgs = _optionalChain([tc, 'access', _179 => _179.function, 'optionalAccess', _180 => _180.arguments]);
+        return {
+          id: tc.id,
+          type: "function",
+          function: {
+            name: _nullishCoalesce(_optionalChain([tc, 'access', _181 => _181.function, 'optionalAccess', _182 => _182.name]), () => ( "")),
+            arguments: _nullishCoalesce(rawArgs, () => ( "{}"))
+          }
+        };
+      });
+    }
+    let usage;
+    if (_optionalChain([json, 'optionalAccess', _183 => _183.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, () => ( "vertexai-response")),
+      created: _nullishCoalesce(json.created, () => ( Date.now())),
+      content: text,
+      toolCalls,
+      finishReason,
+      usage,
+      raw: json
+    };
+  }
+  /**
+   * Parse Anthropic API response format
+   */
+  parseAnthropicResponse(json) {
+    const contentBlocks = _nullishCoalesce(_optionalChain([json, 'optionalAccess', _184 => _184.content]), () => ( []));
+    const textBlock = contentBlocks.find((b) => b.type === "text");
+    const text = _nullishCoalesce(_optionalChain([textBlock, 'optionalAccess', _185 => _185.text]), () => ( ""));
+    let toolCalls;
+    const toolUseBlocks = contentBlocks.filter((b) => b.type === "tool_use");
+    if (toolUseBlocks.length > 0) {
+      toolCalls = toolUseBlocks.map((block) => ({
+        id: block.id,
+        type: "function",
+        function: {
+          name: _nullishCoalesce(block.name, () => ( "")),
+          arguments: JSON.stringify(_nullishCoalesce(block.input, () => ( {})))
+        }
+      }));
+    }
+    let usage;
+    if (_optionalChain([json, 'optionalAccess', _186 => _186.usage])) {
+      usage = {
+        promptTokens: _nullishCoalesce(json.usage.input_tokens, () => ( 0)),
+        completionTokens: _nullishCoalesce(json.usage.output_tokens, () => ( 0)),
+        totalTokens: (_nullishCoalesce(json.usage.input_tokens, () => ( 0))) + (_nullishCoalesce(json.usage.output_tokens, () => ( 0)))
+      };
+    }
+    const stopReason = _optionalChain([json, 'optionalAccess', _187 => _187.stop_reason]);
+    let finishReason;
+    if (stopReason === "end_turn" || stopReason === "stop_sequence") {
+      finishReason = "stop";
+    } else if (stopReason === "tool_use") {
+      finishReason = "tool_calls";
+    } else if (stopReason === "max_tokens") {
+      finishReason = "length";
+    }
+    return {
+      id: _nullishCoalesce(json.id, () => ( "vertexai-anthropic-response")),
+      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', _188 => _188.error, 'optionalAccess', _189 => _189.message]) || _optionalChain([body, 'optionalAccess', _190 => _190.error]) || _optionalChain([body, 'optionalAccess', _191 => _191.message]) || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch (e37) {
+      try {
+        errorDetail = await response.text();
+      } catch (e38) {
+      }
+    }
+    const classified = _chunk3OF56EMAcjs.classifyApiError.call(void 0, status, errorDetail, response.headers);
+    return withVertexAIMessage(classified);
+  }
+  isNonRetryableError(error) {
+    if (error instanceof _chunk3OF56EMAcjs.ApiError) {
+      return !error.retryable;
+    }
+    const message = error.message.toLowerCase();
+    if (message.includes("cancelled") || message.includes("aborted")) {
+      return true;
+    }
+    if (message.includes("authentication") || message.includes("auth token")) {
+      return true;
+    }
+    if (message.includes("payment") || message.includes("access denied")) {
+      return true;
+    }
+    if (message.includes("not found")) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Check if error is an authentication error that can be fixed by refreshing the token
+   */
+  isAuthError(error) {
+    if (error instanceof _chunk3OF56EMAcjs.ApiError) {
+      return error.code === "auth_failed";
+    }
+    const message = error.message.toLowerCase();
+    if (message.includes("401") || message.includes("unauthorized") || message.includes("authentication") || message.includes("auth token") || message.includes("invalid token") || message.includes("token expired")) {
+      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/XAIProvider.ts
+var XAI_MODELS = [
+  "grok-4.20-reasoning",
+  "grok-4-1-fast-reasoning-latest",
+  "grok-4.20-0309-reasoning"
+];
+var XAI_DEFAULT_MODEL = "grok-4.20-reasoning";
+var XAI_API_BASE_URL = "https://api.x.ai/v1";
+var XAI_FRIENDLY_MESSAGES = {
+  auth_failed: "Authentication failed. Please verify your xAI API key in ~/.autohand/config.json.",
+  payment_required: "Payment required. Please check your xAI account balance or billing settings.",
+  access_denied: "Access denied. Your xAI API key may not have permission for this model.",
+  server_error: "The xAI service encountered an error. Please try again later.",
+  network_error: "Unable to connect to xAI. Please check your internet connection and xAI API configuration.",
+  timeout: "The request timed out. The xAI service may be experiencing high load."
+};
+function withXAIMessage(error) {
+  const friendlyMessage = XAI_FRIENDLY_MESSAGES[error.code];
+  if (!friendlyMessage) {
+    return error;
+  }
+  return new (0, _chunk3OF56EMAcjs.ApiError)(
+    error.rawDetail ? `${friendlyMessage}
+${error.rawDetail}` : friendlyMessage,
+    error.code,
+    error.httpStatus,
+    error.retryable,
+    error.retryAfterMs,
+    error.rawDetail
+  );
+}
+var XAIProvider = class {
+  
+  
+  
+  constructor(config) {
+    this.apiKey = config.apiKey || "";
+    this.baseUrl = (config.baseUrl || XAI_API_BASE_URL).replace(/\/$/, "");
+    this.model = config.model || XAI_DEFAULT_MODEL;
+  }
+  getName() {
+    return "xai";
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  /**
+   * List available models from xAI's REST API (GET /v1/language-models),
+   * falling back to the canonical static list.
+   */
+  async listModels() {
+    try {
+      const headers = await this.buildAuthHeaders();
+      const response = await fetch(`${this.baseUrl}/language-models`, { headers });
+      if (response.ok) {
+        const data = await response.json();
+        if (_optionalChain([data, 'optionalAccess', _192 => _192.models]) && Array.isArray(data.models)) {
+          const ids = /* @__PURE__ */ new Set();
+          for (const m of data.models) {
+            if (m.id) ids.add(m.id);
+            if (Array.isArray(m.aliases)) {
+              for (const a of m.aliases) ids.add(a);
+            }
+          }
+          if (ids.size > 0) {
+            return [...ids];
+          }
+        }
+      }
+    } catch (e39) {
+    }
+    return [...XAI_MODELS];
+  }
+  async isAvailable() {
+    if (!this.apiKey) return false;
+    try {
+      const headers = await this.buildAuthHeaders();
+      const response = await fetch(`${this.baseUrl}/models`, { headers });
+      return response.ok;
+    } catch (e40) {
+      return false;
+    }
+  }
+  /**
+   * Complete a chat request using the xAI Responses API.
+   *
+   * xAI supports server-side tools (`web_search`, `x_search`, `code_execution`)
+   * in addition to standard function calling. This implementation detects
+   * tool types and emits the appropriate xAI tool format.
+   */
+  async complete(request) {
+    const body = {
+      model: request.model || this.model,
+      stream: true,
+      tool_choice: "auto",
+      input: this.toXAIInputItems(request.messages)
+    };
+    const tools = this.mapToXAITools(request.tools);
+    if (tools.length > 0) {
+      body.tools = tools;
+    }
+    const headers = await this.buildAuthHeaders();
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}/responses`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify(body),
+        signal: request.signal
+      });
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && _optionalChain([request, 'access', _193 => _193.signal, 'optionalAccess', _194 => _194.aborted])) {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new (0, _chunk3OF56EMAcjs.ApiError)(
+          "The request timed out. The xAI service may be experiencing high load.",
+          "timeout",
+          0,
+          true
+        );
+      }
+      throw new (0, _chunk3OF56EMAcjs.ApiError)(
+        `Unable to connect to ${this.baseUrl}. Please check the URL and your xAI API key.`,
+        "network_error",
+        0,
+        true
+      );
+    }
+    if (!response.ok) {
+      throw await this.buildApiError(response);
+    }
+    const data = await this.parseXAIStream(response);
+    const toolCalls = this.extractXAIToolCalls(data.output);
+    const content = this.extractXAIContent(data);
+    const usage = this.mapXAIUsage(data.usage);
+    return {
+      id: data.id,
+      created: _nullishCoalesce(data.created_at, () => ( Math.floor(Date.now() / 1e3))),
+      content,
+      toolCalls,
+      finishReason: toolCalls.length > 0 ? "tool_calls" : _optionalChain([data, 'access', _195 => _195.incomplete_details, 'optionalAccess', _196 => _196.reason]) === "max_output_tokens" ? "length" : "stop",
+      usage,
+      raw: data
+    };
+  }
+  // ------------------------------------------------------------------
+  // Helpers
+  // ------------------------------------------------------------------
+  async buildAuthHeaders() {
+    return {
+      Authorization: `Bearer ${this.apiKey}`
+    };
+  }
+  // Map the generic LLMRequest.tools (FunctionDefinition[]) to xAI tool payloads.
+  // xAI built-in tools use a simple `{ type: "web_search" }` form.
+  // If the user supplies a custom FunctionDefinition whose name matches a known
+  // server-side tool we emit the server-side variant; everything else becomes a
+  // standard `function` tool.
+  mapToXAITools(tools) {
+    if (!_optionalChain([tools, 'optionalAccess', _197 => _197.length])) return [];
+    return tools.map((tool) => {
+      const name = tool.name.toLowerCase();
+      if (name === "web_search" || name === "x_search" || name === "code_execution" || name === "code_interpreter") {
+        return { type: name === "code_interpreter" ? "code_execution" : name };
+      }
+      return {
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        }
+      };
+    });
+  }
+  // Convert the internal message format to xAI Responses API input items.
+  toXAIInputItems(messages) {
+    const items = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        continue;
+      }
+      if (msg.role === "tool" && msg.tool_call_id && msg.content) {
+        items.push({
+          type: "function_call_output",
+          call_id: msg.tool_call_id,
+          output: msg.content
+        });
+        continue;
+      }
+      if (msg.role === "assistant" && _optionalChain([msg, 'access', _198 => _198.tool_calls, 'optionalAccess', _199 => _199.length])) {
+        items.push({
+          type: "message",
+          role: "assistant",
+          content: []
+          // will have function_calls appended
+        });
+        for (const tc of msg.tool_calls) {
+          items.push({
+            type: "function_call",
+            call_id: tc.id,
+            name: tc.function.name,
+            arguments: tc.function.arguments
+          });
+        }
+        continue;
+      }
+      if (msg.content && typeof msg.content === "string" && msg.content.trim()) {
+        items.push({
+          type: "message",
+          role: msg.role === "user" ? "user" : "user",
+          content: [{ type: "input_text", text: msg.content }]
+        });
+      }
+    }
+    return items;
+  }
+  extractXAIToolCalls(output) {
+    if (!Array.isArray(output)) return [];
+    return output.filter((entry) => _optionalChain([entry, 'optionalAccess', _200 => _200.type]) === "function_call").map((toolCall, index) => ({
+      id: _nullishCoalesce(toolCall.call_id, () => ( `call_${index + 1}`)),
+      type: "function",
+      function: {
+        name: toolCall.name,
+        arguments: toolCall.arguments
+      }
+    }));
+  }
+  extractXAIContent(data) {
+    if (typeof data.output_text === "string" && data.output_text.trim()) {
+      return data.output_text;
+    }
+    if (!Array.isArray(data.output)) return "";
+    const parts = [];
+    for (const item of data.output) {
+      if (_optionalChain([item, 'optionalAccess', _201 => _201.type]) !== "message" || !Array.isArray(item.content)) continue;
+      for (const ci of item.content) {
+        if (_optionalChain([ci, 'optionalAccess', _202 => _202.type]) === "output_text" && typeof ci.text === "string") {
+          parts.push(ci.text);
+        }
+      }
+    }
+    return parts.join("\n").trim();
+  }
+  mapXAIUsage(usage) {
+    if (!usage) return void 0;
+    const input = _nullishCoalesce(usage.input_tokens, () => ( 0));
+    const output = _nullishCoalesce(usage.output_tokens, () => ( 0));
+    return {
+      promptTokens: input,
+      completionTokens: output,
+      totalTokens: _nullishCoalesce(usage.total_tokens, () => ( input + output))
+    };
+  }
+  async parseXAIStream(response) {
+    const text = await response.text();
+    let currentEvent = "";
+    let completedData = null;
+    for (const line of text.split("\n")) {
+      if (line.startsWith("event: ")) {
+        currentEvent = line.slice(7).trim();
+        continue;
+      }
+      if (line.startsWith("data: ") && currentEvent === "response.completed") {
+        completedData = JSON.parse(line.slice(6));
+        break;
+      }
+    }
+    if (!completedData) {
+      throw new (0, _chunk3OF56EMAcjs.ApiError)(
+        "No response.completed event found in stream. The API response may be malformed.",
+        "invalid_request",
+        0,
+        false
+      );
+    }
+    return completedData;
+  }
+  async buildApiError(response) {
+    let errorDetail = "";
+    try {
+      const body = await response.json();
+      const errObj = _optionalChain([body, 'optionalAccess', _203 => _203.error]);
+      errorDetail = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([errObj, 'optionalAccess', _204 => _204.message]), () => ( _optionalChain([body, 'optionalAccess', _205 => _205.detail]))), () => ( _optionalChain([body, 'optionalAccess', _206 => _206.error]))), () => ( ""));
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch (e41) {
+      try {
+        errorDetail = await response.text();
+      } catch (e42) {
+      }
+    }
+    return withXAIMessage(_chunk3OF56EMAcjs.classifyApiError.call(void 0, response.status, errorDetail, response.headers));
+  }
+};
+
+// src/providers/CerebrasClient.ts
+function sanitizeMessages5(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', _207 => _207.tool_calls, 'optionalAccess', _208 => _208.length])) {
+      sanitized.tool_calls = msg.tool_calls;
+    }
+    if (msg.name) {
+      sanitized.name = msg.name;
+    }
+    return sanitized;
+  });
+}
+var DEFAULT_BASE_URL3 = "https://api.cerebras.ai/v1";
+var DEFAULT_MAX_RETRIES7 = 3;
+var MAX_ALLOWED_RETRIES7 = 5;
+var DEFAULT_RETRY_DELAY7 = 1e3;
+var DEFAULT_TIMEOUT7 = 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 Cerebras API key in ~/.autohand/config.json.",
+  402: "Payment required. Please check your Cerebras 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 Cerebras service encountered an internal error. Please try again later.",
+  502: "The Cerebras service is temporarily unavailable. Please try again in a few moments.",
+  503: "The Cerebras service is currently overloaded. Please try again later.",
+  504: "The request timed out. The service may be experiencing high load."
+};
+var CerebrasClient = class {
+  
+  
+  
+  
+  
+  
+  constructor(settings, networkSettings) {
+    this.apiKey = settings.apiKey;
+    this.baseUrl = _nullishCoalesce(settings.baseUrl, () => ( DEFAULT_BASE_URL3));
+    this.defaultModel = settings.model;
+    this.maxRetries = Math.min(
+      _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _209 => _209.maxRetries]), () => ( DEFAULT_MAX_RETRIES7)),
+      MAX_ALLOWED_RETRIES7
+    );
+    this.retryDelay = DEFAULT_RETRY_DELAY7;
+    this.timeout = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _210 => _210.timeout]), () => ( DEFAULT_TIMEOUT7));
+  }
+  setDefaultModel(model) {
+    this.defaultModel = model;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async complete(request) {
+    const payload = {
+      model: _nullishCoalesce(request.model, () => ( this.defaultModel)),
+      messages: sanitizeMessages5(request.messages),
+      temperature: _nullishCoalesce(request.temperature, () => ( 0.7)),
+      max_tokens: _nullishCoalesce(request.maxTokens, () => ( 2e4)),
+      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",
+      "x-source": "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 Cerebras API. Please try again.")));
+  }
+  async makeRequest(payload, headers, signal, payloadJson) {
+    const timeoutController = new AbortController();
+    const timerId = setTimeout(() => timeoutController.abort(), this.timeout);
+    const combinedSignal = signal ? this.combineSignals(signal, timeoutController.signal) : timeoutController.signal;
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: payloadJson,
+        signal: combinedSignal
+      });
+    } finally {
+      clearTimeout(timerId);
+    }
+    if (!response.ok) {
+      throw await this.buildApiError(response, payload);
+    }
+    if (payload.stream) {
+      return this.handleStreamingResponse(response);
+    }
+    const data = await response.json();
+    const choice = _optionalChain([data, 'access', _211 => _211.choices, 'optionalAccess', _212 => _212[0]]);
+    let toolCalls;
+    if (_optionalChain([choice, 'optionalAccess', _213 => _213.message, 'optionalAccess', _214 => _214.tool_calls, 'optionalAccess', _215 => _215.length])) {
+      toolCalls = choice.message.tool_calls.map((tc) => ({
+        id: tc.id,
+        type: tc.type,
+        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', _216 => _216.length]) ? "tool_calls" : _optionalChain([choice, 'optionalAccess', _217 => _217.finish_reason]) === "stop" || _optionalChain([choice, 'optionalAccess', _218 => _218.finish_reason]) === "length" || _optionalChain([choice, 'optionalAccess', _219 => _219.finish_reason]) === "content_filter" ? choice.finish_reason : "stop";
+    return {
+      id: data.id || `cerebras-${Date.now()}`,
+      created: data.created || Math.floor(Date.now() / 1e3),
+      content: _nullishCoalesce(_optionalChain([choice, 'optionalAccess', _220 => _220.message, 'optionalAccess', _221 => _221.content]), () => ( "")),
+      toolCalls,
+      usage,
+      finishReason,
+      raw: data
+    };
+  }
+  async handleStreamingResponse(response) {
+    const reader = _optionalChain([response, 'access', _222 => _222.body, 'optionalAccess', _223 => _223.getReader, 'call', _224 => _224()]);
+    if (!reader) {
+      throw new Error("No response body available for streaming");
+    }
+    let content = "";
+    let finishReason;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = new TextDecoder().decode(value);
+        const lines = chunk.split("\n");
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") continue;
+            try {
+              const parsed = JSON.parse(data);
+              const delta = _optionalChain([parsed, 'access', _225 => _225.choices, 'optionalAccess', _226 => _226[0], 'optionalAccess', _227 => _227.delta]);
+              if (_optionalChain([delta, 'optionalAccess', _228 => _228.content])) {
+                content += delta.content;
+              }
+              if (_optionalChain([parsed, 'access', _229 => _229.choices, 'optionalAccess', _230 => _230[0], 'optionalAccess', _231 => _231.finish_reason])) {
+                finishReason = parsed.choices[0].finish_reason;
+              }
+            } catch (e43) {
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return {
+      id: `cerebras-${Date.now()}`,
+      created: Math.floor(Date.now() / 1e3),
+      content,
+      finishReason: finishReason || "stop",
+      raw: { content, finishReason }
+    };
+  }
+  combineSignals(userSignal, timeoutSignal) {
+    const controller = new AbortController();
+    const onAbort = () => {
+      controller.abort();
+    };
+    userSignal.addEventListener("abort", onAbort);
+    timeoutSignal.addEventListener("abort", onAbort);
+    if (userSignal.aborted || timeoutSignal.aborted) {
+      controller.abort();
+    }
+    return controller.signal;
+  }
+  async buildApiError(response, _body) {
+    let errorDetail = "";
+    try {
+      const errorData = await response.json();
+      errorDetail = _optionalChain([errorData, 'access', _232 => _232.error, 'optionalAccess', _233 => _233.message]) || JSON.stringify(errorData);
+    } catch (e44) {
+      try {
+        errorDetail = await response.text();
+      } catch (e45) {
+        errorDetail = `HTTP ${response.status}`;
+      }
+    }
+    const friendlyMessage = FRIENDLY_ERRORS2[response.status] || `Cerebras API error (${response.status}): ${errorDetail}`;
+    return new Error(friendlyMessage);
+  }
+  isNonRetryableError(error) {
+    const message = error.message.toLowerCase();
+    return message.includes("authentication failed") || message.includes("access denied") || message.includes("not found") || message.includes("malformed");
+  }
+};
+
+// src/providers/CerebrasProvider.ts
+var CEREBRAS_DEFAULT_BASE_URL = "https://api.cerebras.ai/v1";
+var CEREBRAS_MODELS = [
+  "zai-glm-4.7",
+  "qwen-3-235b-a22b-instruct-2507"
+];
+var CerebrasProvider = class {
+  
+  
+  constructor(config, networkSettings) {
+    const effectiveConfig = {
+      ...config,
+      baseUrl: _nullishCoalesce(config.baseUrl, () => ( CEREBRAS_DEFAULT_BASE_URL))
+    };
+    this.client = new CerebrasClient(effectiveConfig, networkSettings);
+    this.model = config.model;
+  }
+  getName() {
+    return "cerebras";
+  }
+  setModel(model) {
+    this.model = model;
+    this.client.setDefaultModel(model);
+  }
+  async listModels() {
+    return [...CEREBRAS_MODELS];
+  }
+  async isAvailable() {
+    return true;
+  }
+  async complete(request) {
+    return this.client.complete(request);
+  }
+};
+
+// src/providers/DeepSeekProvider.ts
+var DEEPSEEK_DEFAULT_BASE_URL = "https://api.deepseek.com";
+var DEEPSEEK_MODELS = [
+  "deepseek-v4-flash",
+  "deepseek-v4-pro",
+  "deepseek-chat",
+  "deepseek-reasoner"
+];
+var DeepSeekProvider = class {
+  
+  
+  constructor(config, networkSettings) {
+    const effectiveConfig = {
+      ...config,
+      baseUrl: _nullishCoalesce(config.baseUrl, () => ( DEEPSEEK_DEFAULT_BASE_URL))
+    };
+    this.client = new LLMGatewayClient(effectiveConfig, networkSettings, {
+      serviceName: "DeepSeek",
+      credentialName: "DeepSeek API key",
+      accountName: "DeepSeek account"
+    });
+    this.model = config.model;
+  }
+  getName() {
+    return "deepseek";
+  }
+  setModel(model) {
+    this.model = model;
+    this.client.setDefaultModel(model);
+  }
+  async listModels() {
+    return [...DEEPSEEK_MODELS];
+  }
+  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, config.network);
+      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, config.network);
+      case "llmgateway":
+        if (!config.llmgateway) {
+          return new UnconfiguredProvider("llmgateway");
+        }
+        return new LLMGatewayProvider(config.llmgateway, config.network);
+      case "azure":
+        if (!config.azure) {
+          return new UnconfiguredProvider("azure");
+        }
+        return new AzureProvider(config.azure, config.network);
+      case "zai":
+        if (!config.zai) {
+          return new UnconfiguredProvider("zai");
+        }
+        return new ZaiProvider(config.zai, config.network);
+      case "vertexai":
+        if (!config.vertexai) {
+          return new UnconfiguredProvider("vertexai");
+        }
+        return new VertexAIProvider(config.vertexai, config.network);
+      case "xai":
+        if (!config.xai) {
+          return new UnconfiguredProvider("xai");
+        }
+        return new XAIProvider(config.xai);
+      case "cerebras":
+        if (!config.cerebras) {
+          return new UnconfiguredProvider("cerebras");
+        }
+        return new CerebrasProvider(config.cerebras, config.network);
+      case "nvidia":
+        if (!config.nvidia) {
+          return new UnconfiguredProvider("nvidia");
+        }
+        return new (0, _chunkUWFG2R2Icjs.NVIDIAProvider)(config.nvidia, config.network);
+      case "deepseek":
+        if (!config.deepseek) {
+          return new UnconfiguredProvider("deepseek");
+        }
+        return new DeepSeekProvider(config.deepseek, 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 = ["zai", "xai", "vertexai", "nvidia", "openrouter", "openai", "ollama", "llmgateway", "llamacpp", "deepseek", "cerebras", "azure"];
+    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", "azure", "zai", "vertexai", "xai", "cerebras", "nvidia", "deepseek"];
+    return allProviders.includes(name);
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.isChatGPTAuthExpired = isChatGPTAuthExpired; exports.authenticateOpenAIChatGPT = authenticateOpenAIChatGPT; exports.OPENAI_MODELS = OPENAI_MODELS; exports.getOpenRouterModelContextWindow = getOpenRouterModelContextWindow; exports.modelSupportsImages = modelSupportsImages; exports.ZAI_DEFAULT_BASE_URL = ZAI_DEFAULT_BASE_URL; exports.ZAI_MODELS = ZAI_MODELS; exports.isGcloudInstalled = isGcloudInstalled; exports.getGcloudProject = getGcloudProject; exports.getGcloudAccessToken = getGcloudAccessToken; exports.getGcloudAccount = getGcloudAccount; exports.VERTEX_AI_CODING_MODELS = VERTEX_AI_CODING_MODELS; exports.CEREBRAS_DEFAULT_BASE_URL = CEREBRAS_DEFAULT_BASE_URL; exports.CEREBRAS_MODELS = CEREBRAS_MODELS; exports.DEEPSEEK_DEFAULT_BASE_URL = DEEPSEEK_DEFAULT_BASE_URL; exports.DEEPSEEK_MODELS = DEEPSEEK_MODELS; exports.ProviderNotConfiguredError = ProviderNotConfiguredError; exports.ProviderFactory = ProviderFactory;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Google Cloud CLI authentication utilities
+ * @license Apache-2.0
+ */