claudish 4.6.7 → 4.6.9

package/dist/index.js

@@ -31010,11 +31010,11 @@ async function doesModelSupportReasoning(modelId) {
   }
   return false;
 }
-async function fetchLiteLLMModels(baseUrl, apiKey) {
+async function fetchLiteLLMModels(baseUrl, apiKey, forceUpdate = false) {
   const hash2 = createHash2("sha256").update(baseUrl).digest("hex").substring(0, 16);
   const cacheDir = join6(homedir5(), ".claudish");
   const cachePath = join6(cacheDir, `litellm-models-${hash2}.json`);
-  if (existsSync6(cachePath)) {
+  if (!forceUpdate && existsSync6(cachePath)) {
     try {
       const cacheData = JSON.parse(readFileSync5(cachePath, "utf-8"));
       const timestamp = new Date(cacheData.timestamp);
@@ -31572,11 +31572,11 @@ async function getFreeModels() {
   });
   return combined;
 }
-async function getAllModelsForSearch() {
+async function getAllModelsForSearch(forceUpdate = false) {
   const litellmBaseUrl = process.env.LITELLM_BASE_URL;
   const litellmApiKey = process.env.LITELLM_API_KEY;
   const fetchEntries = [
-    { name: "OpenRouter", promise: fetchAllModels().then((models) => models.map(toModelInfo)) },
+    { name: "OpenRouter", promise: fetchAllModels(forceUpdate).then((models) => models.map(toModelInfo)) },
     { name: "xAI", promise: fetchXAIModels() },
     { name: "Gemini", promise: fetchGeminiModels() },
     { name: "OpenAI", promise: fetchOpenAIModels() },
@@ -31586,7 +31586,7 @@ async function getAllModelsForSearch() {
     { name: "Zen", promise: fetchZenFreeModels() }
   ];
   if (litellmBaseUrl && litellmApiKey) {
-    fetchEntries.push({ name: "LiteLLM", promise: fetchLiteLLMModels(litellmBaseUrl, litellmApiKey) });
+    fetchEntries.push({ name: "LiteLLM", promise: fetchLiteLLMModels(litellmBaseUrl, litellmApiKey, forceUpdate) });
   }
   const settled = await Promise.allSettled(fetchEntries.map((e) => e.promise));
   const fetchResults = {};
@@ -31686,7 +31686,7 @@ function fuzzyMatch(text, query) {
   return queryIdx === lowerQuery.length ? score / lowerQuery.length * 0.6 : 0;
 }
 async function selectModel(options = {}) {
-  const { freeOnly = false, recommended = true, message } = options;
+  const { freeOnly = false, recommended = true, message, forceUpdate = false } = options;
   let models;
   if (freeOnly) {
     models = await getFreeModels();
@@ -31695,7 +31695,7 @@ async function selectModel(options = {}) {
     }
   } else {
     const [allModels, recommendedModels] = await Promise.all([
-      getAllModelsForSearch(),
+      getAllModelsForSearch(forceUpdate),
       Promise.resolve(recommended ? loadRecommendedModels2() : [])
     ]);
     const seenIds = new Set;
@@ -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"
   };
 });
 
@@ -33624,13 +33648,34 @@ __export(exports_cli, {
   getMissingKeyResolutions: () => getMissingKeyResolutions,
   getMissingKeyError: () => getMissingKeyError
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync9, mkdirSync as mkdirSync6, copyFileSync } from "node:fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync9, mkdirSync as mkdirSync6, copyFileSync, readdirSync, unlinkSync as unlinkSync3 } from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { dirname as dirname4, join as join9 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 function getVersion() {
   return VERSION;
 }
+function clearAllModelCaches() {
+  const cacheDir = join9(homedir8(), ".claudish");
+  if (!existsSync9(cacheDir))
+    return;
+  const cachePatterns = ["all-models.json", "pricing-cache.json"];
+  let cleared = 0;
+  try {
+    const files = readdirSync(cacheDir);
+    for (const file2 of files) {
+      if (cachePatterns.includes(file2) || file2.startsWith("litellm-models-")) {
+        unlinkSync3(join9(cacheDir, file2));
+        cleared++;
+      }
+    }
+    if (cleared > 0) {
+      console.error(`\uD83D\uDDD1️  Cleared ${cleared} cache file(s)`);
+    }
+  } catch (error46) {
+    console.error(`Warning: Could not clear caches: ${error46}`);
+  }
+}
 async function parseArgs(args) {
   const config3 = {
     model: undefined,
@@ -33770,6 +33815,8 @@ async function parseArgs(args) {
     } else if (arg === "--top-models") {
       const hasJsonFlag = args.includes("--json");
       const forceUpdate = args.includes("--force-update");
+      if (forceUpdate)
+        clearAllModelCaches();
       await checkAndUpdateModelsCache(forceUpdate);
       if (hasJsonFlag) {
         printAvailableModelsJSON();
@@ -33777,12 +33824,14 @@ async function parseArgs(args) {
         printAvailableModels();
       }
       process.exit(0);
-    } else if (arg === "--models" || arg === "-s" || arg === "--search") {
+    } else if (arg === "--models" || arg === "--list-models" || arg === "-s" || arg === "--search") {
       const nextArg = args[i + 1];
       const hasQuery = nextArg && !nextArg.startsWith("--");
       const query = hasQuery ? args[++i] : null;
       const hasJsonFlag = args.includes("--json");
       const forceUpdate = args.includes("--force-update");
+      if (forceUpdate)
+        clearAllModelCaches();
       if (query) {
         await searchAndPrintModels(query, forceUpdate);
       } else {
@@ -34890,7 +34939,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.9", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, CLAUDISH_CACHE_DIR3, ALL_MODELS_JSON_PATH2;
 var init_cli = __esm(() => {
   init_config();
   init_model_loader();
@@ -34914,7 +34963,7 @@ __export(exports_claude_runner, {
   checkClaudeInstalled: () => checkClaudeInstalled
 });
 import { spawn } from "node:child_process";
-import { writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync7, existsSync as existsSync10 } from "node:fs";
+import { writeFileSync as writeFileSync7, unlinkSync as unlinkSync4, mkdirSync as mkdirSync7, existsSync as existsSync10 } from "node:fs";
 import { tmpdir, homedir as homedir9 } from "node:os";
 import { join as join10 } from "node:path";
 function isWindows() {
@@ -35137,7 +35186,7 @@ Or set CLAUDE_PATH to your custom installation:`);
     });
   });
   try {
-    unlinkSync3(tempSettingsPath);
+    unlinkSync4(tempSettingsPath);
   } catch (error46) {}
   return exitCode;
 }
@@ -35151,7 +35200,7 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet) {
       }
       proc.kill();
       try {
-        unlinkSync3(tempSettingsPath);
+        unlinkSync4(tempSettingsPath);
       } catch {}
       process.exit(0);
     });
@@ -65417,10 +65466,320 @@ 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);
+  }
+  supportsVision() {
+    return true;
+  }
+  convertMessages(claudeRequest) {
+    const messages = convertMessagesToOpenAI(claudeRequest, this.targetModel, filterIdentity);
+    if (!this.supportsVision()) {
+      for (const msg of messages) {
+        if (Array.isArray(msg.content)) {
+          msg.content = msg.content.filter((part) => part.type !== "image_url");
+          if (msg.content.length === 1 && msg.content[0].type === "text") {
+            msg.content = msg.content[0].text;
+          } else if (msg.content.length === 0) {
+            msg.content = "";
+          }
+        }
+      }
+    }
+    return messages;
+  }
+  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
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { homedir as homedir20 } from "node:os";
+import { join as join21 } from "node:path";
+var INLINE_IMAGE_MODEL_PATTERNS, MODEL_EXTRA_HEADERS, LiteLLMHandler;
+var init_litellm_handler = __esm(() => {
+  init_remote_provider_handler();
+  init_logger();
+  INLINE_IMAGE_MODEL_PATTERNS = ["minimax"];
+  MODEL_EXTRA_HEADERS = [
+    { pattern: "kimi", headers: { "User-Agent": "claude-code/1.0" } }
+  ];
+  LiteLLMHandler = class LiteLLMHandler extends RemoteProviderHandler {
+    baseUrl;
+    modelVisionSupported;
+    needsInlineImages;
+    constructor(targetModel, modelName, apiKey, port, baseUrl) {
+      super(targetModel, modelName, apiKey, port);
+      this.baseUrl = baseUrl;
+      this.modelVisionSupported = this.checkVisionSupport();
+      this.needsInlineImages = INLINE_IMAGE_MODEL_PATTERNS.some((p) => this.modelName.toLowerCase().includes(p));
+    }
+    supportsVision() {
+      return this.modelVisionSupported;
+    }
+    convertMessages(claudeRequest) {
+      const messages = super.convertMessages(claudeRequest);
+      if (!this.needsInlineImages)
+        return messages;
+      for (const msg of messages) {
+        if (!Array.isArray(msg.content))
+          continue;
+        const newContent = [];
+        let inlineImages = "";
+        for (const part of msg.content) {
+          if (part.type === "image_url") {
+            const url2 = typeof part.image_url === "string" ? part.image_url : part.image_url?.url;
+            if (url2?.startsWith("data:")) {
+              const base64Match = url2.match(/^data:[^;]+;base64,(.+)$/);
+              if (base64Match) {
+                inlineImages += `
+[Image base64:${base64Match[1]}]`;
+                log(`[LiteLLM] Converted image_url to inline base64 for ${this.modelName}`);
+              }
+            } else if (url2) {
+              inlineImages += `
+[Image URL: ${url2}]`;
+            }
+          } else {
+            newContent.push(part);
+          }
+        }
+        if (inlineImages) {
+          const lastText = newContent.findLast((p) => p.type === "text");
+          if (lastText) {
+            lastText.text += inlineImages;
+          } else {
+            newContent.push({ type: "text", text: inlineImages.trim() });
+          }
+        }
+        if (newContent.length === 1 && newContent[0].type === "text") {
+          msg.content = newContent[0].text;
+        } else if (newContent.length > 0) {
+          msg.content = newContent;
+        }
+      }
+      return messages;
+    }
+    checkVisionSupport() {
+      try {
+        const hash2 = createHash4("sha256").update(this.baseUrl).digest("hex").substring(0, 16);
+        const cachePath = join21(homedir20(), ".claudish", `litellm-models-${hash2}.json`);
+        if (!existsSync12(cachePath))
+          return true;
+        const cacheData = JSON.parse(readFileSync9(cachePath, "utf-8"));
+        const model = cacheData.models?.find((m) => m.name === this.modelName);
+        if (model && model.supportsVision === false) {
+          log(`[LiteLLM] Model ${this.modelName} does not support vision, images will be stripped`);
+          return false;
+        }
+        return true;
+      } catch {
+        return true;
+      }
+    }
+    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;
+        }
+      }
+      const extraHeaders = this.getExtraHeaders();
+      if (extraHeaders) {
+        payload.extra_headers = extraHeaders;
+      }
+      return payload;
+    }
+    getExtraHeaders() {
+      const model = this.modelName.toLowerCase();
+      const merged = {};
+      let found = false;
+      for (const { pattern, headers } of MODEL_EXTRA_HEADERS) {
+        if (model.includes(pattern)) {
+          Object.assign(merged, headers);
+          found = true;
+        }
+      }
+      return found ? merged : null;
+    }
+  };
+});
+
+// src/services/pricing-cache.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync17, existsSync as existsSync13, mkdirSync as mkdirSync17, statSync } from "node:fs";
+import { homedir as homedir21 } from "node:os";
+import { join as join22 } from "node:path";
 function getDynamicPricingSync(provider, modelName) {
   if (provider === "openrouter") {
     const direct = pricingMap.get(modelName);
@@ -65485,12 +65844,12 @@ async function warmPricingCache() {
 }
 function loadDiskCache() {
   try {
-    if (!existsSync12(CACHE_FILE))
+    if (!existsSync13(CACHE_FILE))
       return false;
     const stat = statSync(CACHE_FILE);
     const age = Date.now() - stat.mtimeMs;
     const isFresh = age < CACHE_TTL_MS;
-    const raw2 = readFileSync9(CACHE_FILE, "utf-8");
+    const raw2 = readFileSync10(CACHE_FILE, "utf-8");
     const data = JSON.parse(raw2);
     for (const [key, pricing] of Object.entries(data)) {
       pricingMap.set(key, pricing);
@@ -65502,12 +65861,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 +65896,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 = join22(homedir21(), ".claudish");
+  CACHE_FILE = join22(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS = 24 * 60 * 60 * 1000;
   PROVIDER_TO_OR_PREFIX = {
     openai: ["openai/"],
@@ -65660,6 +66019,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 +66162,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 +66180,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 existsSync14, mkdirSync as mkdirSync18, readFileSync as readFileSync11, unlinkSync as unlinkSync5, writeFileSync as writeFileSync18 } from "node:fs";
+import { homedir as homedir22, platform as platform2, tmpdir as tmpdir2 } from "node:os";
+import { join as join23 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 function getUpdateCommand() {
   const scriptPath = process.argv[1] || "";
@@ -65825,27 +66194,27 @@ 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 || join23(homedir22(), "AppData", "Local");
+    cacheDir = join23(localAppData, "claudish");
   } else {
-    cacheDir = join21(homedir20(), ".cache", "claudish");
+    cacheDir = join23(homedir22(), ".cache", "claudish");
   }
   try {
-    if (!existsSync13(cacheDir)) {
-      mkdirSync17(cacheDir, { recursive: true });
+    if (!existsSync14(cacheDir)) {
+      mkdirSync18(cacheDir, { recursive: true });
     }
-    return join21(cacheDir, "update-check.json");
+    return join23(cacheDir, "update-check.json");
   } catch {
-    return join21(tmpdir2(), "claudish-update-check.json");
+    return join23(tmpdir2(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync13(cachePath)) {
+    if (!existsSync14(cachePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync10(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync11(cachePath, "utf-8"));
     return data;
   } catch {
     return null;
@@ -65858,7 +66227,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) {
@@ -65868,8 +66237,8 @@ function isCacheValid(cache) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync13(cachePath)) {
-      unlinkSync4(cachePath);
+    if (existsSync14(cachePath)) {
+      unlinkSync5(cachePath);
     }
   } catch {}
 }

package/package.json

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

package/recommended-models.json

@@ -1,6 +1,6 @@
 {
   "version": "1.2.0",
-  "lastUpdated": "2026-02-14",
+  "lastUpdated": "2026-02-15",
   "source": "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
   "models": [
     {