claudish 5.1.1 → 5.2.0

package/dist/index.js

@@ -33320,6 +33320,275 @@ var init_remote_provider_registry = __esm(() => {
   init_model_parser();
 });
 
+// src/auth/oauth-registry.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
+import { join as join8 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+function hasValidOAuthCredentials(descriptor) {
+  const credPath = join8(homedir7(), ".claudish", descriptor.credentialFile);
+  if (!existsSync8(credPath))
+    return false;
+  if (descriptor.validationMode === "file-exists") {
+    return true;
+  }
+  try {
+    const data = JSON.parse(readFileSync7(credPath, "utf-8"));
+    if (!data.access_token)
+      return false;
+    if (data.refresh_token)
+      return true;
+    if (descriptor.expiresAtField && data[descriptor.expiresAtField]) {
+      const buffer = descriptor.expiryBufferMs ?? 0;
+      return data[descriptor.expiresAtField] > Date.now() + buffer;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasOAuthCredentials(providerName) {
+  const descriptor = OAUTH_PROVIDERS[providerName];
+  if (!descriptor)
+    return false;
+  return hasValidOAuthCredentials(descriptor);
+}
+var OAUTH_PROVIDERS;
+var init_oauth_registry = __esm(() => {
+  OAUTH_PROVIDERS = {
+    "kimi-coding": {
+      credentialFile: "kimi-oauth.json",
+      validationMode: "check-expiry",
+      expiresAtField: "expires_at",
+      expiryBufferMs: 5 * 60 * 1000
+    },
+    kimi: {
+      credentialFile: "kimi-oauth.json",
+      validationMode: "check-expiry",
+      expiresAtField: "expires_at",
+      expiryBufferMs: 5 * 60 * 1000
+    },
+    google: {
+      credentialFile: "gemini-oauth.json",
+      validationMode: "check-expiry",
+      expiresAtField: "expires_at",
+      expiryBufferMs: 5 * 60 * 1000
+    },
+    "gemini-codeassist": {
+      credentialFile: "gemini-oauth.json",
+      validationMode: "check-expiry",
+      expiresAtField: "expires_at",
+      expiryBufferMs: 5 * 60 * 1000
+    }
+  };
+});
+
+// src/providers/auto-route.ts
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:fs";
+import { join as join9 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { createHash as createHash3 } from "node:crypto";
+function readLiteLLMCacheSync(baseUrl) {
+  const hash2 = createHash3("sha256").update(baseUrl).digest("hex").substring(0, 16);
+  const cachePath = join9(homedir8(), ".claudish", `litellm-models-${hash2}.json`);
+  if (!existsSync9(cachePath))
+    return null;
+  try {
+    const data = JSON.parse(readFileSync8(cachePath, "utf-8"));
+    if (!Array.isArray(data.models))
+      return null;
+    return data.models;
+  } catch {
+    return null;
+  }
+}
+function checkOAuthForProvider(nativeProvider, modelName) {
+  if (!hasOAuthCredentials(nativeProvider))
+    return null;
+  return {
+    provider: nativeProvider,
+    resolvedModelId: modelName,
+    modelName,
+    reason: "oauth-credentials",
+    displayMessage: `Auto-routed: ${modelName} -> ${nativeProvider} (oauth)`
+  };
+}
+function checkApiKeyForProvider(nativeProvider, modelName) {
+  const keyInfo = API_KEY_ENV_VARS[nativeProvider];
+  if (!keyInfo)
+    return null;
+  if (keyInfo.envVar && process.env[keyInfo.envVar]) {
+    return {
+      provider: nativeProvider,
+      resolvedModelId: modelName,
+      modelName,
+      reason: "api-key",
+      displayMessage: `Auto-routed: ${modelName} -> ${nativeProvider} (api-key)`
+    };
+  }
+  if (keyInfo.aliases) {
+    for (const alias of keyInfo.aliases) {
+      if (process.env[alias]) {
+        return {
+          provider: nativeProvider,
+          resolvedModelId: modelName,
+          modelName,
+          reason: "api-key",
+          displayMessage: `Auto-routed: ${modelName} -> ${nativeProvider} (api-key)`
+        };
+      }
+    }
+  }
+  return null;
+}
+function formatForOpenRouter(modelName, nativeProvider) {
+  if (modelName.includes("/")) {
+    return modelName;
+  }
+  const vendor = OPENROUTER_VENDOR_MAP[nativeProvider];
+  if (vendor) {
+    return `${vendor}/${modelName}`;
+  }
+  return modelName;
+}
+function getAutoRouteHint(modelName, nativeProvider) {
+  const hint = PROVIDER_HINT_MAP[nativeProvider];
+  const lines = [
+    `No credentials found for "${modelName}". Options:`
+  ];
+  let hasOption = false;
+  if (hint?.loginFlag) {
+    lines.push(`  Run:  claudish ${hint.loginFlag}  (authenticate via OAuth)`);
+    hasOption = true;
+  }
+  if (hint?.apiKeyEnvVar) {
+    lines.push(`  Set:  export ${hint.apiKeyEnvVar}=your-key`);
+    hasOption = true;
+  }
+  if (hint?.openRouterModel) {
+    lines.push(`  Use:  claudish --model or@${hint.openRouterModel}  (route via OpenRouter)`);
+    hasOption = true;
+  }
+  if (!hasOption) {
+    return null;
+  }
+  lines.push(`  Or set OPENROUTER_API_KEY for automatic OpenRouter fallback`);
+  return lines.join(`
+`);
+}
+function autoRoute(modelName, nativeProvider) {
+  const litellmBaseUrl = process.env.LITELLM_BASE_URL;
+  if (litellmBaseUrl) {
+    const models = readLiteLLMCacheSync(litellmBaseUrl);
+    if (models !== null) {
+      const match = models.find((m) => m.name === modelName || m.id === `litellm@${modelName}`);
+      if (match) {
+        return {
+          provider: "litellm",
+          resolvedModelId: `litellm@${modelName}`,
+          modelName,
+          reason: "litellm-cache",
+          displayMessage: `Auto-routed: ${modelName} -> litellm`
+        };
+      }
+    }
+  }
+  if (nativeProvider !== "unknown") {
+    const oauthResult = checkOAuthForProvider(nativeProvider, modelName);
+    if (oauthResult)
+      return oauthResult;
+  }
+  if (nativeProvider !== "unknown") {
+    const apiKeyResult = checkApiKeyForProvider(nativeProvider, modelName);
+    if (apiKeyResult)
+      return apiKeyResult;
+  }
+  if (process.env.OPENROUTER_API_KEY) {
+    const orModelId = formatForOpenRouter(modelName, nativeProvider);
+    return {
+      provider: "openrouter",
+      resolvedModelId: orModelId,
+      modelName,
+      reason: "openrouter-fallback",
+      displayMessage: `Auto-routed: ${modelName} -> openrouter`
+    };
+  }
+  return null;
+}
+var API_KEY_ENV_VARS, OPENROUTER_VENDOR_MAP, PROVIDER_HINT_MAP;
+var init_auto_route = __esm(() => {
+  init_oauth_registry();
+  API_KEY_ENV_VARS = {
+    google: { envVar: "GEMINI_API_KEY" },
+    "gemini-codeassist": { envVar: "GEMINI_API_KEY" },
+    openai: { envVar: "OPENAI_API_KEY" },
+    minimax: { envVar: "MINIMAX_API_KEY" },
+    "minimax-coding": { envVar: "MINIMAX_CODING_API_KEY" },
+    kimi: { envVar: "MOONSHOT_API_KEY", aliases: ["KIMI_API_KEY"] },
+    "kimi-coding": { envVar: "KIMI_CODING_API_KEY" },
+    glm: { envVar: "ZHIPU_API_KEY", aliases: ["GLM_API_KEY"] },
+    "glm-coding": { envVar: "GLM_CODING_API_KEY", aliases: ["ZAI_CODING_API_KEY"] },
+    zai: { envVar: "ZAI_API_KEY" },
+    ollamacloud: { envVar: "OLLAMA_API_KEY" },
+    litellm: { envVar: "LITELLM_API_KEY" },
+    openrouter: { envVar: "OPENROUTER_API_KEY" },
+    vertex: { envVar: "VERTEX_API_KEY", aliases: ["VERTEX_PROJECT"] },
+    poe: { envVar: "POE_API_KEY" }
+  };
+  OPENROUTER_VENDOR_MAP = {
+    google: "google",
+    openai: "openai",
+    kimi: "moonshot",
+    "kimi-coding": "moonshot",
+    glm: "zhipuai",
+    "glm-coding": "zhipuai",
+    minimax: "minimax",
+    ollamacloud: "meta-llama"
+  };
+  PROVIDER_HINT_MAP = {
+    "kimi-coding": {
+      loginFlag: "--kimi-login",
+      apiKeyEnvVar: "KIMI_CODING_API_KEY",
+      openRouterModel: "moonshot/kimi-k2"
+    },
+    kimi: {
+      loginFlag: "--kimi-login",
+      apiKeyEnvVar: "MOONSHOT_API_KEY",
+      openRouterModel: "moonshot/moonshot-v1-8k"
+    },
+    google: {
+      loginFlag: "--gemini-login",
+      apiKeyEnvVar: "GEMINI_API_KEY",
+      openRouterModel: "google/gemini-2.0-flash"
+    },
+    "gemini-codeassist": {
+      loginFlag: "--gemini-login",
+      apiKeyEnvVar: "GEMINI_API_KEY",
+      openRouterModel: "google/gemini-2.0-flash"
+    },
+    openai: {
+      apiKeyEnvVar: "OPENAI_API_KEY",
+      openRouterModel: "openai/gpt-4o"
+    },
+    minimax: {
+      apiKeyEnvVar: "MINIMAX_API_KEY",
+      openRouterModel: "minimax/minimax-01"
+    },
+    "minimax-coding": {
+      apiKeyEnvVar: "MINIMAX_CODING_API_KEY"
+    },
+    glm: {
+      apiKeyEnvVar: "ZHIPU_API_KEY",
+      openRouterModel: "zhipuai/glm-4"
+    },
+    "glm-coding": {
+      apiKeyEnvVar: "GLM_CODING_API_KEY"
+    },
+    ollamacloud: {
+      apiKeyEnvVar: "OLLAMA_API_KEY"
+    }
+  };
+});
+
 // src/providers/provider-resolver.ts
 var exports_provider_resolver = {};
 __export(exports_provider_resolver, {
@@ -33331,9 +33600,9 @@ __export(exports_provider_resolver, {
   getMissingKeyResolutions: () => getMissingKeyResolutions,
   getMissingKeyError: () => getMissingKeyError
 });
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join8 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join10 } from "node:path";
+import { homedir as homedir9 } from "node:os";
 function isApiKeyAvailable(info) {
   if (!info.envVar) {
     return true;
@@ -33350,8 +33619,8 @@ function isApiKeyAvailable(info) {
   }
   if (info.oauthFallback) {
     try {
-      const credPath = join8(homedir7(), ".claudish", info.oauthFallback);
-      if (existsSync8(credPath)) {
+      const credPath = join10(homedir9(), ".claudish", info.oauthFallback);
+      if (existsSync10(credPath)) {
         return true;
       }
     } catch {}
@@ -33442,6 +33711,43 @@ function resolveModelProvider(modelId) {
       apiKeyUrl: info.url
     });
   }
+  let pendingAutoRouteMessage;
+  if (!parsed.isExplicitProvider && parsed.provider !== "native-anthropic") {
+    const autoResult = autoRoute(parsed.model, parsed.provider);
+    if (autoResult) {
+      if (autoResult.provider === "litellm") {
+        const info = API_KEY_INFO.litellm;
+        return addCommonFields({
+          category: "direct-api",
+          providerName: "LiteLLM",
+          modelName: autoResult.modelName,
+          fullModelId: autoResult.resolvedModelId,
+          requiredApiKeyEnvVar: info.envVar || null,
+          apiKeyAvailable: isApiKeyAvailable(info),
+          apiKeyDescription: info.description,
+          apiKeyUrl: info.url,
+          wasAutoRouted: true,
+          autoRouteMessage: autoResult.displayMessage
+        });
+      }
+      if (autoResult.provider === "openrouter") {
+        const info = API_KEY_INFO.openrouter;
+        return addCommonFields({
+          category: "openrouter",
+          providerName: "OpenRouter",
+          modelName: autoResult.modelName,
+          fullModelId: autoResult.resolvedModelId,
+          requiredApiKeyEnvVar: info.envVar,
+          apiKeyAvailable: isApiKeyAvailable(info),
+          apiKeyDescription: info.description,
+          apiKeyUrl: info.url,
+          wasAutoRouted: true,
+          autoRouteMessage: autoResult.displayMessage
+        });
+      }
+      pendingAutoRouteMessage = autoResult.displayMessage;
+    }
+  }
   const remoteResolved = resolveRemoteProvider(modelId);
   if (remoteResolved) {
     const provider = remoteResolved.provider;
@@ -33451,6 +33757,7 @@ function resolveModelProvider(modelId) {
       url: ""
     };
     const providerDisplayName = PROVIDER_DISPLAY_NAMES[provider.name] || provider.name.charAt(0).toUpperCase() + provider.name.slice(1);
+    const wasAutoRouted = !parsed.isExplicitProvider;
     return addCommonFields({
       category: "direct-api",
       providerName: providerDisplayName,
@@ -33459,7 +33766,9 @@ function resolveModelProvider(modelId) {
       requiredApiKeyEnvVar: info.envVar || null,
       apiKeyAvailable: isApiKeyAvailable(info),
       apiKeyDescription: info.envVar ? info.description : null,
-      apiKeyUrl: info.envVar ? info.url : null
+      apiKeyUrl: info.envVar ? info.url : null,
+      wasAutoRouted,
+      autoRouteMessage: wasAutoRouted ? pendingAutoRouteMessage ?? `Auto-routed: ${parsed.model} -> ${providerDisplayName}` : undefined
     });
   }
   if (parsed.provider === "unknown") {
@@ -33522,6 +33831,16 @@ function getMissingKeyError(resolution) {
     lines.push("");
     lines.push(`Get your API key from: ${resolution.apiKeyUrl}`);
   }
+  {
+    const parsed = resolution.parsed;
+    if (parsed && !parsed.isExplicitProvider && parsed.provider !== "unknown" && parsed.provider !== "native-anthropic") {
+      const hint = getAutoRouteHint(parsed.model, parsed.provider);
+      if (hint) {
+        lines.push("");
+        lines.push(hint);
+      }
+    }
+  }
   if (resolution.category === "openrouter") {
     const provider = resolution.fullModelId.split("/")[0];
     lines.push("");
@@ -33582,6 +33901,7 @@ var API_KEY_INFO, PROVIDER_DISPLAY_NAMES;
 var init_provider_resolver = __esm(() => {
   init_provider_registry();
   init_remote_provider_registry();
+  init_auto_route();
   init_model_parser();
   API_KEY_INFO = {
     openrouter: {
@@ -33697,16 +34017,16 @@ __export(exports_cli, {
   getMissingKeyResolutions: () => getMissingKeyResolutions,
   getMissingKeyError: () => getMissingKeyError
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync9, mkdirSync as mkdirSync6, copyFileSync, readdirSync, unlinkSync as unlinkSync3 } from "node:fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync11, 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";
+import { dirname as dirname4, join as join11 } from "node:path";
+import { homedir as homedir10 } from "node:os";
 function getVersion() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join9(homedir8(), ".claudish");
-  if (!existsSync9(cacheDir))
+  const cacheDir = join11(homedir10(), ".claudish");
+  if (!existsSync11(cacheDir))
     return;
   const cachePatterns = ["all-models.json", "pricing-cache.json"];
   let cleared = 0;
@@ -33714,7 +34034,7 @@ function clearAllModelCaches() {
     const files = readdirSync(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2) || file2.startsWith("litellm-models-")) {
-        unlinkSync3(join9(cacheDir, file2));
+        unlinkSync3(join11(cacheDir, file2));
         cleared++;
       }
     }
@@ -33983,9 +34303,9 @@ async function fetchOllamaModels() {
 }
 async function searchAndPrintModels(query, forceUpdate) {
   let models = [];
-  if (!forceUpdate && existsSync9(ALL_MODELS_JSON_PATH2)) {
+  if (!forceUpdate && existsSync11(ALL_MODELS_JSON_PATH2)) {
     try {
-      const cacheData = JSON.parse(readFileSync7(ALL_MODELS_JSON_PATH2, "utf-8"));
+      const cacheData = JSON.parse(readFileSync9(ALL_MODELS_JSON_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
       const now = new Date;
       const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
@@ -34153,9 +34473,9 @@ Found ${results.length} matching models:
 async function printAllModels(jsonOutput, forceUpdate) {
   let models = [];
   const [ollamaModels, zenModels] = await Promise.all([fetchOllamaModels(), fetchZenModels()]);
-  if (!forceUpdate && existsSync9(ALL_MODELS_JSON_PATH2)) {
+  if (!forceUpdate && existsSync11(ALL_MODELS_JSON_PATH2)) {
     try {
-      const cacheData = JSON.parse(readFileSync7(ALL_MODELS_JSON_PATH2, "utf-8"));
+      const cacheData = JSON.parse(readFileSync9(ALL_MODELS_JSON_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
       const now = new Date;
       const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
@@ -34356,11 +34676,11 @@ async function printAllModels(jsonOutput, forceUpdate) {
   console.log("Top models:            claudish --top-models");
 }
 function isCacheStale() {
-  if (!existsSync9(MODELS_JSON_PATH)) {
+  if (!existsSync11(MODELS_JSON_PATH)) {
     return true;
   }
   try {
-    const jsonContent = readFileSync7(MODELS_JSON_PATH, "utf-8");
+    const jsonContent = readFileSync9(MODELS_JSON_PATH, "utf-8");
     const data = JSON.parse(jsonContent);
     if (!data.lastUpdated) {
       return true;
@@ -34455,9 +34775,9 @@ async function updateModelsFromOpenRouter() {
       providers.add(provider);
     }
     let version2 = "1.1.5";
-    if (existsSync9(MODELS_JSON_PATH)) {
+    if (existsSync11(MODELS_JSON_PATH)) {
       try {
-        const existing = JSON.parse(readFileSync7(MODELS_JSON_PATH, "utf-8"));
+        const existing = JSON.parse(readFileSync9(MODELS_JSON_PATH, "utf-8"));
         version2 = existing.version || version2;
       } catch {}
     }
@@ -34485,7 +34805,7 @@ async function checkAndUpdateModelsCache(forceUpdate = false) {
     await updateModelsFromOpenRouter();
   } else {
     try {
-      const data = JSON.parse(readFileSync7(MODELS_JSON_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync9(MODELS_JSON_PATH, "utf-8"));
       console.error(`✓ Using cached models (last updated: ${data.lastUpdated})`);
     } catch {}
   }
@@ -34789,8 +35109,8 @@ MORE INFO:
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join9(__dirname5, "../AI_AGENT_GUIDE.md");
-    const guideContent = readFileSync7(guidePath, "utf-8");
+    const guidePath = join11(__dirname5, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync9(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
     console.error("Error reading AI Agent Guide:");
@@ -34806,19 +35126,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join9(cwd, ".claude");
-  const skillsDir = join9(claudeDir, "skills");
-  const claudishSkillDir = join9(skillsDir, "claudish-usage");
-  const skillFile = join9(claudishSkillDir, "SKILL.md");
-  if (existsSync9(skillFile)) {
+  const claudeDir = join11(cwd, ".claude");
+  const skillsDir = join11(claudeDir, "skills");
+  const claudishSkillDir = join11(skillsDir, "claudish-usage");
+  const skillFile = join11(claudishSkillDir, "SKILL.md");
+  if (existsSync11(skillFile)) {
     console.log("✅ Claudish skill already installed at:");
     console.log(`   ${skillFile}
 `);
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join9(__dirname5, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync9(sourceSkillPath)) {
+  const sourceSkillPath = join11(__dirname5, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync11(sourceSkillPath)) {
     console.error("❌ Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -34827,15 +35147,15 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync9(claudeDir)) {
+    if (!existsSync11(claudeDir)) {
       mkdirSync6(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync9(skillsDir)) {
+    if (!existsSync11(skillsDir)) {
       mkdirSync6(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync9(claudishSkillDir)) {
+    if (!existsSync11(claudishSkillDir)) {
       mkdirSync6(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
@@ -34878,8 +35198,8 @@ function printAvailableModels() {
   let lastUpdated = "unknown";
   let models = [];
   try {
-    if (existsSync9(MODELS_JSON_PATH)) {
-      const data = JSON.parse(readFileSync7(MODELS_JSON_PATH, "utf-8"));
+    if (existsSync11(MODELS_JSON_PATH)) {
+      const data = JSON.parse(readFileSync9(MODELS_JSON_PATH, "utf-8"));
       lastUpdated = data.lastUpdated || "unknown";
       models = data.models || [];
     }
@@ -34932,9 +35252,9 @@ Force update: claudish --list-models --force-update
 `);
 }
 function printAvailableModelsJSON() {
-  const jsonPath = join9(__dirname5, "../recommended-models.json");
+  const jsonPath = join11(__dirname5, "../recommended-models.json");
   try {
-    const jsonContent = readFileSync7(jsonPath, "utf-8");
+    const jsonContent = readFileSync9(jsonPath, "utf-8");
     const data = JSON.parse(jsonContent);
     const outputData = {
       ...data,
@@ -35026,7 +35346,7 @@ async function fetchGLMCodingModels2() {
     return [];
   }
 }
-var __filename5, __dirname5, VERSION = "5.1.1", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, CLAUDISH_CACHE_DIR3, ALL_MODELS_JSON_PATH2;
+var __filename5, __dirname5, VERSION = "5.2.0", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, CLAUDISH_CACHE_DIR3, ALL_MODELS_JSON_PATH2;
 var init_cli = __esm(() => {
   init_config();
   init_model_loader();
@@ -35035,12 +35355,12 @@ var init_cli = __esm(() => {
   __filename5 = fileURLToPath4(import.meta.url);
   __dirname5 = dirname4(__filename5);
   try {
-    const packageJson = JSON.parse(readFileSync7(join9(__dirname5, "../package.json"), "utf-8"));
+    const packageJson = JSON.parse(readFileSync9(join11(__dirname5, "../package.json"), "utf-8"));
     VERSION = packageJson.version;
   } catch {}
-  MODELS_JSON_PATH = join9(__dirname5, "../recommended-models.json");
-  CLAUDISH_CACHE_DIR3 = join9(homedir8(), ".claudish");
-  ALL_MODELS_JSON_PATH2 = join9(CLAUDISH_CACHE_DIR3, "all-models.json");
+  MODELS_JSON_PATH = join11(__dirname5, "../recommended-models.json");
+  CLAUDISH_CACHE_DIR3 = join11(homedir10(), ".claudish");
+  ALL_MODELS_JSON_PATH2 = join11(CLAUDISH_CACHE_DIR3, "all-models.json");
 });
 
 // src/claude-runner.ts
@@ -35050,17 +35370,17 @@ __export(exports_claude_runner, {
   checkClaudeInstalled: () => checkClaudeInstalled
 });
 import { spawn } from "node:child_process";
-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";
+import { writeFileSync as writeFileSync7, unlinkSync as unlinkSync4, mkdirSync as mkdirSync7, existsSync as existsSync12 } from "node:fs";
+import { tmpdir, homedir as homedir11 } from "node:os";
+import { join as join12 } from "node:path";
 function isWindows() {
   return process.platform === "win32";
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir();
-  const claudishDir = join10(homeDir, ".claudish");
+  const claudishDir = join12(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join10(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join12(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -35145,13 +35465,13 @@ process.stdin.on('end', () => {
 }
 function createTempSettingsFile(modelDisplay, port) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir();
-  const claudishDir = join10(homeDir, ".claudish");
+  const claudishDir = join12(homeDir, ".claudish");
   try {
     mkdirSync7(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join10(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join10(claudishDir, `tokens-${port}.json`);
+  const tempPath = join12(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join12(claudishDir, `tokens-${port}.json`);
   let statusCommand;
   if (isWindows()) {
     const scriptPath = createStatusLineScript(tokenFilePath);
@@ -35257,8 +35577,8 @@ async function runClaudeWithProxy(config3, proxyUrl) {
     console.error("Install it from: https://claude.com/claude-code");
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
-    const home = homedir9();
-    const localPath = isWindows() ? join10(home, ".claude", "local", "claude.exe") : join10(home, ".claude", "local", "claude");
+    const home = homedir11();
+    const localPath = isWindows() ? join12(home, ".claude", "local", "claude.exe") : join12(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -35297,23 +35617,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet) {
 async function findClaudeBinary() {
   const isWindows2 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync10(process.env.CLAUDE_PATH)) {
+    if (existsSync12(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir9();
-  const localPath = isWindows2 ? join10(home, ".claude", "local", "claude.exe") : join10(home, ".claude", "local", "claude");
-  if (existsSync10(localPath)) {
+  const home = homedir11();
+  const localPath = isWindows2 ? join12(home, ".claude", "local", "claude.exe") : join12(home, ".claude", "local", "claude");
+  if (existsSync12(localPath)) {
     return localPath;
   }
   if (isWindows2) {
     const windowsPaths = [
-      join10(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join10(home, ".npm-global", "claude.cmd"),
-      join10(home, "node_modules", ".bin", "claude.cmd")
+      join12(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join12(home, ".npm-global", "claude.cmd"),
+      join12(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path of windowsPaths) {
-      if (existsSync10(path)) {
+      if (existsSync12(path)) {
         return path;
       }
     }
@@ -35321,14 +35641,14 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join10(home, ".npm-global/bin/claude"),
-      join10(home, ".local/bin/claude"),
-      join10(home, "node_modules/.bin/claude"),
+      join12(home, ".npm-global/bin/claude"),
+      join12(home, ".local/bin/claude"),
+      join12(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join10(home, "../usr/bin/claude")
+      join12(home, "../usr/bin/claude")
     ];
     for (const path of commonPaths) {
-      if (existsSync10(path)) {
+      if (existsSync12(path)) {
         return path;
       }
     }
@@ -61219,9 +61539,9 @@ var init_gemini_codeassist = __esm(() => {
 // src/auth/vertex-auth.ts
 import { exec as exec4 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
-import { existsSync as existsSync11 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync13 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
+import { join as join13 } from "node:path";
 
 class VertexAuthManager {
   cachedToken = null;
@@ -61275,8 +61595,8 @@ class VertexAuthManager {
   }
   async tryADC() {
     try {
-      const adcPath = join11(homedir10(), ".config/gcloud/application_default_credentials.json");
-      if (!existsSync11(adcPath)) {
+      const adcPath = join13(homedir12(), ".config/gcloud/application_default_credentials.json");
+      if (!existsSync13(adcPath)) {
         log("[VertexAuth] ADC credentials file not found");
         return null;
       }
@@ -61300,7 +61620,7 @@ class VertexAuthManager {
     if (!credPath) {
       return null;
     }
-    if (!existsSync11(credPath)) {
+    if (!existsSync13(credPath)) {
       throw new Error(`Service account file not found: ${credPath}
 
 Check GOOGLE_APPLICATION_CREDENTIALS path.`);
@@ -61339,8 +61659,8 @@ function validateVertexOAuthConfig() {
 ` + `  export VERTEX_PROJECT='your-gcp-project-id'
 ` + "  export VERTEX_LOCATION='us-central1'  # optional";
   }
-  const adcPath = join11(homedir10(), ".config/gcloud/application_default_credentials.json");
-  const hasADC = existsSync11(adcPath);
+  const adcPath = join13(homedir12(), ".config/gcloud/application_default_credentials.json");
+  const hasADC = existsSync13(adcPath);
   const hasServiceAccount = !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
   if (!hasADC && !hasServiceAccount) {
     return `No Vertex AI credentials found.
@@ -61736,8 +62056,8 @@ var init_middleware = __esm(() => {
 
 // src/handlers/shared/token-tracker.ts
 import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { join as join12 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { join as join14 } from "node:path";
 
 class TokenTracker {
   port;
@@ -61851,9 +62171,9 @@ class TokenTracker {
         is_free: isFreeModel,
         is_estimated: isEstimate || false
       };
-      const claudishDir = join12(homedir11(), ".claudish");
+      const claudishDir = join14(homedir13(), ".claudish");
       mkdirSync8(claudishDir, { recursive: true });
-      writeFileSync8(join12(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+      writeFileSync8(join14(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
     } catch (e) {
       log(`[TokenTracker] Error writing token file: ${e}`);
     }
@@ -63048,10 +63368,10 @@ var init_litellm = __esm(() => {
 });
 
 // src/adapters/litellm-adapter.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
-import { createHash as createHash3 } from "node:crypto";
-import { homedir as homedir12 } from "node:os";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync11 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { homedir as homedir14 } from "node:os";
+import { join as join15 } from "node:path";
 var INLINE_IMAGE_MODEL_PATTERNS, LiteLLMAdapter;
 var init_litellm_adapter = __esm(() => {
   init_base_adapter();
@@ -63146,11 +63466,11 @@ var init_litellm_adapter = __esm(() => {
     }
     checkVisionSupport() {
       try {
-        const hash2 = createHash3("sha256").update(this.baseUrl).digest("hex").substring(0, 16);
-        const cachePath = join13(homedir12(), ".claudish", `litellm-models-${hash2}.json`);
-        if (!existsSync12(cachePath))
+        const hash2 = createHash4("sha256").update(this.baseUrl).digest("hex").substring(0, 16);
+        const cachePath = join15(homedir14(), ".claudish", `litellm-models-${hash2}.json`);
+        if (!existsSync14(cachePath))
           return true;
-        const cacheData = JSON.parse(readFileSync9(cachePath, "utf-8"));
+        const cacheData = JSON.parse(readFileSync11(cachePath, "utf-8"));
         const model = cacheData.models?.find((m) => m.name === this.modelId);
         if (model && model.supportsVision === false) {
           log(`[LiteLLMAdapter] Model ${this.modelId} does not support vision`);
@@ -63268,12 +63588,12 @@ class AnthropicCompatProvider {
     }
     if (this.provider.name === "kimi-coding" && !this.apiKey) {
       try {
-        const { existsSync: existsSync13, readFileSync: readFileSync10 } = await import("node:fs");
-        const { join: join14 } = await import("node:path");
-        const { homedir: homedir13 } = await import("node:os");
-        const credPath = join14(homedir13(), ".claudish", "kimi-oauth.json");
-        if (existsSync13(credPath)) {
-          const data = JSON.parse(readFileSync10(credPath, "utf-8"));
+        const { existsSync: existsSync15, readFileSync: readFileSync12 } = await import("node:fs");
+        const { join: join16 } = await import("node:path");
+        const { homedir: homedir15 } = await import("node:os");
+        const credPath = join16(homedir15(), ".claudish", "kimi-oauth.json");
+        if (existsSync15(credPath)) {
+          const data = JSON.parse(readFileSync12(credPath, "utf-8"));
           if (data.access_token && data.refresh_token) {
             const { KimiOAuth: KimiOAuth2 } = await Promise.resolve().then(() => (init_kimi_oauth(), exports_kimi_oauth));
             const oauth = KimiOAuth2.getInstance();
@@ -63495,9 +63815,9 @@ var init_ollamacloud_adapter = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync9, existsSync as existsSync13, mkdirSync as mkdirSync9, statSync } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { join as join14 } from "node:path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, existsSync as existsSync15, mkdirSync as mkdirSync9, statSync } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+import { join as join16 } from "node:path";
 function getDynamicPricingSync(provider, modelName) {
   if (provider === "openrouter") {
     const direct = pricingMap.get(modelName);
@@ -63562,12 +63882,12 @@ async function warmPricingCache() {
 }
 function loadDiskCache() {
   try {
-    if (!existsSync13(CACHE_FILE))
+    if (!existsSync15(CACHE_FILE))
       return false;
     const stat = statSync(CACHE_FILE);
     const age = Date.now() - stat.mtimeMs;
     const isFresh = age < CACHE_TTL_MS;
-    const raw2 = readFileSync10(CACHE_FILE, "utf-8");
+    const raw2 = readFileSync12(CACHE_FILE, "utf-8");
     const data = JSON.parse(raw2);
     for (const [key, pricing] of Object.entries(data)) {
       pricingMap.set(key, pricing);
@@ -63614,8 +63934,8 @@ var init_pricing_cache = __esm(() => {
   init_model_loader();
   init_remote_provider_types();
   pricingMap = new Map;
-  CACHE_DIR = join14(homedir13(), ".claudish");
-  CACHE_FILE = join14(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join16(homedir15(), ".claudish");
+  CACHE_FILE = join16(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS = 24 * 60 * 60 * 1000;
   PROVIDER_TO_OR_PREFIX = {
     openai: ["openai/"],
@@ -63710,11 +64030,18 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
       return remoteProviderHandlers.get(targetModel);
     }
     const resolution = resolveModelProvider(targetModel);
+    if (resolution.wasAutoRouted && resolution.autoRouteMessage) {
+      console.error(`[Auto-route] ${resolution.autoRouteMessage}`);
+    }
     if (resolution.category === "openrouter") {
+      if (resolution.wasAutoRouted && resolution.fullModelId) {
+        return getOpenRouterHandler(resolution.fullModelId);
+      }
       return null;
     }
+    const resolveTarget = resolution.wasAutoRouted && resolution.fullModelId ? resolution.fullModelId : targetModel;
     if (resolution.category === "direct-api" && resolution.apiKeyAvailable) {
-      const resolved = resolveRemoteProvider(targetModel);
+      const resolved = resolveRemoteProvider(resolveTarget);
       if (!resolved)
         return null;
       if (resolved.provider.name === "openrouter") {
@@ -63838,11 +64165,19 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
       } else {
         return null;
       }
-      remoteProviderHandlers.set(targetModel, handler);
+      remoteProviderHandlers.set(resolveTarget, handler);
+      if (resolveTarget !== targetModel) {
+        remoteProviderHandlers.set(targetModel, handler);
+      }
       return handler;
     }
     return null;
   };
+  if (process.env.LITELLM_BASE_URL && process.env.LITELLM_API_KEY) {
+    fetchLiteLLMModels(process.env.LITELLM_BASE_URL, process.env.LITELLM_API_KEY).then(() => {
+      log("[Proxy] LiteLLM model cache pre-warmed for auto-routing");
+    }).catch(() => {});
+  }
   const getHandlerForRequest = (requestedModel) => {
     if (monitorMode)
       return nativeHandler;
@@ -63965,6 +64300,7 @@ var init_proxy_server = __esm(() => {
   init_vertex_auth();
   init_provider_resolver();
   init_pricing_cache();
+  init_model_loader();
 });
 
 // src/update-checker.ts
@@ -63976,9 +64312,9 @@ __export(exports_update_checker, {
   checkForUpdates: () => checkForUpdates
 });
 import { execSync } from "node:child_process";
-import { existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync11, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "node:fs";
-import { homedir as homedir14, platform as platform2, tmpdir as tmpdir2 } from "node:os";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync13, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "node:fs";
+import { homedir as homedir16, platform as platform2, tmpdir as tmpdir2 } from "node:os";
+import { join as join17 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 function getUpdateCommand() {
   const scriptPath = process.argv[1] || "";
@@ -63990,27 +64326,27 @@ function getUpdateCommand() {
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows2) {
-    const localAppData = process.env.LOCALAPPDATA || join15(homedir14(), "AppData", "Local");
-    cacheDir = join15(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join17(homedir16(), "AppData", "Local");
+    cacheDir = join17(localAppData, "claudish");
   } else {
-    cacheDir = join15(homedir14(), ".cache", "claudish");
+    cacheDir = join17(homedir16(), ".cache", "claudish");
   }
   try {
-    if (!existsSync14(cacheDir)) {
+    if (!existsSync16(cacheDir)) {
       mkdirSync10(cacheDir, { recursive: true });
     }
-    return join15(cacheDir, "update-check.json");
+    return join17(cacheDir, "update-check.json");
   } catch {
-    return join15(tmpdir2(), "claudish-update-check.json");
+    return join17(tmpdir2(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync14(cachePath)) {
+    if (!existsSync16(cachePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync11(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync13(cachePath, "utf-8"));
     return data;
   } catch {
     return null;
@@ -64033,7 +64369,7 @@ function isCacheValid(cache) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync14(cachePath)) {
+    if (existsSync16(cachePath)) {
       unlinkSync5(cachePath);
     }
   } catch {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "5.1.1",
+  "version": "5.2.0",
   "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-25",
+  "lastUpdated": "2026-02-26",
   "source": "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
   "models": [
     {