autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-CCVMREXI.js

@@ -0,0 +1,420 @@
+import {
+  ApiError,
+  classifyApiError
+} from "./chunk-FQVG6ZHF.js";
+
+// src/providers/NVIDIAClient.ts
+function sanitizeMessages(messages) {
+  return messages.map((msg) => {
+    const sanitized = {
+      role: msg.role,
+      content: msg.content
+    };
+    if (msg.role === "tool" && msg.tool_call_id) {
+      sanitized.tool_call_id = msg.tool_call_id;
+    }
+    if (msg.role === "assistant" && msg.tool_calls?.length) {
+      sanitized.tool_calls = msg.tool_calls;
+    }
+    if (msg.name) {
+      sanitized.name = msg.name;
+    }
+    return sanitized;
+  });
+}
+var NVIDIA_DEFAULT_BASE_URL = "https://integrate.api.nvidia.com/v1";
+var DEFAULT_MAX_RETRIES = 3;
+var MAX_ALLOWED_RETRIES = 5;
+var DEFAULT_RETRY_DELAY = 1e3;
+var DEFAULT_TIMEOUT = 3e4;
+var FRIENDLY_ERRORS = {
+  400: "The request was malformed. This often happens when the context is too long. Try /undo to remove recent turns or /new to start fresh.",
+  401: "Authentication failed. Please verify your NVIDIA API key in ~/.autohand/config.json.",
+  402: "Payment required. Please check your NVIDIA 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 NVIDIA service encountered an internal error. Please try again later.",
+  502: "The NVIDIA service is temporarily unavailable. Please try again in a few moments.",
+  503: "The NVIDIA service is currently overloaded. Please try again later.",
+  504: "The request timed out. The service may be experiencing high load."
+};
+var NVIDIAClient = class {
+  apiKey;
+  baseUrl;
+  defaultModel;
+  maxRetries;
+  retryDelay;
+  timeout;
+  constructor(settings, networkSettings) {
+    this.apiKey = settings.apiKey ?? "";
+    this.baseUrl = settings.baseUrl ?? NVIDIA_DEFAULT_BASE_URL;
+    this.defaultModel = settings.model;
+    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;
+  }
+  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 NVIDIA API. Please try again.");
+  }
+  buildPayload(request) {
+    const payload = {
+      model: request.model ?? this.defaultModel,
+      messages: sanitizeMessages(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 NVIDIA service may be experiencing high load.");
+      }
+      throw new Error("Unable to connect to NVIDIA API. Please check your internet connection.");
+    }
+    if (!response.ok) {
+      throw 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) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.function?.name ?? "",
+          arguments: tc.function?.arguments ?? "{}"
+        }
+      }));
+    }
+    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 ?? "nvidia-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 ?? `nvidia-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 = FRIENDLY_ERRORS[status];
+    const classified = classifyApiError(status, errorDetail, response.headers);
+    if (friendlyMessage) {
+      return new ApiError(
+        errorDetail ? `${friendlyMessage}
+${errorDetail}` : friendlyMessage,
+        classified.code,
+        classified.httpStatus,
+        classified.retryable,
+        classified.retryAfterMs,
+        errorDetail
+      );
+    }
+    if (status >= 500) {
+      const base = "The NVIDIA service is temporarily unavailable. Please try again later.";
+      return new ApiError(
+        errorDetail ? `${base}
+(${status}: ${errorDetail})` : base,
+        classified.code,
+        classified.httpStatus,
+        classified.retryable,
+        classified.retryAfterMs,
+        errorDetail
+      );
+    }
+    if (status >= 400) {
+      const base = "The request could not be processed.";
+      const message2 = errorDetail ? `${base} (${status}: ${errorDetail})` : `${base} (HTTP ${status}) Please try again or adjust your prompt.`;
+      return new ApiError(
+        message2,
+        classified.code,
+        classified.httpStatus,
+        classified.retryable,
+        classified.retryAfterMs,
+        errorDetail
+      );
+    }
+    const message = errorDetail ? `An unexpected error occurred: ${errorDetail}` : "An unexpected error occurred. Please try again.";
+    return new ApiError(
+      message,
+      classified.code,
+      classified.httpStatus,
+      classified.retryable,
+      classified.retryAfterMs,
+      errorDetail
+    );
+  }
+  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("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/NVIDIAProvider.ts
+var NVIDIA_DEFAULT_BASE_URL2 = "https://integrate.api.nvidia.com/v1";
+var NVIDIA_MODELS = [
+  "deepseek-ai/deepseek-v4-pro",
+  "z-ai/glm-5.1",
+  "z-ai/glm-4.7",
+  "qwen/qwen3.5-122b-a10b",
+  "nvidia/usdcode",
+  "moonshotai/kimi-k2.5",
+  "minimaxai/minimax-m2.7",
+  "microsoft/phi-4-mini-instruct",
+  "mistralai/mistral-small-4-119b-2603",
+  "mistralai/mixtral-8x7b-instruct-v0.1",
+  "mistralai/mixtral-8x22b-instruct-v0.1",
+  "mistralai/mamba-codestral-7b-v0.1",
+  "nvidia/mistral-nemo-minitron-8b-base",
+  "google/gemma-4-31b-it",
+  "bigcode/starcoder2-7b"
+];
+var NVIDIA_DEFAULT_MODEL = "z-ai/glm-5.1";
+var NVIDIAProvider = class {
+  client;
+  model;
+  chatTemplateKwargs;
+  stream;
+  constructor(config, networkSettings) {
+    this.client = new NVIDIAClient(config, networkSettings);
+    this.model = config.model;
+    this.chatTemplateKwargs = config.chatTemplateKwargs;
+    this.stream = config.stream ?? false;
+  }
+  getName() {
+    return "nvidia";
+  }
+  setModel(model) {
+    this.model = model;
+    this.client.setDefaultModel(model);
+  }
+  async listModels() {
+    return [...NVIDIA_MODELS];
+  }
+  async isAvailable() {
+    return true;
+  }
+  async complete(request) {
+    const enhancedRequest = {
+      ...request,
+      // Use request stream if set, otherwise fall back to provider default
+      stream: request.stream ?? this.stream,
+      // Merge chatTemplateKwargs: request-level takes precedence
+      chatTemplateKwargs: request.chatTemplateKwargs ?? this.chatTemplateKwargs
+    };
+    return this.client.complete(enhancedRequest);
+  }
+};
+
+export {
+  NVIDIA_DEFAULT_BASE_URL2 as NVIDIA_DEFAULT_BASE_URL,
+  NVIDIA_MODELS,
+  NVIDIA_DEFAULT_MODEL,
+  NVIDIAProvider
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-CFAWTLSC.js

@@ -0,0 +1,13 @@
+// src/ui/inkMode.ts
+function shouldUseInkRenderer(env = process.env) {
+  return env.AUTOHAND_LEGACY_UI !== "1" && env.AUTOHAND_NO_INK !== "1";
+}
+
+export {
+  shouldUseInkRenderer
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-G27PQQFD.js → chunk-CFFE4VA3.js}

@@ -1,6 +1,6 @@
 import {
   t
-} from "./chunk-APIXPPMT.js";
+} from "./chunk-CBFH2J3O.js";
 
 // src/commands/undo.ts
 import chalk from "chalk";