autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-QKP772OZ.js

@@ -0,0 +1,4291 @@
+import {
+  NVIDIAProvider
+} from "./chunk-CCVMREXI.js";
+import {
+  ApiError,
+  classifyApiError
+} from "./chunk-FQVG6ZHF.js";
+
+// 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 {
+  baseUrl;
+  model;
+  disableTools = false;
+  maxRetries;
+  retryDelay;
+  timeout;
+  chunkTimeout;
+  constructor(config, networkSettings) {
+    this.baseUrl = config.baseUrl || "http://localhost:11434";
+    this.model = config.model || "llama3.2:latest";
+    const configuredRetries = networkSettings?.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.maxRetries = Math.min(Math.max(0, configuredRetries), MAX_ALLOWED_RETRIES);
+    this.retryDelay = networkSettings?.retryDelay ?? DEFAULT_RETRY_DELAY;
+    this.timeout = networkSettings?.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 {
+      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 {
+      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: 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 lastError ?? new 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" && request.signal?.aborted) {
+        throw new ApiError("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new 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 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: data.prompt_eval_count ?? 0,
+        completionTokens: data.eval_count ?? 0,
+        totalTokens: (data.prompt_eval_count ?? 0) + (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: toolCalls?.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 {
+    }
+    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 = classifyApiError(
+        response.status === 429 ? response.status : 429,
+        errorBody,
+        response.headers
+      );
+      return new 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 = classifyApiError(response.status, errorBody, response.headers);
+      return new 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 = classifyApiError(response.status, errorBody, response.headers);
+      return new ApiError(
+        `Model not found. Run 'ollama pull ${String(body.model)}' to download it.
+${errorBody}`,
+        baseError.code,
+        baseError.httpStatus,
+        baseError.retryable,
+        baseError.retryAfterMs,
+        errorBody
+      );
+    }
+    return classifyApiError(response.status, errorBody, response.headers);
+  }
+  buildMessages(messages, includeToolMetadata) {
+    if (!includeToolMetadata) {
+      return this.sanitizeMessagesForToollessMode(messages);
+    }
+    return 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?.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 {
+    }
+    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" && toolCalls?.length) {
+        const toolNames = toolCalls.map((call) => {
+          const fn = call && typeof call === "object" ? call.function : void 0;
+          return typeof fn?.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 = response.body?.getReader();
+    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 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 {
+          }
+        }
+        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 ApiError) {
+      return !error.retryable;
+    }
+    const classified = classifyApiError(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/openaiAuth.ts
+import { createHash, randomBytes } from "crypto";
+import { createServer } from "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 {
+    return null;
+  }
+}
+function decodeJwtExpiry(token) {
+  const payload = decodeJwtPayload(token);
+  if (!payload?.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(randomBytes(32));
+}
+function generatePkceChallenge(verifier) {
+  return toBase64Url(createHash("sha256").update(verifier).digest());
+}
+function createState() {
+  return randomBytes(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 = 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 {
+      payload = rawText;
+    }
+  }
+  const detail = extractErrorDetail(payload) ?? (typeof payload === "string" && payload.trim() ? payload.trim() : void 0);
+  return { payload, detail };
+}
+async function openBrowser(url) {
+  try {
+    const open = await import("open").then((mod) => mod.default);
+    await open(url);
+    return true;
+  } catch {
+    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 = createServer((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));
+        settle?.({
+          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."));
+        settle?.({
+          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."));
+        settle?.({
+          error: "missing_code",
+          errorDescription: "Missing authorization code."
+        });
+        return;
+      }
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(callbackSuccessHtml());
+      settle?.({ code });
+    } catch {
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(callbackErrorHtml("Internal error while handling the callback."));
+      settle?.({
+        error: "callback_error",
+        errorDescription: "Internal error while handling the callback."
+      });
+    }
+  });
+  const timeoutId = setTimeout(() => {
+    settle?.({
+      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 payload?.["https://api.openai.com/auth"]?.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 options.onPrompt?.({
+      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: payload.refresh_token ?? auth.refreshToken,
+    idToken: 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 {
+  baseUrl;
+  apiKey;
+  model;
+  reasoningEffort;
+  authMode;
+  chatgptAuth;
+  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 !!this.chatgptAuth?.accessToken && !!this.chatgptAuth?.accountId;
+    }
+    try {
+      const headers = await this.buildAuthHeaders();
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers
+      });
+      return response.ok;
+    } catch {
+      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" && msg.tool_calls?.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: 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" && request.signal?.aborted) {
+        throw new ApiError("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new ApiError(
+          "The request timed out. The OpenAI service may be experiencing high load.",
+          "timeout",
+          0,
+          true
+        );
+      }
+      throw new 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: 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: 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" && request.signal?.aborted) {
+        throw new ApiError("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new ApiError(
+          "The request timed out. The ChatGPT Codex service may be experiencing high load.",
+          "timeout",
+          0,
+          true
+        );
+      }
+      throw new 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: data.usage.input_tokens ?? 0,
+      completionTokens: data.usage.output_tokens ?? 0,
+      totalTokens: data.usage.total_tokens ?? (data.usage.input_tokens ?? 0) + (data.usage.output_tokens ?? 0)
+    } : void 0;
+    return {
+      id: data.id,
+      created: data.created_at ?? Math.floor(Date.now() / 1e3),
+      content,
+      toolCalls,
+      finishReason: toolCalls.length > 0 ? "tool_calls" : data.incomplete_details?.reason === "max_output_tokens" ? "length" : "stop",
+      usage,
+      raw: data
+    };
+  }
+  async buildApiError(response) {
+    let errorDetail = "";
+    try {
+      const body = await response.json();
+      const errObj = body?.error;
+      errorDetail = errObj?.message ?? body?.detail ?? body?.error ?? "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch {
+      try {
+        errorDetail = await response.text();
+      } catch {
+      }
+    }
+    return this.withOpenAIMessage(classifyApiError(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 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 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 (!this.chatgptAuth?.accessToken || !this.chatgptAuth.accountId) {
+        throw new 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" && msg.tool_calls?.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) => entry?.type === "function_call").map((toolCall, index) => ({
+      id: 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 (item?.type !== "message" || !Array.isArray(item.content)) {
+        continue;
+      }
+      for (const contentItem of item.content) {
+        if (contentItem?.type === "output_text" && typeof contentItem.text === "string") {
+          parts.push(contentItem.text);
+        }
+      }
+    }
+    return parts.join("\n").trim();
+  }
+};
+
+// src/providers/LlamaCppProvider.ts
+var LlamaCppProvider = class _LlamaCppProvider {
+  baseUrl;
+  model;
+  static 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 data.data?.map((m) => m.id) ?? [this.model];
+    } catch {
+      return this.model ? [this.model] : [];
+    }
+  }
+  async isAvailable() {
+    try {
+      const response = await fetch(`${this.baseUrl}/health`);
+      return response.ok;
+    } catch {
+      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: request.temperature ?? 0.7,
+      max_tokens: 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: 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 (choice?.message.tool_calls?.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 = toolCalls?.length ? "tool_calls" : choice?.finish_reason === "stop" || choice?.finish_reason === "length" || choice?.finish_reason === "content_filter" ? choice.finish_reason : "stop";
+    return {
+      id: data.id || `llamacpp-${Date.now()}`,
+      created: data.created || Math.floor(Date.now() / 1e3),
+      content: choice?.message.content ?? "",
+      toolCalls,
+      finishReason,
+      usage,
+      raw: data
+    };
+  }
+  async buildApiError(response, body) {
+    let errorBody = "";
+    try {
+      errorBody = await response.text();
+    } catch {
+    }
+    const lowerBody = errorBody.toLowerCase();
+    if (body.tools && response.status === 400 && (lowerBody.includes("tool") || lowerBody.includes("function") || lowerBody.includes("schema"))) {
+      return new 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 = classifyApiError(response.status, errorBody, response.headers);
+    return new ApiError(
+      `llama.cpp API error: ${response.status} ${response.statusText}${errorBody ? `
+${errorBody}` : ""}`,
+      baseError.code,
+      baseError.httpStatus,
+      baseError.retryable,
+      baseError.retryAfterMs,
+      errorBody
+    );
+  }
+};
+
+// 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(capability.architecture?.input_modalities)) {
+    return capability.architecture.input_modalities;
+  }
+  return [];
+}
+function getOpenRouterCapabilityContextWindow(capability) {
+  const contextWindow = capability?.top_provider?.context_length ?? capability?.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(data?.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 {
+    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) => 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" && msg.tool_calls?.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 ApiError(
+    error.rawDetail ? `${friendlyMessage}
+${error.rawDetail}` : friendlyMessage,
+    error.code,
+    error.httpStatus,
+    error.retryable,
+    error.retryAfterMs,
+    error.rawDetail
+  );
+}
+var OpenRouterClient = class {
+  apiKey;
+  baseUrl;
+  defaultModel;
+  maxRetries;
+  retryDelay;
+  timeout;
+  constructor(settings, networkSettings) {
+    this.apiKey = settings.apiKey ?? "";
+    this.baseUrl = settings.baseUrl ?? DEFAULT_BASE_URL;
+    this.defaultModel = settings.model;
+    const configuredRetries = networkSettings?.maxRetries ?? DEFAULT_MAX_RETRIES2;
+    this.maxRetries = Math.min(
+      Math.max(0, configuredRetries),
+      MAX_ALLOWED_RETRIES2
+    );
+    this.retryDelay = networkSettings?.retryDelay ?? DEFAULT_RETRY_DELAY2;
+    this.timeout = networkSettings?.timeout ?? DEFAULT_TIMEOUT2;
+  }
+  setDefaultModel(model) {
+    this.defaultModel = model;
+  }
+  async complete(request) {
+    const selectedModel = request.model ?? this.defaultModel;
+    const allowImageInputs = messageContainsImageContent(request.messages) ? await modelSupportsImages(selectedModel) : false;
+    const payload = {
+      model: selectedModel,
+      messages: sanitizeMessages(request.messages, allowImageInputs),
+      temperature: request.temperature ?? 0.2,
+      max_tokens: request.maxTokens ?? 16e3,
+      // Increased from 1000 to allow large file generation
+      stream: 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: 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 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 ApiError ? error.retryAfterMs : void 0;
+          const delay = Math.max(
+            this.retryDelay * Math.pow(2, attempt),
+            retryAfterMs ?? 0
+          );
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError ?? new 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: preSerializedBody ?? JSON.stringify(payload),
+          signal: combinedSignal
+        });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && signal?.aborted) {
+        throw new ApiError("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new ApiError(
+          "The request timed out. The OpenRouter service may be experiencing high load.",
+          "timeout",
+          0,
+          true
+        );
+      }
+      throw new 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 = json?.choices?.[0]?.message;
+    const text = message?.content ?? "";
+    const finishReason = json?.choices?.[0]?.finish_reason;
+    let toolCalls;
+    if (message?.tool_calls && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => {
+        const rawArgs = tc.function?.arguments;
+        return {
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.function?.name ?? "",
+            arguments: rawArgs ?? "{}"
+          }
+        };
+      });
+    }
+    let usage;
+    if (json?.usage) {
+      usage = {
+        promptTokens: json.usage.prompt_tokens ?? 0,
+        completionTokens: json.usage.completion_tokens ?? 0,
+        totalTokens: json.usage.total_tokens ?? 0
+      };
+    }
+    return {
+      id: json.id ?? "autohand-local",
+      created: 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 = body?.error?.message || body?.error || body?.message || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch {
+      try {
+        errorDetail = await response.text();
+      } catch {
+      }
+    }
+    return withOpenRouterMessage(classifyApiError(status, errorDetail, response.headers));
+  }
+  isNonRetryableError(error) {
+    if (error instanceof ApiError) {
+      return !error.retryable;
+    }
+    const classified = classifyApiError(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 {
+  client;
+  model;
+  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 {
+    }
+    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 {
+  baseUrl;
+  model;
+  maxRetries;
+  retryDelay;
+  timeout;
+  constructor(config, networkSettings) {
+    const port = config.port || 8080;
+    this.baseUrl = config.baseUrl || `http://localhost:${port}`;
+    this.model = config.model || "mlx-model";
+    const configuredRetries = networkSettings?.maxRetries ?? DEFAULT_MAX_RETRIES3;
+    this.maxRetries = Math.min(Math.max(0, configuredRetries), MAX_ALLOWED_RETRIES3);
+    this.retryDelay = networkSettings?.retryDelay ?? DEFAULT_RETRY_DELAY3;
+    this.timeout = networkSettings?.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 data.data?.map((m) => m.id) ?? (this.model ? [this.model] : []);
+      } finally {
+        clearTimeout(timerId);
+      }
+    } catch {
+      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 {
+      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: request.temperature ?? 0.7,
+      max_tokens: 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: 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 lastError ?? new 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" && userSignal?.aborted) {
+        throw new ApiError("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new 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 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 {
+      let rawBody = "";
+      try {
+        rawBody = await response.text();
+      } catch {
+      }
+      throw new 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 (choice?.message.tool_calls?.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 = toolCalls?.length ? "tool_calls" : choice?.finish_reason === "stop" || choice?.finish_reason === "length" || choice?.finish_reason === "content_filter" ? choice.finish_reason : "stop";
+    return {
+      id: data.id || `mlx-${Date.now()}`,
+      created: data.created || Math.floor(Date.now() / 1e3),
+      content: choice?.message.content ?? "",
+      toolCalls,
+      finishReason,
+      usage,
+      raw: data
+    };
+  }
+  async buildApiError(response) {
+    let errorDetail = "";
+    try {
+      const body = await response.json();
+      const maybeError = body?.error;
+      if (maybeError && typeof maybeError === "object") {
+        errorDetail = maybeError?.message ?? "";
+      } else if (typeof maybeError === "string") {
+        errorDetail = maybeError;
+      } else if (typeof body?.message === "string") {
+        errorDetail = body.message;
+      }
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch {
+      try {
+        errorDetail = await response.text();
+      } catch {
+      }
+    }
+    return classifyApiError(response.status, errorDetail, response.headers);
+  }
+  isNonRetryableError(error) {
+    if (error instanceof ApiError) {
+      return !error.retryable;
+    }
+    const classified = classifyApiError(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" && msg.tool_calls?.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 {
+  apiKey;
+  baseUrl;
+  defaultModel;
+  maxRetries;
+  retryDelay;
+  timeout;
+  errorLabels;
+  constructor(settings, networkSettings, errorLabels = DEFAULT_ERROR_LABELS) {
+    this.apiKey = settings.apiKey ?? "";
+    this.baseUrl = settings.baseUrl ?? DEFAULT_BASE_URL2;
+    this.defaultModel = settings.model;
+    this.errorLabels = errorLabels;
+    const configuredRetries = networkSettings?.maxRetries ?? DEFAULT_MAX_RETRIES4;
+    this.maxRetries = Math.min(
+      Math.max(0, configuredRetries),
+      MAX_ALLOWED_RETRIES4
+    );
+    this.retryDelay = networkSettings?.retryDelay ?? DEFAULT_RETRY_DELAY4;
+    this.timeout = networkSettings?.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: 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,
+          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 lastError ?? new Error("Failed to communicate with LLM Gateway. Please try again.");
+  }
+  buildPayload(request) {
+    const payload = {
+      model: request.model ?? this.defaultModel,
+      messages: sanitizeMessages2(request.messages),
+      temperature: request.temperature ?? 0.2,
+      max_tokens: request.maxTokens ?? 16e3,
+      stream: 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: preSerializedBody ?? JSON.stringify(payload),
+          signal: combinedSignal
+        });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && signal?.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 = json?.choices?.[0]?.message;
+    const text = message?.content ?? "";
+    const finishReason = json?.choices?.[0]?.finish_reason;
+    let toolCalls;
+    if (message?.tool_calls && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => {
+        const rawArgs = tc.function?.arguments;
+        return {
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.function?.name ?? "",
+            arguments: rawArgs ?? "{}"
+          }
+        };
+      });
+    }
+    let usage;
+    if (json?.usage) {
+      usage = {
+        promptTokens: json.usage.prompt_tokens ?? 0,
+        completionTokens: json.usage.completion_tokens ?? 0,
+        totalTokens: json.usage.total_tokens ?? 0
+      };
+    }
+    return {
+      id: json.id ?? "llmgateway-response",
+      created: json.created ?? Date.now(),
+      content: text,
+      toolCalls,
+      finishReason,
+      usage,
+      raw: json
+    };
+  }
+  async handleStreamingResponse(response) {
+    const reader = response.body?.getReader();
+    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 = data.choices?.[0]?.delta;
+              if (!delta) continue;
+              const reasoning = delta.reasoning || delta.reasoning_content;
+              if (reasoning) {
+                fullReasoning += reasoning;
+              }
+              if (delta.content) {
+                fullContent += delta.content;
+              }
+              if (data.choices?.[0]?.finish_reason) {
+                finishReason = data.choices[0].finish_reason;
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const finalContent = fullReasoning ? `<thinking>${fullReasoning}</thinking>
+
+${fullContent}` : fullContent;
+    return {
+      id: lastChunk?.id ?? `llmgateway-stream-${Date.now()}`,
+      created: lastChunk?.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 = body?.error?.message || body?.error || body?.message || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch {
+      try {
+        errorDetail = await response.text();
+      } catch {
+      }
+    }
+    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 {
+  client;
+  model;
+  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 = class {
+  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 {
+      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;
+  }
+};
+
+// 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" && msg.tool_calls?.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 {
+  tokenManager;
+  options;
+  defaultModel;
+  maxRetries;
+  retryDelay;
+  timeout;
+  constructor(options, networkSettings) {
+    this.options = options;
+    this.tokenManager = new AzureTokenManager();
+    this.defaultModel = options.model;
+    const configuredRetries = networkSettings?.maxRetries ?? DEFAULT_MAX_RETRIES5;
+    this.maxRetries = Math.min(
+      Math.max(0, configuredRetries),
+      MAX_ALLOWED_RETRIES5
+    );
+    this.retryDelay = networkSettings?.retryDelay ?? DEFAULT_RETRY_DELAY5;
+    this.timeout = networkSettings?.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 = 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 {
+      }
+    }
+    return `https://${resourceName}.openai.azure.com/openai/deployments/${deploymentName}/chat/completions?api-version=${apiVersion}`;
+  }
+  async complete(request) {
+    const payload = {
+      messages: sanitizeMessages3(request.messages),
+      temperature: request.temperature ?? 0.2,
+      max_tokens: request.maxTokens ?? 16e3,
+      stream: 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: 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 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: preSerializedBody ?? JSON.stringify(payload),
+          signal: combinedSignal
+        });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && signal?.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 = json?.choices?.[0]?.message;
+    const text = message?.content ?? "";
+    const finishReason = json?.choices?.[0]?.finish_reason;
+    let toolCalls;
+    if (message?.tool_calls && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => {
+        const rawArgs = tc.function?.arguments;
+        return {
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.function?.name ?? "",
+            arguments: rawArgs ?? "{}"
+          }
+        };
+      });
+    }
+    let usage;
+    if (json?.usage) {
+      usage = {
+        promptTokens: json.usage.prompt_tokens ?? 0,
+        completionTokens: json.usage.completion_tokens ?? 0,
+        totalTokens: json.usage.total_tokens ?? 0
+      };
+    }
+    return {
+      id: json.id ?? "autohand-azure",
+      created: 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 = body?.error?.message || body?.error || body?.message || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch {
+      try {
+        errorDetail = await response.text();
+      } catch {
+      }
+    }
+    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 {
+  client;
+  model;
+  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: 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 {
+  client;
+  model;
+  constructor(config, networkSettings) {
+    const effectiveConfig = {
+      ...config,
+      baseUrl: 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
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var tokenCache = null;
+async function isGcloudInstalled() {
+  try {
+    await execAsync("gcloud --version", { timeout: 5e3 });
+    return true;
+  } catch {
+    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 {
+    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 {
+    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" && msg.tool_calls?.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 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 {
+  authToken;
+  // Changed from readonly to allow refresh
+  endpoint;
+  region;
+  projectId;
+  baseUrl;
+  defaultModel;
+  maxRetries;
+  retryDelay;
+  timeout;
+  useGcloudRefresh;
+  // Auto-refresh via gcloud CLI
+  constructor(settings, networkSettings) {
+    this.authToken = settings.authToken;
+    this.endpoint = settings.endpoint ?? DEFAULT_ENDPOINT;
+    this.region = 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 = networkSettings?.maxRetries ?? DEFAULT_MAX_RETRIES6;
+    this.maxRetries = Math.min(
+      Math.max(0, configuredRetries),
+      MAX_ALLOWED_RETRIES6
+    );
+    this.retryDelay = networkSettings?.retryDelay ?? DEFAULT_RETRY_DELAY6;
+    this.timeout = networkSettings?.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 {
+      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 = 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: request.maxTokens ?? 16e3,
+        stream: 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: tool.parameters ?? { type: "object", properties: {} }
+        }));
+      }
+    } else {
+      payload = {
+        model,
+        messages: sanitizeMessages4(request.messages),
+        temperature: request.temperature ?? 0.2,
+        max_tokens: request.maxTokens ?? 16e3,
+        stream: 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: 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 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 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: preSerializedBody ?? JSON.stringify(payload),
+          signal: combinedSignal
+        });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && signal?.aborted) {
+        throw new ApiError("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new ApiError(
+          "Request timed out. The Vertex AI service may be experiencing high load.",
+          "timeout",
+          504,
+          true
+        );
+      }
+      const classified = classifyApiError(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 = json?.choices?.[0]?.message;
+    const text = message?.content ?? "";
+    const finishReason = json?.choices?.[0]?.finish_reason;
+    let toolCalls;
+    if (message?.tool_calls && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => {
+        const rawArgs = tc.function?.arguments;
+        return {
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.function?.name ?? "",
+            arguments: rawArgs ?? "{}"
+          }
+        };
+      });
+    }
+    let usage;
+    if (json?.usage) {
+      usage = {
+        promptTokens: json.usage.prompt_tokens ?? 0,
+        completionTokens: json.usage.completion_tokens ?? 0,
+        totalTokens: json.usage.total_tokens ?? 0
+      };
+    }
+    return {
+      id: json.id ?? "vertexai-response",
+      created: json.created ?? Date.now(),
+      content: text,
+      toolCalls,
+      finishReason,
+      usage,
+      raw: json
+    };
+  }
+  /**
+   * Parse Anthropic API response format
+   */
+  parseAnthropicResponse(json) {
+    const contentBlocks = json?.content ?? [];
+    const textBlock = contentBlocks.find((b) => b.type === "text");
+    const text = textBlock?.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: block.name ?? "",
+          arguments: JSON.stringify(block.input ?? {})
+        }
+      }));
+    }
+    let usage;
+    if (json?.usage) {
+      usage = {
+        promptTokens: json.usage.input_tokens ?? 0,
+        completionTokens: json.usage.output_tokens ?? 0,
+        totalTokens: (json.usage.input_tokens ?? 0) + (json.usage.output_tokens ?? 0)
+      };
+    }
+    const stopReason = json?.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: 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 = body?.error?.message || body?.error || body?.message || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch {
+      try {
+        errorDetail = await response.text();
+      } catch {
+      }
+    }
+    const classified = classifyApiError(status, errorDetail, response.headers);
+    return withVertexAIMessage(classified);
+  }
+  isNonRetryableError(error) {
+    if (error instanceof 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 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 ApiError(
+    error.rawDetail ? `${friendlyMessage}
+${error.rawDetail}` : friendlyMessage,
+    error.code,
+    error.httpStatus,
+    error.retryable,
+    error.retryAfterMs,
+    error.rawDetail
+  );
+}
+var XAIProvider = class {
+  baseUrl;
+  apiKey;
+  model;
+  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 (data?.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 {
+    }
+    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 {
+      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" && request.signal?.aborted) {
+        throw new ApiError("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new ApiError(
+          "The request timed out. The xAI service may be experiencing high load.",
+          "timeout",
+          0,
+          true
+        );
+      }
+      throw new 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: data.created_at ?? Math.floor(Date.now() / 1e3),
+      content,
+      toolCalls,
+      finishReason: toolCalls.length > 0 ? "tool_calls" : data.incomplete_details?.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 (!tools?.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" && msg.tool_calls?.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) => entry?.type === "function_call").map((toolCall, index) => ({
+      id: 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 (item?.type !== "message" || !Array.isArray(item.content)) continue;
+      for (const ci of item.content) {
+        if (ci?.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 = usage.input_tokens ?? 0;
+    const output = usage.output_tokens ?? 0;
+    return {
+      promptTokens: input,
+      completionTokens: output,
+      totalTokens: 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 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 = body?.error;
+      errorDetail = errObj?.message ?? body?.detail ?? body?.error ?? "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch {
+      try {
+        errorDetail = await response.text();
+      } catch {
+      }
+    }
+    return withXAIMessage(classifyApiError(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" && msg.tool_calls?.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 {
+  apiKey;
+  baseUrl;
+  defaultModel;
+  maxRetries;
+  retryDelay;
+  timeout;
+  constructor(settings, networkSettings) {
+    this.apiKey = settings.apiKey;
+    this.baseUrl = settings.baseUrl ?? DEFAULT_BASE_URL3;
+    this.defaultModel = settings.model;
+    this.maxRetries = Math.min(
+      networkSettings?.maxRetries ?? DEFAULT_MAX_RETRIES7,
+      MAX_ALLOWED_RETRIES7
+    );
+    this.retryDelay = DEFAULT_RETRY_DELAY7;
+    this.timeout = networkSettings?.timeout ?? DEFAULT_TIMEOUT7;
+  }
+  setDefaultModel(model) {
+    this.defaultModel = model;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async complete(request) {
+    const payload = {
+      model: request.model ?? this.defaultModel,
+      messages: sanitizeMessages5(request.messages),
+      temperature: request.temperature ?? 0.7,
+      max_tokens: request.maxTokens ?? 2e4,
+      stream: 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: 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 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 = data.choices?.[0];
+    let toolCalls;
+    if (choice?.message?.tool_calls?.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 = toolCalls?.length ? "tool_calls" : choice?.finish_reason === "stop" || choice?.finish_reason === "length" || choice?.finish_reason === "content_filter" ? choice.finish_reason : "stop";
+    return {
+      id: data.id || `cerebras-${Date.now()}`,
+      created: data.created || Math.floor(Date.now() / 1e3),
+      content: choice?.message?.content ?? "",
+      toolCalls,
+      usage,
+      finishReason,
+      raw: data
+    };
+  }
+  async handleStreamingResponse(response) {
+    const reader = response.body?.getReader();
+    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 = parsed.choices?.[0]?.delta;
+              if (delta?.content) {
+                content += delta.content;
+              }
+              if (parsed.choices?.[0]?.finish_reason) {
+                finishReason = parsed.choices[0].finish_reason;
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    } 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 = errorData.error?.message || JSON.stringify(errorData);
+    } catch {
+      try {
+        errorDetail = await response.text();
+      } catch {
+        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 {
+  client;
+  model;
+  constructor(config, networkSettings) {
+    const effectiveConfig = {
+      ...config,
+      baseUrl: 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 {
+  client;
+  model;
+  constructor(config, networkSettings) {
+    const effectiveConfig = {
+      ...config,
+      baseUrl: 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";
+  }
+  providerName;
+};
+var UnconfiguredProvider = class {
+  constructor(providerName) {
+    this.providerName = 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 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);
+  }
+};
+
+export {
+  isChatGPTAuthExpired,
+  authenticateOpenAIChatGPT,
+  OPENAI_MODELS,
+  getOpenRouterModelContextWindow,
+  modelSupportsImages,
+  ZAI_DEFAULT_BASE_URL,
+  ZAI_MODELS,
+  isGcloudInstalled,
+  getGcloudProject,
+  getGcloudAccessToken,
+  getGcloudAccount,
+  VERTEX_AI_CODING_MODELS,
+  CEREBRAS_DEFAULT_BASE_URL,
+  CEREBRAS_MODELS,
+  DEEPSEEK_DEFAULT_BASE_URL,
+  DEEPSEEK_MODELS,
+  ProviderNotConfiguredError,
+  ProviderFactory
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Google Cloud CLI authentication utilities
+ * @license Apache-2.0
+ */