autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-Y5BDE24P.cjs

@@ -0,0 +1,444 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunk3OF56EMAcjs = require('./chunk-3OF56EMA.cjs');
+
+// src/providers/usage.ts
+function readTokenCount(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+      return Math.floor(value);
+    }
+  }
+  return void 0;
+}
+function normalizeLLMUsage(rawUsage) {
+  if (!rawUsage || typeof rawUsage !== "object" || Array.isArray(rawUsage)) {
+    return void 0;
+  }
+  const usage = rawUsage;
+  const promptTokens = readTokenCount(usage, ["prompt_tokens", "input_tokens", "promptTokens", "inputTokens"]);
+  const completionTokens = readTokenCount(usage, ["completion_tokens", "output_tokens", "completionTokens", "outputTokens"]);
+  const reportedTotal = readTokenCount(usage, ["total_tokens", "totalTokens"]);
+  const hasAnyActualCount = promptTokens !== void 0 || completionTokens !== void 0 || reportedTotal !== void 0;
+  if (!hasAnyActualCount) {
+    return void 0;
+  }
+  const totalTokens = _nullishCoalesce(reportedTotal, () => ( (_nullishCoalesce(promptTokens, () => ( 0))) + (_nullishCoalesce(completionTokens, () => ( 0)))));
+  return {
+    promptTokens: _nullishCoalesce(promptTokens, () => ( 0)),
+    completionTokens: _nullishCoalesce(completionTokens, () => ( 0)),
+    totalTokens
+  };
+}
+
+// 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" && _optionalChain([msg, 'access', _ => _.tool_calls, 'optionalAccess', _2 => _2.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 {
+  
+  
+  
+  
+  
+  
+  constructor(settings, networkSettings) {
+    this.apiKey = _nullishCoalesce(settings.apiKey, () => ( ""));
+    this.baseUrl = _nullishCoalesce(settings.baseUrl, () => ( NVIDIA_DEFAULT_BASE_URL));
+    this.defaultModel = settings.model;
+    const configuredRetries = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _3 => _3.maxRetries]), () => ( DEFAULT_MAX_RETRIES));
+    this.maxRetries = Math.min(Math.max(0, configuredRetries), MAX_ALLOWED_RETRIES);
+    this.retryDelay = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _4 => _4.retryDelay]), () => ( DEFAULT_RETRY_DELAY));
+    this.timeout = _nullishCoalesce(_optionalChain([networkSettings, 'optionalAccess', _5 => _5.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: _nullishCoalesce(tool.parameters, () => ( { type: "object", properties: {} }))
+        }
+      }));
+      if (request.toolChoice) {
+        payload.tool_choice = request.toolChoice;
+      }
+    }
+    if (request.chatTemplateKwargs) {
+      payload.extra_body = {
+        chat_template_kwargs: this.buildChatTemplateKwargs(request.chatTemplateKwargs)
+      };
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "x-source": "Autohand Code CLI"
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    const payloadJson = JSON.stringify(payload);
+    const payloadSizeBytes = payloadJson.length;
+    const maxPayloadSize = 5 * 1024 * 1024;
+    if (payloadSizeBytes > maxPayloadSize) {
+      const sizeMB = (payloadSizeBytes / (1024 * 1024)).toFixed(2);
+      throw new Error(
+        `Request payload too large (${sizeMB}MB). This usually happens when the conversation history grows too long. Try using /undo to remove recent turns or /new to start fresh.`
+      );
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await this.makeRequest(
+          payload,
+          headers,
+          request.signal,
+          payloadJson,
+          _nullishCoalesce(request.stream, () => ( false))
+        );
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (this.isNonRetryableError(error)) {
+          throw error;
+        }
+        if (attempt < this.maxRetries) {
+          const delay = this.retryDelay * Math.pow(2, attempt);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw _nullishCoalesce(lastError, () => ( new Error("Failed to communicate with NVIDIA API. Please try again.")));
+  }
+  buildPayload(request) {
+    const payload = {
+      model: _nullishCoalesce(request.model, () => ( this.defaultModel)),
+      messages: sanitizeMessages(request.messages),
+      temperature: _nullishCoalesce(request.temperature, () => ( 0.2)),
+      max_tokens: _nullishCoalesce(request.maxTokens, () => ( 16e3)),
+      stream: _nullishCoalesce(request.stream, () => ( false))
+    };
+    return payload;
+  }
+  buildChatTemplateKwargs(kwargs) {
+    const result = {};
+    if (kwargs.thinking !== void 0) result.thinking = kwargs.thinking;
+    if (kwargs.enable_thinking !== void 0) result.enable_thinking = kwargs.enable_thinking;
+    if (kwargs.reasoning_effort !== void 0) result.reasoning_effort = kwargs.reasoning_effort;
+    if (kwargs.clear_thinking !== void 0) result.clear_thinking = kwargs.clear_thinking;
+    return result;
+  }
+  async makeRequest(payload, headers, signal, preSerializedBody, isStreaming = false) {
+    let response;
+    try {
+      const timeoutController = new AbortController();
+      const timeoutId = setTimeout(() => timeoutController.abort(), this.timeout);
+      const combinedSignal = signal ? this.combineSignals(signal, timeoutController.signal) : timeoutController.signal;
+      try {
+        response = await fetch(`${this.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers,
+          body: _nullishCoalesce(preSerializedBody, () => ( JSON.stringify(payload))),
+          signal: combinedSignal
+        });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && _optionalChain([signal, 'optionalAccess', _6 => _6.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 = _optionalChain([json, 'optionalAccess', _7 => _7.choices, 'optionalAccess', _8 => _8[0], 'optionalAccess', _9 => _9.message]);
+    const text = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _10 => _10.content]), () => ( ""));
+    const finishReason = _optionalChain([json, 'optionalAccess', _11 => _11.choices, 'optionalAccess', _12 => _12[0], 'optionalAccess', _13 => _13.finish_reason]);
+    let toolCalls;
+    if (_optionalChain([message, 'optionalAccess', _14 => _14.tool_calls]) && Array.isArray(message.tool_calls)) {
+      toolCalls = message.tool_calls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: _nullishCoalesce(_optionalChain([tc, 'access', _15 => _15.function, 'optionalAccess', _16 => _16.name]), () => ( "")),
+          arguments: _nullishCoalesce(_optionalChain([tc, 'access', _17 => _17.function, 'optionalAccess', _18 => _18.arguments]), () => ( "{}"))
+        }
+      }));
+    }
+    const usage = normalizeLLMUsage(_optionalChain([json, 'optionalAccess', _19 => _19.usage]));
+    return {
+      id: _nullishCoalesce(json.id, () => ( "nvidia-response")),
+      created: _nullishCoalesce(json.created, () => ( Date.now())),
+      content: text,
+      toolCalls,
+      finishReason,
+      usage,
+      raw: json
+    };
+  }
+  async handleStreamingResponse(response) {
+    const reader = _optionalChain([response, 'access', _20 => _20.body, 'optionalAccess', _21 => _21.getReader, 'call', _22 => _22()]);
+    if (!reader) {
+      throw new Error("No response body for streaming");
+    }
+    const decoder = new TextDecoder();
+    let fullContent = "";
+    let fullReasoning = "";
+    let lastChunk = null;
+    let finishReason = "stop";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        const lines = chunk.split("\n").filter((line) => line.trim());
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const dataStr = line.slice(6).trim();
+            if (dataStr === "[DONE]") continue;
+            try {
+              const data = JSON.parse(dataStr);
+              lastChunk = data;
+              const delta = _optionalChain([data, 'access', _23 => _23.choices, 'optionalAccess', _24 => _24[0], 'optionalAccess', _25 => _25.delta]);
+              if (!delta) continue;
+              const reasoning = delta.reasoning || delta.reasoning_content;
+              if (reasoning) {
+                fullReasoning += reasoning;
+              }
+              if (delta.content) {
+                fullContent += delta.content;
+              }
+              if (_optionalChain([data, 'access', _26 => _26.choices, 'optionalAccess', _27 => _27[0], 'optionalAccess', _28 => _28.finish_reason])) {
+                finishReason = data.choices[0].finish_reason;
+              }
+            } catch (e) {
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const finalContent = fullReasoning ? `<thinking>${fullReasoning}</thinking>
+
+${fullContent}` : fullContent;
+    return {
+      id: _nullishCoalesce(_optionalChain([lastChunk, 'optionalAccess', _29 => _29.id]), () => ( `nvidia-stream-${Date.now()}`)),
+      created: _nullishCoalesce(_optionalChain([lastChunk, 'optionalAccess', _30 => _30.created]), () => ( Math.floor(Date.now() / 1e3))),
+      content: finalContent,
+      finishReason,
+      raw: { content: fullContent, reasoning: fullReasoning, chunks: lastChunk }
+    };
+  }
+  async buildFriendlyError(response) {
+    const status = response.status;
+    let errorDetail = "";
+    try {
+      const body = await response.json();
+      errorDetail = _optionalChain([body, 'optionalAccess', _31 => _31.error, 'optionalAccess', _32 => _32.message]) || _optionalChain([body, 'optionalAccess', _33 => _33.error]) || _optionalChain([body, 'optionalAccess', _34 => _34.message]) || "";
+      if (typeof errorDetail === "object") {
+        errorDetail = JSON.stringify(errorDetail);
+      }
+    } catch (e2) {
+      try {
+        errorDetail = await response.text();
+      } catch (e3) {
+      }
+    }
+    const friendlyMessage = FRIENDLY_ERRORS[status];
+    const classified = _chunk3OF56EMAcjs.classifyApiError.call(void 0, status, errorDetail, response.headers);
+    if (friendlyMessage) {
+      return new (0, _chunk3OF56EMAcjs.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 (0, _chunk3OF56EMAcjs.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 (0, _chunk3OF56EMAcjs.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 (0, _chunk3OF56EMAcjs.ApiError)(
+      message,
+      classified.code,
+      classified.httpStatus,
+      classified.retryable,
+      classified.retryAfterMs,
+      errorDetail
+    );
+  }
+  isNonRetryableError(error) {
+    if (error instanceof _chunk3OF56EMAcjs.ApiError) {
+      return !error.retryable;
+    }
+    const message = error.message.toLowerCase();
+    if (message.includes("cancelled") || message.includes("aborted")) {
+      return true;
+    }
+    if (message.includes("authentication") || message.includes("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 {
+  
+  
+  
+  
+  constructor(config, networkSettings) {
+    this.client = new NVIDIAClient(config, networkSettings);
+    this.model = config.model;
+    this.chatTemplateKwargs = config.chatTemplateKwargs;
+    this.stream = _nullishCoalesce(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: _nullishCoalesce(request.stream, () => ( this.stream)),
+      // Merge chatTemplateKwargs: request-level takes precedence
+      chatTemplateKwargs: _nullishCoalesce(request.chatTemplateKwargs, () => ( this.chatTemplateKwargs))
+    };
+    return this.client.complete(enhancedRequest);
+  }
+};
+
+
+
+
+
+
+
+exports.normalizeLLMUsage = normalizeLLMUsage; exports.NVIDIA_DEFAULT_BASE_URL = NVIDIA_DEFAULT_BASE_URL2; exports.NVIDIA_MODELS = NVIDIA_MODELS; exports.NVIDIA_DEFAULT_MODEL = NVIDIA_DEFAULT_MODEL; exports.NVIDIAProvider = NVIDIAProvider;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */