claudish 4.6.7 → 4.6.8

package/dist/index.js

@@ -32800,6 +32800,8 @@ var init_model_parser = __esm(() => {
     lc: "ollamacloud",
     meta: "ollamacloud",
     poe: "poe",
+    litellm: "litellm",
+    ll: "litellm",
     ollama: "ollama",
     lms: "lmstudio",
     lmstudio: "lmstudio",
@@ -32820,7 +32822,8 @@ var init_model_parser = __esm(() => {
     "opencode-zen",
     "vertex",
     "gemini-codeassist",
-    "poe"
+    "poe",
+    "litellm"
   ]);
   LOCAL_PROVIDERS = new Set(["ollama", "lmstudio", "vllm", "mlx"]);
   NATIVE_MODEL_PATTERNS = [
@@ -33041,7 +33044,8 @@ function resolveRemoteProvider(modelId) {
     ollamacloud: "ollamacloud",
     "opencode-zen": "opencode-zen",
     vertex: "vertex",
-    "gemini-codeassist": "gemini-codeassist"
+    "gemini-codeassist": "gemini-codeassist",
+    litellm: "litellm"
   };
   const mappedProviderName = providerNameMap[parsed.provider];
   if (mappedProviderName) {
@@ -33253,6 +33257,20 @@ var getRemoteProviders = () => [
       supportsJsonMode: false,
       supportsReasoning: true
     }
+  },
+  {
+    name: "litellm",
+    baseUrl: process.env.LITELLM_BASE_URL || "",
+    apiPath: "/v1/chat/completions",
+    apiKeyEnvVar: "LITELLM_API_KEY",
+    prefixes: ["litellm/", "ll/"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      supportsReasoning: true
+    }
   }
 ];
 var init_remote_provider_registry = __esm(() => {
@@ -33592,6 +33610,11 @@ var init_provider_resolver = __esm(() => {
       envVar: "ZAI_API_KEY",
       description: "Z.AI API Key",
       url: "https://z.ai/"
+    },
+    litellm: {
+      envVar: "LITELLM_API_KEY",
+      description: "LiteLLM API Key",
+      url: "https://docs.litellm.ai/"
     }
   };
   PROVIDER_DISPLAY_NAMES = {
@@ -33607,7 +33630,8 @@ var init_provider_resolver = __esm(() => {
     "glm-coding": "GLM Coding",
     zai: "Z.AI",
     ollamacloud: "OllamaCloud",
-    "opencode-zen": "OpenCode Zen"
+    "opencode-zen": "OpenCode Zen",
+    litellm: "LiteLLM"
   };
 });
 
@@ -34890,7 +34914,7 @@ async function fetchGLMCodingModels2() {
     return [];
   }
 }
-var __filename5, __dirname5, VERSION = "4.6.7", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, CLAUDISH_CACHE_DIR3, ALL_MODELS_JSON_PATH2;
+var __filename5, __dirname5, VERSION = "4.6.8", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, CLAUDISH_CACHE_DIR3, ALL_MODELS_JSON_PATH2;
 var init_cli = __esm(() => {
   init_config();
   init_model_loader();
@@ -65417,10 +65441,212 @@ var init_ollamacloud_handler = __esm(() => {
   init_remote_provider_types();
 });
 
-// src/services/pricing-cache.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync16, existsSync as existsSync12, mkdirSync as mkdirSync16, statSync } from "node:fs";
+// src/handlers/shared/remote-provider-handler.ts
+import { writeFileSync as writeFileSync16, mkdirSync as mkdirSync16 } from "node:fs";
 import { homedir as homedir19 } from "node:os";
 import { join as join20 } from "node:path";
+
+class RemoteProviderHandler {
+  targetModel;
+  modelName;
+  apiKey;
+  adapterManager;
+  middlewareManager;
+  port;
+  sessionTotalCost = 0;
+  sessionInputTokens = 0;
+  sessionOutputTokens = 0;
+  contextWindow = 200000;
+  CLAUDE_INTERNAL_CONTEXT_MAX = 200000;
+  constructor(targetModel, modelName, apiKey, port) {
+    this.targetModel = targetModel;
+    this.modelName = modelName;
+    this.apiKey = apiKey;
+    this.port = port;
+    this.adapterManager = new AdapterManager(targetModel);
+    this.middlewareManager = new MiddlewareManager;
+    this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
+    this.middlewareManager.initialize().catch((err) => log(`[Handler:${targetModel}] Middleware init error: ${err}`));
+  }
+  getAdditionalHeaders() {
+    return {};
+  }
+  getApiEndpoint() {
+    const config3 = this.getProviderConfig();
+    return `${config3.baseUrl}${config3.apiPath}`;
+  }
+  supportsReasoning() {
+    return false;
+  }
+  writeTokenFile(input, output) {
+    try {
+      const total = input + output;
+      const leftPct = this.contextWindow > 0 ? Math.max(0, Math.min(100, Math.round((this.contextWindow - total) / this.contextWindow * 100))) : 100;
+      const pricing = this.getPricing();
+      const data = {
+        input_tokens: input,
+        output_tokens: output,
+        total_tokens: total,
+        total_cost: this.sessionTotalCost,
+        context_window: this.contextWindow,
+        context_left_percent: leftPct,
+        is_free: pricing.isFree || false,
+        is_estimated: pricing.isEstimate || false,
+        provider_name: this.getProviderName(),
+        model_name: this.modelName,
+        updated_at: Date.now()
+      };
+      const claudishDir = join20(homedir19(), ".claudish");
+      mkdirSync16(claudishDir, { recursive: true });
+      writeFileSync16(join20(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+    } catch (e) {
+      log(`[Handler] Error writing token file: ${e}`);
+    }
+  }
+  updateTokenTracking(inputTokens, outputTokens) {
+    this.sessionInputTokens = inputTokens;
+    this.sessionOutputTokens += outputTokens;
+    const pricing = this.getPricing();
+    const cost = inputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M;
+    this.sessionTotalCost += cost;
+    this.writeTokenFile(inputTokens, this.sessionOutputTokens);
+  }
+  convertMessages(claudeRequest) {
+    return convertMessagesToOpenAI(claudeRequest, this.targetModel, filterIdentity);
+  }
+  convertTools(claudeRequest) {
+    return convertToolsToOpenAI(claudeRequest);
+  }
+  handleStreamingResponse(c, response, adapter, claudeRequest, toolNameMap) {
+    return createStreamingResponseHandler(c, response, adapter, this.targetModel, this.middlewareManager, (input, output) => this.updateTokenTracking(input, output), claudeRequest.tools, toolNameMap);
+  }
+  async handle(c, payload) {
+    const config3 = this.getProviderConfig();
+    const { claudeRequest, droppedParams } = transformOpenAIToClaude(payload);
+    const messages = this.convertMessages(claudeRequest);
+    const tools = this.convertTools(claudeRequest);
+    const systemPromptLength = typeof claudeRequest.system === "string" ? claudeRequest.system.length : 0;
+    logStructured(`${config3.name} Request`, {
+      targetModel: this.targetModel,
+      originalModel: payload.model,
+      messageCount: messages.length,
+      toolCount: tools.length,
+      systemPromptLength,
+      maxTokens: claudeRequest.max_tokens
+    });
+    if (getLogLevel() === "debug") {
+      const lastUserMsg = messages.filter((m) => m.role === "user").pop();
+      if (lastUserMsg) {
+        const content = typeof lastUserMsg.content === "string" ? lastUserMsg.content : JSON.stringify(lastUserMsg.content);
+        log(`[${config3.name}] Last user message: ${truncateContent(content, 500)}`);
+      }
+      if (tools.length > 0) {
+        const toolNames = tools.map((t) => t.function?.name || t.name).join(", ");
+        log(`[${config3.name}] Tools: ${toolNames}`);
+      }
+    }
+    const requestPayload = this.buildRequestPayload(claudeRequest, messages, tools);
+    const adapter = this.adapterManager.getAdapter();
+    if (typeof adapter.reset === "function")
+      adapter.reset();
+    adapter.prepareRequest(requestPayload, claudeRequest);
+    const toolNameMap = adapter.getToolNameMap();
+    await this.middlewareManager.beforeRequest({
+      modelId: this.targetModel,
+      messages,
+      tools,
+      stream: true
+    });
+    const endpoint = this.getApiEndpoint();
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      ...this.getAdditionalHeaders()
+    };
+    log(`[${config3.name}] Calling API: ${endpoint}`);
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestPayload)
+    });
+    log(`[${config3.name}] Response status: ${response.status}`);
+    if (!response.ok) {
+      const errorText = await response.text();
+      log(`[${config3.name}] Error: ${errorText}`);
+      return c.json({ error: errorText }, response.status);
+    }
+    if (droppedParams.length > 0) {
+      c.header("X-Dropped-Params", droppedParams.join(", "));
+    }
+    return this.handleStreamingResponse(c, response, adapter, claudeRequest, toolNameMap);
+  }
+  async shutdown() {}
+}
+var init_remote_provider_handler = __esm(() => {
+  init_adapter_manager();
+  init_middleware();
+  init_transform();
+  init_logger();
+  init_openai_compat();
+});
+
+// src/handlers/litellm-handler.ts
+var LiteLLMHandler;
+var init_litellm_handler = __esm(() => {
+  init_remote_provider_handler();
+  LiteLLMHandler = class LiteLLMHandler extends RemoteProviderHandler {
+    baseUrl;
+    constructor(targetModel, modelName, apiKey, port, baseUrl) {
+      super(targetModel, modelName, apiKey, port);
+      this.baseUrl = baseUrl;
+    }
+    getProviderConfig() {
+      return {
+        name: "litellm",
+        baseUrl: this.baseUrl,
+        apiPath: "/v1/chat/completions",
+        apiKeyEnvVar: "LITELLM_API_KEY"
+      };
+    }
+    getPricing() {
+      return {
+        inputCostPer1M: 1,
+        outputCostPer1M: 4,
+        isEstimate: true
+      };
+    }
+    getProviderName() {
+      return "LiteLLM";
+    }
+    buildRequestPayload(claudeRequest, messages, tools) {
+      const payload = {
+        model: this.modelName,
+        messages,
+        temperature: claudeRequest.temperature ?? 1,
+        stream: true,
+        stream_options: { include_usage: true },
+        max_tokens: claudeRequest.max_tokens
+      };
+      if (tools.length > 0) {
+        payload.tools = tools;
+      }
+      if (claudeRequest.tool_choice) {
+        const { type, name } = claudeRequest.tool_choice;
+        if (type === "tool" && name) {
+          payload.tool_choice = { type: "function", function: { name } };
+        } else if (type === "auto" || type === "none") {
+          payload.tool_choice = type;
+        }
+      }
+      return payload;
+    }
+  };
+});
+
+// src/services/pricing-cache.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync17, existsSync as existsSync12, mkdirSync as mkdirSync17, statSync } from "node:fs";
+import { homedir as homedir20 } from "node:os";
+import { join as join21 } from "node:path";
 function getDynamicPricingSync(provider, modelName) {
   if (provider === "openrouter") {
     const direct = pricingMap.get(modelName);
@@ -65502,12 +65728,12 @@ function loadDiskCache() {
 }
 function saveDiskCache() {
   try {
-    mkdirSync16(CACHE_DIR, { recursive: true });
+    mkdirSync17(CACHE_DIR, { recursive: true });
     const data = {};
     for (const [key, pricing] of pricingMap) {
       data[key] = pricing;
     }
-    writeFileSync16(CACHE_FILE, JSON.stringify(data), "utf-8");
+    writeFileSync17(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch (error46) {
     log(`[PricingCache] Error saving disk cache: ${error46}`);
   }
@@ -65537,8 +65763,8 @@ var init_pricing_cache = __esm(() => {
   init_model_loader();
   init_remote_provider_types();
   pricingMap = new Map;
-  CACHE_DIR = join20(homedir19(), ".claudish");
-  CACHE_FILE = join20(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join21(homedir20(), ".claudish");
+  CACHE_FILE = join21(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS = 24 * 60 * 60 * 1000;
   PROVIDER_TO_OR_PREFIX = {
     openai: ["openai/"],
@@ -65660,6 +65886,15 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
       } else if (resolved.provider.name === "ollamacloud") {
         handler = new OllamaCloudHandler(resolved.provider, resolved.modelName, apiKey, port);
         log(`[Proxy] Created OllamaCloud handler: ${resolved.modelName}`);
+      } else if (resolved.provider.name === "litellm") {
+        if (!resolved.provider.baseUrl) {
+          console.error("Error: LITELLM_BASE_URL or --litellm-url is required for LiteLLM provider.");
+          console.error("Set it with: export LITELLM_BASE_URL='https://your-litellm-instance.com'");
+          console.error("Or use: claudish --litellm-url https://your-instance.com --model litellm@model 'task'");
+          return null;
+        }
+        handler = new LiteLLMHandler(targetModel, resolved.modelName, apiKey, port, resolved.provider.baseUrl);
+        log(`[Proxy] Created LiteLLM handler: ${resolved.modelName} (${resolved.provider.baseUrl})`);
       } else if (resolved.provider.name === "vertex") {
         const hasApiKey = !!process.env.VERTEX_API_KEY;
         const vertexConfig = getVertexConfig();
@@ -65794,6 +66029,7 @@ var init_proxy_server = __esm(() => {
   init_vertex_oauth_handler();
   init_poe_handler();
   init_ollamacloud_handler();
+  init_litellm_handler();
   init_provider_registry();
   init_model_parser();
   init_remote_provider_registry();
@@ -65811,9 +66047,9 @@ __export(exports_update_checker, {
   checkForUpdates: () => checkForUpdates
 });
 import { execSync } from "node:child_process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync17, readFileSync as readFileSync10, unlinkSync as unlinkSync4, writeFileSync as writeFileSync17 } from "node:fs";
-import { homedir as homedir20, platform as platform2, tmpdir as tmpdir2 } from "node:os";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync18, readFileSync as readFileSync10, unlinkSync as unlinkSync4, writeFileSync as writeFileSync18 } from "node:fs";
+import { homedir as homedir21, platform as platform2, tmpdir as tmpdir2 } from "node:os";
+import { join as join22 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 function getUpdateCommand() {
   const scriptPath = process.argv[1] || "";
@@ -65825,18 +66061,18 @@ function getUpdateCommand() {
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows2) {
-    const localAppData = process.env.LOCALAPPDATA || join21(homedir20(), "AppData", "Local");
-    cacheDir = join21(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join22(homedir21(), "AppData", "Local");
+    cacheDir = join22(localAppData, "claudish");
   } else {
-    cacheDir = join21(homedir20(), ".cache", "claudish");
+    cacheDir = join22(homedir21(), ".cache", "claudish");
   }
   try {
     if (!existsSync13(cacheDir)) {
-      mkdirSync17(cacheDir, { recursive: true });
+      mkdirSync18(cacheDir, { recursive: true });
     }
-    return join21(cacheDir, "update-check.json");
+    return join22(cacheDir, "update-check.json");
   } catch {
-    return join21(tmpdir2(), "claudish-update-check.json");
+    return join22(tmpdir2(), "claudish-update-check.json");
   }
 }
 function readCache() {
@@ -65858,7 +66094,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync17(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync18(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "4.6.7",
+  "version": "4.6.8",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",