claudish 5.15.0 → 5.16.0

package/dist/index.js

@@ -29162,6 +29162,7 @@ __export(exports_logger, {
   structuralRedact: () => structuralRedact,
   setStderrQuiet: () => setStderrQuiet,
   setLogLevel: () => setLogLevel,
+  setDiagOutput: () => setDiagOutput,
   maskCredential: () => maskCredential,
   logStructured: () => logStructured,
   logStderr: () => logStderr,
@@ -29329,12 +29330,17 @@ function log(message, forceConsole = false) {
   }
 }
 function logStderr(message) {
-  if (!stderrQuiet) {
+  if (diagOutput) {
+    diagOutput.write(message);
+  } else if (!stderrQuiet) {
     process.stderr.write(`[claudish] ${message}
 `);
   }
   log(message);
 }
+function setDiagOutput(output) {
+  diagOutput = output;
+}
 function setStderrQuiet(quiet) {
   stderrQuiet = quiet;
 }
@@ -29392,7 +29398,7 @@ function logStructured(label, data) {
   }
   log(`[${label}] ${JSON.stringify(data, null, 2)}`);
 }
-var logFilePath = null, logLevel = "info", stderrQuiet = false, logBuffer, flushTimer = null, FLUSH_INTERVAL_MS = 100, MAX_BUFFER_SIZE = 50, alwaysOnLogPath = null, alwaysOnBuffer, CONTENT_KEYS;
+var logFilePath = null, logLevel = "info", stderrQuiet = false, diagOutput = null, logBuffer, flushTimer = null, FLUSH_INTERVAL_MS = 100, MAX_BUFFER_SIZE = 50, alwaysOnLogPath = null, alwaysOnBuffer, CONTENT_KEYS;
 var init_logger = __esm(() => {
   logBuffer = [];
   alwaysOnBuffer = [];
@@ -30799,6 +30805,554 @@ var init_profile_config = __esm(() => {
   };
 });
 
+// src/providers/provider-definitions.ts
+function ensureProviderByNameCache() {
+  if (!_providerByNameCache) {
+    _providerByNameCache = new Map;
+    for (const def of BUILTIN_PROVIDERS) {
+      _providerByNameCache.set(def.name, def);
+    }
+  }
+  return _providerByNameCache;
+}
+function getShortcuts() {
+  if (!_shortcutsCache) {
+    _shortcutsCache = {};
+    for (const def of BUILTIN_PROVIDERS) {
+      for (const shortcut of def.shortcuts) {
+        _shortcutsCache[shortcut] = def.name;
+      }
+    }
+  }
+  return _shortcutsCache;
+}
+function getLegacyPrefixPatterns() {
+  if (!_legacyPrefixCache) {
+    _legacyPrefixCache = [];
+    for (const def of BUILTIN_PROVIDERS) {
+      for (const lp of def.legacyPrefixes) {
+        _legacyPrefixCache.push({
+          prefix: lp.prefix,
+          provider: def.name,
+          stripPrefix: lp.stripPrefix
+        });
+      }
+    }
+  }
+  return _legacyPrefixCache;
+}
+function getNativeModelPatterns() {
+  if (!_nativeModelPatternsCache) {
+    _nativeModelPatternsCache = [];
+    for (const def of BUILTIN_PROVIDERS) {
+      if (def.nativeModelPatterns) {
+        for (const np of def.nativeModelPatterns) {
+          _nativeModelPatternsCache.push({
+            pattern: np.pattern,
+            provider: def.name
+          });
+        }
+      }
+    }
+  }
+  return _nativeModelPatternsCache;
+}
+function getProviderByName(name) {
+  return ensureProviderByNameCache().get(name);
+}
+function getApiKeyInfo(providerName) {
+  const def = getProviderByName(providerName);
+  if (!def)
+    return null;
+  return {
+    envVar: def.apiKeyEnvVar,
+    description: def.apiKeyDescription,
+    url: def.apiKeyUrl,
+    aliases: def.apiKeyAliases,
+    oauthFallback: def.oauthFallback
+  };
+}
+function getDisplayName(providerName) {
+  const def = getProviderByName(providerName);
+  return def?.displayName || providerName.charAt(0).toUpperCase() + providerName.slice(1);
+}
+function getEffectiveBaseUrl(def) {
+  if (def.baseUrlEnvVars) {
+    for (const envVar of def.baseUrlEnvVars) {
+      const value = process.env[envVar];
+      if (value)
+        return value;
+    }
+  }
+  return def.baseUrl;
+}
+function isLocalTransport(providerName) {
+  if (!_localProvidersCache) {
+    _localProvidersCache = new Set;
+    for (const def of BUILTIN_PROVIDERS) {
+      if (def.isLocal) {
+        _localProvidersCache.add(def.name);
+      }
+    }
+  }
+  return _localProvidersCache.has(providerName.toLowerCase());
+}
+function toRemoteProvider(def) {
+  const baseUrl = getEffectiveBaseUrl(def);
+  let effectiveBaseUrl = baseUrl;
+  if (def.name === "opencode-zen-go" && def.baseUrlEnvVars) {
+    const envOverride = process.env[def.baseUrlEnvVars[0]];
+    if (envOverride) {
+      effectiveBaseUrl = envOverride.replace("/zen", "/zen/go");
+    }
+  }
+  return {
+    name: def.name === "google" ? "gemini" : def.name,
+    baseUrl: effectiveBaseUrl,
+    apiPath: def.apiPath,
+    apiKeyEnvVar: def.apiKeyEnvVar,
+    prefixes: def.legacyPrefixes.map((lp) => lp.prefix),
+    headers: def.headers,
+    authScheme: def.authScheme
+  };
+}
+function getAllProviders() {
+  return BUILTIN_PROVIDERS;
+}
+function getApiKeyEnvVars(providerName) {
+  const def = getProviderByName(providerName);
+  if (!def)
+    return null;
+  return {
+    envVar: def.apiKeyEnvVar,
+    aliases: def.apiKeyAliases
+  };
+}
+var BUILTIN_PROVIDERS, _shortcutsCache = null, _legacyPrefixCache = null, _nativeModelPatternsCache = null, _providerByNameCache = null, _localProvidersCache = null;
+var init_provider_definitions = __esm(() => {
+  BUILTIN_PROVIDERS = [
+    {
+      name: "google",
+      displayName: "Gemini",
+      transport: "gemini",
+      baseUrl: "https://generativelanguage.googleapis.com",
+      baseUrlEnvVars: ["GEMINI_BASE_URL"],
+      apiPath: "/v1beta/models/{model}:streamGenerateContent?alt=sse",
+      apiKeyEnvVar: "GEMINI_API_KEY",
+      apiKeyDescription: "Google Gemini API Key",
+      apiKeyUrl: "https://aistudio.google.com/app/apikey",
+      shortcuts: ["g", "gemini"],
+      shortestPrefix: "g",
+      legacyPrefixes: [
+        { prefix: "g/", stripPrefix: true },
+        { prefix: "gemini/", stripPrefix: true }
+      ],
+      nativeModelPatterns: [{ pattern: /^google\//i }, { pattern: /^gemini-/i }],
+      isDirectApi: true
+    },
+    {
+      name: "gemini-codeassist",
+      displayName: "Gemini Code Assist",
+      transport: "gemini-oauth",
+      baseUrl: "https://cloudcode-pa.googleapis.com",
+      apiPath: "/v1internal:streamGenerateContent?alt=sse",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "Gemini Code Assist (OAuth)",
+      apiKeyUrl: "https://cloud.google.com/code-assist",
+      shortcuts: ["go"],
+      shortestPrefix: "go",
+      legacyPrefixes: [{ prefix: "go/", stripPrefix: true }],
+      isDirectApi: true
+    },
+    {
+      name: "openai",
+      displayName: "OpenAI",
+      transport: "openai",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://api.openai.com",
+      baseUrlEnvVars: ["OPENAI_BASE_URL"],
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "OPENAI_API_KEY",
+      apiKeyDescription: "OpenAI API Key",
+      apiKeyUrl: "https://platform.openai.com/api-keys",
+      shortcuts: ["oai"],
+      shortestPrefix: "oai",
+      legacyPrefixes: [{ prefix: "oai/", stripPrefix: true }],
+      nativeModelPatterns: [
+        { pattern: /^openai\//i },
+        { pattern: /^gpt-/i },
+        { pattern: /^o1(-|$)/i },
+        { pattern: /^o3(-|$)/i },
+        { pattern: /^chatgpt-/i }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "openrouter",
+      displayName: "OpenRouter",
+      transport: "openrouter",
+      baseUrl: "https://openrouter.ai",
+      apiPath: "/api/v1/chat/completions",
+      apiKeyEnvVar: "OPENROUTER_API_KEY",
+      apiKeyDescription: "OpenRouter API Key",
+      apiKeyUrl: "https://openrouter.ai/keys",
+      shortcuts: ["or"],
+      shortestPrefix: "or",
+      legacyPrefixes: [{ prefix: "or/", stripPrefix: true }],
+      nativeModelPatterns: [{ pattern: /^openrouter\//i }],
+      headers: {
+        "HTTP-Referer": "https://claudish.com",
+        "X-Title": "Claudish - OpenRouter Proxy"
+      },
+      isDirectApi: true
+    },
+    {
+      name: "minimax",
+      displayName: "MiniMax",
+      transport: "anthropic",
+      baseUrl: "https://api.minimax.io",
+      baseUrlEnvVars: ["MINIMAX_BASE_URL"],
+      apiPath: "/anthropic/v1/messages",
+      apiKeyEnvVar: "MINIMAX_API_KEY",
+      apiKeyDescription: "MiniMax API Key",
+      apiKeyUrl: "https://www.minimaxi.com/",
+      authScheme: "bearer",
+      shortcuts: ["mm", "mmax"],
+      shortestPrefix: "mm",
+      legacyPrefixes: [
+        { prefix: "mmax/", stripPrefix: true },
+        { prefix: "mm/", stripPrefix: true }
+      ],
+      nativeModelPatterns: [
+        { pattern: /^minimax\//i },
+        { pattern: /^minimax-/i },
+        { pattern: /^abab-/i }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "minimax-coding",
+      displayName: "MiniMax Coding",
+      transport: "anthropic",
+      baseUrl: "https://api.minimax.io",
+      baseUrlEnvVars: ["MINIMAX_CODING_BASE_URL"],
+      apiPath: "/anthropic/v1/messages",
+      apiKeyEnvVar: "MINIMAX_CODING_API_KEY",
+      apiKeyDescription: "MiniMax Coding Plan API Key",
+      apiKeyUrl: "https://platform.minimax.io/user-center/basic-information/interface-key",
+      authScheme: "bearer",
+      shortcuts: ["mmc"],
+      shortestPrefix: "mmc",
+      legacyPrefixes: [{ prefix: "mmc/", stripPrefix: true }],
+      isDirectApi: true
+    },
+    {
+      name: "kimi-coding",
+      displayName: "Kimi Coding",
+      transport: "kimi-coding",
+      baseUrl: "https://api.kimi.com/coding/v1",
+      apiPath: "/messages",
+      apiKeyEnvVar: "KIMI_CODING_API_KEY",
+      apiKeyDescription: "Kimi Coding API Key",
+      apiKeyUrl: "https://kimi.com/code (get key from membership page, or run: claudish --kimi-login)",
+      oauthFallback: "kimi-oauth.json",
+      shortcuts: ["kc"],
+      shortestPrefix: "kc",
+      legacyPrefixes: [{ prefix: "kc/", stripPrefix: true }],
+      nativeModelPatterns: [{ pattern: /^kimi-for-coding$/i }],
+      isDirectApi: true
+    },
+    {
+      name: "kimi",
+      displayName: "Kimi",
+      transport: "anthropic",
+      baseUrl: "https://api.moonshot.ai",
+      baseUrlEnvVars: ["MOONSHOT_BASE_URL", "KIMI_BASE_URL"],
+      apiPath: "/anthropic/v1/messages",
+      apiKeyEnvVar: "MOONSHOT_API_KEY",
+      apiKeyAliases: ["KIMI_API_KEY"],
+      apiKeyDescription: "Kimi/Moonshot API Key",
+      apiKeyUrl: "https://platform.moonshot.cn/",
+      shortcuts: ["kimi", "moon", "moonshot"],
+      shortestPrefix: "kimi",
+      legacyPrefixes: [
+        { prefix: "kimi/", stripPrefix: true },
+        { prefix: "moonshot/", stripPrefix: true }
+      ],
+      nativeModelPatterns: [
+        { pattern: /^moonshot(ai)?\//i },
+        { pattern: /^moonshot-/i },
+        { pattern: /^kimi-/i }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "glm",
+      displayName: "GLM",
+      transport: "openai",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://open.bigmodel.cn",
+      baseUrlEnvVars: ["ZHIPU_BASE_URL", "GLM_BASE_URL"],
+      apiPath: "/api/paas/v4/chat/completions",
+      apiKeyEnvVar: "ZHIPU_API_KEY",
+      apiKeyAliases: ["GLM_API_KEY"],
+      apiKeyDescription: "GLM/Zhipu API Key",
+      apiKeyUrl: "https://open.bigmodel.cn/",
+      shortcuts: ["glm", "zhipu"],
+      shortestPrefix: "glm",
+      legacyPrefixes: [
+        { prefix: "glm/", stripPrefix: true },
+        { prefix: "zhipu/", stripPrefix: true }
+      ],
+      nativeModelPatterns: [
+        { pattern: /^zhipu\//i },
+        { pattern: /^glm-/i },
+        { pattern: /^chatglm-/i }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "glm-coding",
+      displayName: "GLM Coding",
+      transport: "openai",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://api.z.ai",
+      apiPath: "/api/coding/paas/v4/chat/completions",
+      apiKeyEnvVar: "GLM_CODING_API_KEY",
+      apiKeyAliases: ["ZAI_CODING_API_KEY"],
+      apiKeyDescription: "GLM Coding Plan API Key",
+      apiKeyUrl: "https://z.ai/subscribe",
+      shortcuts: ["gc"],
+      shortestPrefix: "gc",
+      legacyPrefixes: [{ prefix: "gc/", stripPrefix: true }],
+      isDirectApi: true
+    },
+    {
+      name: "zai",
+      displayName: "Z.AI",
+      transport: "anthropic",
+      baseUrl: "https://api.z.ai",
+      baseUrlEnvVars: ["ZAI_BASE_URL"],
+      apiPath: "/api/anthropic/v1/messages",
+      apiKeyEnvVar: "ZAI_API_KEY",
+      apiKeyDescription: "Z.AI API Key",
+      apiKeyUrl: "https://z.ai/",
+      shortcuts: ["zai"],
+      shortestPrefix: "zai",
+      legacyPrefixes: [{ prefix: "zai/", stripPrefix: true }],
+      nativeModelPatterns: [{ pattern: /^z-ai\//i }, { pattern: /^zai\//i }],
+      isDirectApi: true
+    },
+    {
+      name: "ollamacloud",
+      displayName: "OllamaCloud",
+      transport: "ollamacloud",
+      tokenStrategy: "accumulate-both",
+      baseUrl: "https://ollama.com",
+      baseUrlEnvVars: ["OLLAMACLOUD_BASE_URL"],
+      apiPath: "/api/chat",
+      apiKeyEnvVar: "OLLAMA_API_KEY",
+      apiKeyDescription: "OllamaCloud API Key",
+      apiKeyUrl: "https://ollama.com/account",
+      shortcuts: ["oc", "llama", "lc", "meta"],
+      shortestPrefix: "oc",
+      legacyPrefixes: [{ prefix: "oc/", stripPrefix: true }],
+      nativeModelPatterns: [
+        { pattern: /^ollamacloud\//i },
+        { pattern: /^meta-llama\//i },
+        { pattern: /^llama-/i },
+        { pattern: /^llama3/i }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "opencode-zen",
+      displayName: "OpenCode Zen",
+      transport: "openai",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://opencode.ai/zen",
+      baseUrlEnvVars: ["OPENCODE_BASE_URL"],
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "OPENCODE_API_KEY",
+      apiKeyDescription: "OpenCode Zen (Free)",
+      apiKeyUrl: "https://opencode.ai/",
+      publicKeyFallback: "public",
+      shortcuts: ["zen"],
+      shortestPrefix: "zen",
+      legacyPrefixes: [{ prefix: "zen/", stripPrefix: true }],
+      isDirectApi: true
+    },
+    {
+      name: "opencode-zen-go",
+      displayName: "OpenCode Zen Go",
+      transport: "openai",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://opencode.ai/zen/go",
+      baseUrlEnvVars: ["OPENCODE_BASE_URL"],
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "OPENCODE_API_KEY",
+      apiKeyDescription: "OpenCode Zen Go (Lite Plan)",
+      apiKeyUrl: "https://opencode.ai/",
+      shortcuts: ["zengo", "zgo"],
+      shortestPrefix: "zengo",
+      legacyPrefixes: [
+        { prefix: "zengo/", stripPrefix: true },
+        { prefix: "zgo/", stripPrefix: true }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "vertex",
+      displayName: "Vertex AI",
+      transport: "vertex",
+      baseUrl: "",
+      apiPath: "",
+      apiKeyEnvVar: "VERTEX_PROJECT",
+      apiKeyAliases: ["VERTEX_API_KEY"],
+      apiKeyDescription: "Vertex AI API Key",
+      apiKeyUrl: "https://console.cloud.google.com/vertex-ai",
+      shortcuts: ["v", "vertex"],
+      shortestPrefix: "v",
+      legacyPrefixes: [
+        { prefix: "v/", stripPrefix: true },
+        { prefix: "vertex/", stripPrefix: true }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "litellm",
+      displayName: "LiteLLM",
+      transport: "litellm",
+      baseUrl: "",
+      baseUrlEnvVars: ["LITELLM_BASE_URL"],
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "LITELLM_API_KEY",
+      apiKeyDescription: "LiteLLM API Key",
+      apiKeyUrl: "https://docs.litellm.ai/",
+      shortcuts: ["litellm", "ll"],
+      shortestPrefix: "ll",
+      legacyPrefixes: [
+        { prefix: "litellm/", stripPrefix: true },
+        { prefix: "ll/", stripPrefix: true }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "poe",
+      displayName: "Poe",
+      transport: "poe",
+      baseUrl: "https://api.poe.com",
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "POE_API_KEY",
+      apiKeyDescription: "Poe API Key",
+      apiKeyUrl: "https://poe.com/api_key",
+      shortcuts: ["poe"],
+      shortestPrefix: "poe",
+      legacyPrefixes: [],
+      nativeModelPatterns: [{ pattern: /^poe:/i }],
+      isDirectApi: true
+    },
+    {
+      name: "ollama",
+      displayName: "Ollama",
+      transport: "local",
+      baseUrl: "http://localhost:11434",
+      apiPath: "/api/chat",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "Ollama (Local)",
+      apiKeyUrl: "",
+      shortcuts: ["ollama"],
+      shortestPrefix: "ollama",
+      legacyPrefixes: [
+        { prefix: "ollama/", stripPrefix: true },
+        { prefix: "ollama:", stripPrefix: true }
+      ],
+      isLocal: true
+    },
+    {
+      name: "lmstudio",
+      displayName: "LM Studio",
+      transport: "local",
+      baseUrl: "http://localhost:1234",
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "LM Studio (Local)",
+      apiKeyUrl: "",
+      shortcuts: ["lms", "lmstudio", "mlstudio"],
+      shortestPrefix: "lms",
+      legacyPrefixes: [
+        { prefix: "lmstudio/", stripPrefix: true },
+        { prefix: "lmstudio:", stripPrefix: true },
+        { prefix: "mlstudio/", stripPrefix: true },
+        { prefix: "mlstudio:", stripPrefix: true }
+      ],
+      isLocal: true
+    },
+    {
+      name: "vllm",
+      displayName: "vLLM",
+      transport: "local",
+      baseUrl: "http://localhost:8000",
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "vLLM (Local)",
+      apiKeyUrl: "",
+      shortcuts: ["vllm"],
+      shortestPrefix: "vllm",
+      legacyPrefixes: [
+        { prefix: "vllm/", stripPrefix: true },
+        { prefix: "vllm:", stripPrefix: true }
+      ],
+      isLocal: true
+    },
+    {
+      name: "mlx",
+      displayName: "MLX",
+      transport: "local",
+      baseUrl: "http://localhost:8080",
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "MLX (Local)",
+      apiKeyUrl: "",
+      shortcuts: ["mlx"],
+      shortestPrefix: "mlx",
+      legacyPrefixes: [
+        { prefix: "mlx/", stripPrefix: true },
+        { prefix: "mlx:", stripPrefix: true }
+      ],
+      isLocal: true
+    },
+    {
+      name: "qwen",
+      displayName: "Qwen",
+      transport: "openai",
+      baseUrl: "",
+      apiPath: "",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "Qwen (auto-routed via OpenRouter)",
+      apiKeyUrl: "",
+      shortcuts: [],
+      shortestPrefix: "qwen",
+      legacyPrefixes: [],
+      nativeModelPatterns: [{ pattern: /^qwen/i }]
+    },
+    {
+      name: "native-anthropic",
+      displayName: "Anthropic (Native)",
+      transport: "anthropic",
+      baseUrl: "",
+      apiPath: "",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "Anthropic (Native Claude Code auth)",
+      apiKeyUrl: "",
+      shortcuts: [],
+      shortestPrefix: "",
+      legacyPrefixes: [],
+      nativeModelPatterns: [{ pattern: /^anthropic\//i }, { pattern: /^claude-/i }]
+    }
+  ];
+});
+
 // src/providers/model-parser.ts
 function parseModelSpec(modelSpec) {
   const original = modelSpec;
@@ -30895,125 +31449,17 @@ function getLegacySyntaxWarning(parsed) {
   return `Deprecation warning: "${parsed.original}" uses legacy prefix syntax.
 ` + `  Consider using: ${newSyntax}`;
 }
-var PROVIDER_SHORTCUTS, DIRECT_API_PROVIDERS, LOCAL_PROVIDERS, NATIVE_MODEL_PATTERNS, LEGACY_PREFIX_PATTERNS;
+var PROVIDER_SHORTCUTS, LOCAL_PROVIDERS, NATIVE_MODEL_PATTERNS, LEGACY_PREFIX_PATTERNS;
 var init_model_parser = __esm(() => {
-  PROVIDER_SHORTCUTS = {
-    g: "google",
-    gemini: "google",
-    oai: "openai",
-    or: "openrouter",
-    mm: "minimax",
-    mmax: "minimax",
-    mmc: "minimax-coding",
-    kimi: "kimi",
-    moon: "kimi",
-    moonshot: "kimi",
-    kc: "kimi-coding",
-    glm: "glm",
-    zhipu: "glm",
-    gc: "glm-coding",
-    zai: "zai",
-    oc: "ollamacloud",
-    zen: "opencode-zen",
-    zengo: "opencode-zen-go",
-    zgo: "opencode-zen-go",
-    v: "vertex",
-    vertex: "vertex",
-    go: "gemini-codeassist",
-    llama: "ollamacloud",
-    lc: "ollamacloud",
-    meta: "ollamacloud",
-    poe: "poe",
-    litellm: "litellm",
-    ll: "litellm",
-    ollama: "ollama",
-    lms: "lmstudio",
-    lmstudio: "lmstudio",
-    mlstudio: "lmstudio",
-    vllm: "vllm",
-    mlx: "mlx"
-  };
-  DIRECT_API_PROVIDERS = new Set([
-    "google",
-    "openai",
-    "minimax",
-    "kimi",
-    "minimax-coding",
-    "kimi-coding",
-    "glm",
-    "glm-coding",
-    "zai",
-    "ollamacloud",
-    "opencode-zen",
-    "vertex",
-    "gemini-codeassist",
-    "poe",
-    "litellm"
-  ]);
-  LOCAL_PROVIDERS = new Set(["ollama", "lmstudio", "vllm", "mlx"]);
-  NATIVE_MODEL_PATTERNS = [
-    { pattern: /^google\//i, provider: "google" },
-    { pattern: /^gemini-/i, provider: "google" },
-    { pattern: /^openai\//i, provider: "openai" },
-    { pattern: /^gpt-/i, provider: "openai" },
-    { pattern: /^o1(-|$)/i, provider: "openai" },
-    { pattern: /^o3(-|$)/i, provider: "openai" },
-    { pattern: /^chatgpt-/i, provider: "openai" },
-    { pattern: /^minimax\//i, provider: "minimax" },
-    { pattern: /^minimax-/i, provider: "minimax" },
-    { pattern: /^abab-/i, provider: "minimax" },
-    { pattern: /^kimi-for-coding$/i, provider: "kimi-coding" },
-    { pattern: /^moonshot(ai)?\//i, provider: "kimi" },
-    { pattern: /^moonshot-/i, provider: "kimi" },
-    { pattern: /^kimi-/i, provider: "kimi" },
-    { pattern: /^zhipu\//i, provider: "glm" },
-    { pattern: /^glm-/i, provider: "glm" },
-    { pattern: /^chatglm-/i, provider: "glm" },
-    { pattern: /^z-ai\//i, provider: "zai" },
-    { pattern: /^zai\//i, provider: "zai" },
-    { pattern: /^ollamacloud\//i, provider: "ollamacloud" },
-    { pattern: /^meta-llama\//i, provider: "ollamacloud" },
-    { pattern: /^llama-/i, provider: "ollamacloud" },
-    { pattern: /^llama3/i, provider: "ollamacloud" },
-    { pattern: /^openrouter\//i, provider: "openrouter" },
-    { pattern: /^qwen/i, provider: "qwen" },
-    { pattern: /^poe:/i, provider: "poe" },
-    { pattern: /^anthropic\//i, provider: "native-anthropic" },
-    { pattern: /^claude-/i, provider: "native-anthropic" }
-  ];
-  LEGACY_PREFIX_PATTERNS = [
-    { prefix: "g/", provider: "google", stripPrefix: true },
-    { prefix: "gemini/", provider: "google", stripPrefix: true },
-    { prefix: "oai/", provider: "openai", stripPrefix: true },
-    { prefix: "or/", provider: "openrouter", stripPrefix: true },
-    { prefix: "mmax/", provider: "minimax", stripPrefix: true },
-    { prefix: "mm/", provider: "minimax", stripPrefix: true },
-    { prefix: "mmc/", provider: "minimax-coding", stripPrefix: true },
-    { prefix: "kimi/", provider: "kimi", stripPrefix: true },
-    { prefix: "moonshot/", provider: "kimi", stripPrefix: true },
-    { prefix: "kc/", provider: "kimi-coding", stripPrefix: true },
-    { prefix: "glm/", provider: "glm", stripPrefix: true },
-    { prefix: "zhipu/", provider: "glm", stripPrefix: true },
-    { prefix: "gc/", provider: "glm-coding", stripPrefix: true },
-    { prefix: "zai/", provider: "zai", stripPrefix: true },
-    { prefix: "oc/", provider: "ollamacloud", stripPrefix: true },
-    { prefix: "zen/", provider: "opencode-zen", stripPrefix: true },
-    { prefix: "zengo/", provider: "opencode-zen-go", stripPrefix: true },
-    { prefix: "zgo/", provider: "opencode-zen-go", stripPrefix: true },
-    { prefix: "v/", provider: "vertex", stripPrefix: true },
-    { prefix: "vertex/", provider: "vertex", stripPrefix: true },
-    { prefix: "go/", provider: "gemini-codeassist", stripPrefix: true },
-    { prefix: "ollama/", provider: "ollama", stripPrefix: true },
-    { prefix: "ollama:", provider: "ollama", stripPrefix: true },
-    { prefix: "lmstudio/", provider: "lmstudio", stripPrefix: true },
-    { prefix: "lmstudio:", provider: "lmstudio", stripPrefix: true },
-    { prefix: "mlstudio/", provider: "lmstudio", stripPrefix: true },
-    { prefix: "mlstudio:", provider: "lmstudio", stripPrefix: true },
-    { prefix: "vllm/", provider: "vllm", stripPrefix: true },
-    { prefix: "vllm:", provider: "vllm", stripPrefix: true },
-    { prefix: "mlx/", provider: "mlx", stripPrefix: true },
-    { prefix: "mlx:", provider: "mlx", stripPrefix: true }
-  ];
+  init_provider_definitions();
+  PROVIDER_SHORTCUTS = getShortcuts();
+  LOCAL_PROVIDERS = {
+    has(name) {
+      return isLocalTransport(name);
+    }
+  };
+  NATIVE_MODEL_PATTERNS = getNativeModelPatterns();
+  LEGACY_PREFIX_PATTERNS = getLegacyPrefixPatterns();
 });
 
 // src/auth/oauth-registry.ts
@@ -31320,7 +31766,7 @@ function checkOAuthForProvider(nativeProvider, modelName) {
   };
 }
 function checkApiKeyForProvider(nativeProvider, modelName) {
-  const keyInfo = API_KEY_ENV_VARS[nativeProvider];
+  const keyInfo = getApiKeyEnvVars(nativeProvider);
   if (!keyInfo)
     return null;
   if (keyInfo.envVar && process.env[keyInfo.envVar]) {
@@ -31448,7 +31894,7 @@ async function warmZenModelCache() {
   writeSync3(join11(cacheDir, "zen-models.json"), JSON.stringify({ models, fetchedAt: new Date().toISOString() }));
 }
 function hasProviderCredentials(provider) {
-  const keyInfo = API_KEY_ENV_VARS[provider];
+  const keyInfo = getApiKeyEnvVars(provider);
   if (keyInfo?.envVar && process.env[keyInfo.envVar])
     return true;
   if (keyInfo?.aliases?.some((a) => process.env[a]))
@@ -31501,27 +31947,12 @@ function getFallbackChain(modelName, nativeProvider) {
   }
   return routes;
 }
-var API_KEY_ENV_VARS, PROVIDER_HINT_MAP, PROVIDER_TO_PREFIX, DISPLAY_NAMES, SUBSCRIPTION_ALTERNATIVES;
+var PROVIDER_HINT_MAP, PROVIDER_TO_PREFIX, DISPLAY_NAMES, SUBSCRIPTION_ALTERNATIVES;
 var init_auto_route = __esm(() => {
   init_oauth_registry();
   init_model_catalog_resolver();
-  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" }
-  };
+  init_provider_definitions();
+  init_provider_definitions();
   PROVIDER_HINT_MAP = {
     "kimi-coding": {
       loginFlag: "--kimi-login",
@@ -31565,39 +31996,22 @@ var init_auto_route = __esm(() => {
       apiKeyEnvVar: "OLLAMA_API_KEY"
     }
   };
-  PROVIDER_TO_PREFIX = {
-    google: "g",
-    openai: "oai",
-    minimax: "mm",
-    "minimax-coding": "mmc",
-    kimi: "kimi",
-    "kimi-coding": "kc",
-    glm: "glm",
-    "glm-coding": "gc",
-    zai: "zai",
-    ollamacloud: "oc",
-    "opencode-zen": "zen",
-    "opencode-zen-go": "zengo",
-    litellm: "ll",
-    vertex: "v",
-    "gemini-codeassist": "go"
-  };
-  DISPLAY_NAMES = {
-    google: "Gemini",
-    openai: "OpenAI",
-    minimax: "MiniMax",
-    "minimax-coding": "MiniMax Coding",
-    kimi: "Kimi",
-    "kimi-coding": "Kimi Coding",
-    glm: "GLM",
-    "glm-coding": "GLM Coding",
-    zai: "Z.AI",
-    ollamacloud: "OllamaCloud",
-    "opencode-zen": "OpenCode Zen",
-    "opencode-zen-go": "OpenCode Zen Go",
-    litellm: "LiteLLM",
-    openrouter: "OpenRouter"
-  };
+  PROVIDER_TO_PREFIX = (() => {
+    const map3 = {};
+    for (const def of getAllProviders()) {
+      if (def.shortestPrefix) {
+        map3[def.name] = def.shortestPrefix;
+      }
+    }
+    return map3;
+  })();
+  DISPLAY_NAMES = (() => {
+    const map3 = {};
+    for (const def of getAllProviders()) {
+      map3[def.name] = def.displayName;
+    }
+    return map3;
+  })();
   SUBSCRIPTION_ALTERNATIVES = {
     kimi: {
       subscriptionProvider: "kimi-coding",
@@ -31828,40 +32242,20 @@ function resolveRemoteProvider(modelId) {
   if (parsed.provider === "custom-url") {
     return null;
   }
-  const providerNameMap = {
-    google: "gemini",
-    openai: "openai",
-    openrouter: "openrouter",
-    minimax: "minimax",
-    "minimax-coding": "minimax-coding",
-    kimi: "kimi",
-    "kimi-coding": "kimi-coding",
-    glm: "glm",
-    "glm-coding": "glm-coding",
-    zai: "zai",
-    ollamacloud: "ollamacloud",
-    "opencode-zen": "opencode-zen",
-    "opencode-zen-go": "opencode-zen-go",
-    vertex: "vertex",
-    "gemini-codeassist": "gemini-codeassist",
-    litellm: "litellm"
-  };
-  const mappedProviderName = providerNameMap[parsed.provider];
-  if (mappedProviderName) {
-    const provider = providers.find((p) => p.name === mappedProviderName);
-    if (provider) {
-      return {
-        provider,
-        modelName: parsed.model,
-        isLegacySyntax: parsed.isLegacySyntax
-      };
-    }
+  const mappedName = parsed.provider === "google" ? "gemini" : parsed.provider;
+  const provider = providers.find((p) => p.name === mappedName || p.name === parsed.provider);
+  if (provider) {
+    return {
+      provider,
+      modelName: parsed.model,
+      isLegacySyntax: parsed.isLegacySyntax
+    };
   }
-  for (const provider of providers) {
-    for (const prefix of provider.prefixes) {
+  for (const provider2 of providers) {
+    for (const prefix of provider2.prefixes) {
       if (modelId.startsWith(prefix)) {
         return {
-          provider,
+          provider: provider2,
           modelName: modelId.slice(prefix.length),
           isLegacySyntax: true
         };
@@ -31907,128 +32301,12 @@ Set it with:
 function getRegisteredRemoteProviders() {
   return getRemoteProviders();
 }
-var getRemoteProviders = () => [
-  {
-    name: "gemini",
-    baseUrl: process.env.GEMINI_BASE_URL || "https://generativelanguage.googleapis.com",
-    apiPath: "/v1beta/models/{model}:streamGenerateContent?alt=sse",
-    apiKeyEnvVar: "GEMINI_API_KEY",
-    prefixes: ["g/", "gemini/"]
-  },
-  {
-    name: "gemini-codeassist",
-    baseUrl: "https://cloudcode-pa.googleapis.com",
-    apiPath: "/v1internal:streamGenerateContent?alt=sse",
-    apiKeyEnvVar: "",
-    prefixes: ["go/"]
-  },
-  {
-    name: "openai",
-    baseUrl: process.env.OPENAI_BASE_URL || "https://api.openai.com",
-    apiPath: "/v1/chat/completions",
-    apiKeyEnvVar: "OPENAI_API_KEY",
-    prefixes: ["oai/"]
-  },
-  {
-    name: "openrouter",
-    baseUrl: "https://openrouter.ai",
-    apiPath: "/api/v1/chat/completions",
-    apiKeyEnvVar: "OPENROUTER_API_KEY",
-    prefixes: ["or/"],
-    headers: {
-      "HTTP-Referer": "https://claudish.com",
-      "X-Title": "Claudish - OpenRouter Proxy"
-    }
-  },
-  {
-    name: "minimax",
-    baseUrl: process.env.MINIMAX_BASE_URL || "https://api.minimax.io",
-    apiPath: "/anthropic/v1/messages",
-    apiKeyEnvVar: "MINIMAX_API_KEY",
-    prefixes: ["mmax/", "mm/"],
-    authScheme: "bearer"
-  },
-  {
-    name: "minimax-coding",
-    baseUrl: process.env.MINIMAX_CODING_BASE_URL || "https://api.minimax.io",
-    apiPath: "/anthropic/v1/messages",
-    apiKeyEnvVar: "MINIMAX_CODING_API_KEY",
-    prefixes: ["mmc/"],
-    authScheme: "bearer"
-  },
-  {
-    name: "kimi",
-    baseUrl: process.env.MOONSHOT_BASE_URL || process.env.KIMI_BASE_URL || "https://api.moonshot.ai",
-    apiPath: "/anthropic/v1/messages",
-    apiKeyEnvVar: "MOONSHOT_API_KEY",
-    prefixes: ["kimi/", "moonshot/"]
-  },
-  {
-    name: "kimi-coding",
-    baseUrl: "https://api.kimi.com/coding/v1",
-    apiPath: "/messages",
-    apiKeyEnvVar: "KIMI_CODING_API_KEY",
-    prefixes: ["kc/"]
-  },
-  {
-    name: "glm",
-    baseUrl: process.env.ZHIPU_BASE_URL || process.env.GLM_BASE_URL || "https://open.bigmodel.cn",
-    apiPath: "/api/paas/v4/chat/completions",
-    apiKeyEnvVar: "ZHIPU_API_KEY",
-    prefixes: ["glm/", "zhipu/"]
-  },
-  {
-    name: "glm-coding",
-    baseUrl: "https://api.z.ai",
-    apiPath: "/api/coding/paas/v4/chat/completions",
-    apiKeyEnvVar: "GLM_CODING_API_KEY",
-    prefixes: ["gc/"]
-  },
-  {
-    name: "zai",
-    baseUrl: process.env.ZAI_BASE_URL || "https://api.z.ai",
-    apiPath: "/api/anthropic/v1/messages",
-    apiKeyEnvVar: "ZAI_API_KEY",
-    prefixes: ["zai/"]
-  },
-  {
-    name: "ollamacloud",
-    baseUrl: process.env.OLLAMACLOUD_BASE_URL || "https://ollama.com",
-    apiPath: "/api/chat",
-    apiKeyEnvVar: "OLLAMA_API_KEY",
-    prefixes: ["oc/"]
-  },
-  {
-    name: "opencode-zen",
-    baseUrl: process.env.OPENCODE_BASE_URL || "https://opencode.ai/zen",
-    apiPath: "/v1/chat/completions",
-    apiKeyEnvVar: "OPENCODE_API_KEY",
-    prefixes: ["zen/"]
-  },
-  {
-    name: "opencode-zen-go",
-    baseUrl: process.env.OPENCODE_BASE_URL ? process.env.OPENCODE_BASE_URL.replace("/zen", "/zen/go") : "https://opencode.ai/zen/go",
-    apiPath: "/v1/chat/completions",
-    apiKeyEnvVar: "OPENCODE_API_KEY",
-    prefixes: ["zengo/", "zgo/"]
-  },
-  {
-    name: "vertex",
-    baseUrl: "",
-    apiPath: "",
-    apiKeyEnvVar: "VERTEX_PROJECT",
-    prefixes: ["v/", "vertex/"]
-  },
-  {
-    name: "litellm",
-    baseUrl: process.env.LITELLM_BASE_URL || "",
-    apiPath: "/v1/chat/completions",
-    apiKeyEnvVar: "LITELLM_API_KEY",
-    prefixes: ["litellm/", "ll/"]
-  }
-];
+var getRemoteProviders = () => {
+  return getAllProviders().filter((def) => !def.isLocal && def.baseUrl !== "" && def.name !== "qwen" && def.name !== "native-anthropic").map(toRemoteProvider);
+};
 var init_remote_provider_registry = __esm(() => {
   init_model_parser();
+  init_provider_definitions();
 });
 
 // src/providers/provider-resolver.ts
@@ -32045,6 +32323,24 @@ __export(exports_provider_resolver, {
 import { existsSync as existsSync12 } from "fs";
 import { join as join12 } from "path";
 import { homedir as homedir11 } from "os";
+function getApiKeyInfoForProvider(providerName) {
+  const lookupName = providerName === "gemini" ? "google" : providerName;
+  const info = getApiKeyInfo(lookupName);
+  if (info) {
+    return {
+      envVar: info.envVar,
+      description: info.description,
+      url: info.url,
+      aliases: info.aliases,
+      oauthFallback: info.oauthFallback
+    };
+  }
+  return {
+    envVar: "",
+    description: `${providerName} API Key`,
+    url: ""
+  };
+}
 function isApiKeyAvailable(info) {
   if (!info.envVar) {
     return true;
@@ -32345,105 +32641,21 @@ var init_provider_resolver = __esm(() => {
   init_remote_provider_registry();
   init_auto_route();
   init_model_parser();
-  API_KEY_INFO = {
-    openrouter: {
-      envVar: "OPENROUTER_API_KEY",
-      description: "OpenRouter API Key",
-      url: "https://openrouter.ai/keys"
-    },
-    gemini: {
-      envVar: "GEMINI_API_KEY",
-      description: "Google Gemini API Key",
-      url: "https://aistudio.google.com/app/apikey"
-    },
-    "gemini-codeassist": {
-      envVar: "",
-      description: "Gemini Code Assist (OAuth)",
-      url: "https://cloud.google.com/code-assist"
-    },
-    vertex: {
-      envVar: "VERTEX_API_KEY",
-      description: "Vertex AI API Key",
-      url: "https://console.cloud.google.com/vertex-ai",
-      aliases: ["VERTEX_PROJECT"]
-    },
-    openai: {
-      envVar: "OPENAI_API_KEY",
-      description: "OpenAI API Key",
-      url: "https://platform.openai.com/api-keys"
-    },
-    minimax: {
-      envVar: "MINIMAX_API_KEY",
-      description: "MiniMax API Key",
-      url: "https://www.minimaxi.com/"
-    },
-    "minimax-coding": {
-      envVar: "MINIMAX_CODING_API_KEY",
-      description: "MiniMax Coding Plan API Key",
-      url: "https://platform.minimax.io/user-center/basic-information/interface-key"
-    },
-    kimi: {
-      envVar: "MOONSHOT_API_KEY",
-      description: "Kimi/Moonshot API Key",
-      url: "https://platform.moonshot.cn/",
-      aliases: ["KIMI_API_KEY"]
-    },
-    "kimi-coding": {
-      envVar: "KIMI_CODING_API_KEY",
-      description: "Kimi Coding API Key",
-      url: "https://kimi.com/code (get key from membership page, or run: claudish --kimi-login)",
-      oauthFallback: "kimi-oauth.json"
-    },
-    glm: {
-      envVar: "ZHIPU_API_KEY",
-      description: "GLM/Zhipu API Key",
-      url: "https://open.bigmodel.cn/",
-      aliases: ["GLM_API_KEY"]
-    },
-    "glm-coding": {
-      envVar: "GLM_CODING_API_KEY",
-      description: "GLM Coding Plan API Key",
-      url: "https://z.ai/subscribe",
-      aliases: ["ZAI_CODING_API_KEY"]
-    },
-    ollamacloud: {
-      envVar: "OLLAMA_API_KEY",
-      description: "OllamaCloud API Key",
-      url: "https://ollama.com/account"
-    },
-    "opencode-zen": {
-      envVar: "",
-      description: "OpenCode Zen (Free)",
-      url: "https://opencode.ai/"
-    },
-    zai: {
-      envVar: "ZAI_API_KEY",
-      description: "Z.AI API Key",
-      url: "https://z.ai/"
+  init_provider_definitions();
+  API_KEY_INFO = new Proxy({}, {
+    get(_target, prop) {
+      return getApiKeyInfoForProvider(prop);
     },
-    litellm: {
-      envVar: "LITELLM_API_KEY",
-      description: "LiteLLM API Key",
-      url: "https://docs.litellm.ai/"
+    has() {
+      return true;
     }
-  };
-  PROVIDER_DISPLAY_NAMES = {
-    gemini: "Gemini",
-    "gemini-codeassist": "Gemini Code Assist",
-    vertex: "Vertex AI",
-    openai: "OpenAI",
-    openrouter: "OpenRouter",
-    minimax: "MiniMax",
-    "minimax-coding": "MiniMax Coding",
-    kimi: "Kimi",
-    "kimi-coding": "Kimi Coding",
-    glm: "GLM",
-    "glm-coding": "GLM Coding",
-    zai: "Z.AI",
-    ollamacloud: "OllamaCloud",
-    "opencode-zen": "OpenCode Zen",
-    litellm: "LiteLLM"
-  };
+  });
+  PROVIDER_DISPLAY_NAMES = new Proxy({}, {
+    get(_target, prop) {
+      const lookupName = prop === "gemini" ? "google" : prop;
+      return getDisplayName(lookupName);
+    }
+  });
 });
 
 // src/adapters/tool-name-utils.ts
@@ -32772,6 +32984,12 @@ var init_openai_tools = __esm(() => {
 });
 
 // src/adapters/base-adapter.ts
+function matchesModelFamily(modelId, family) {
+  const lower = modelId.toLowerCase();
+  const fam = family.toLowerCase();
+  return lower.startsWith(fam) || lower.includes(`/${fam}`);
+}
+
 class BaseModelAdapter {
   modelId;
   toolNameMap = new Map;
@@ -32967,7 +33185,7 @@ var init_grok_adapter = __esm(() => {
       return params;
     }
     shouldHandle(modelId) {
-      return modelId.includes("grok") || modelId.includes("x-ai/");
+      return matchesModelFamily(modelId, "grok") || modelId.toLowerCase().includes("x-ai/");
     }
     getName() {
       return "GrokAdapter";
@@ -34224,7 +34442,7 @@ CRITICAL INSTRUCTION FOR OUTPUT FORMAT:
       return 1048576;
     }
     shouldHandle(modelId) {
-      return modelId.includes("gemini") || modelId.includes("google/");
+      return matchesModelFamily(modelId, "gemini") || modelId.toLowerCase().includes("google/");
     }
     getName() {
       return "GeminiAdapter";
@@ -34277,7 +34495,7 @@ var init_codex_adapter = __esm(() => {
       };
     }
     shouldHandle(modelId) {
-      return modelId.toLowerCase().includes("codex");
+      return matchesModelFamily(modelId, "codex");
     }
     getName() {
       return "CodexAdapter";
@@ -34551,8 +34769,7 @@ var init_qwen_adapter = __esm(() => {
       return request;
     }
     shouldHandle(modelId) {
-      const lower = modelId.toLowerCase();
-      return lower.includes("qwen") || lower.includes("alibaba");
+      return matchesModelFamily(modelId, "qwen") || matchesModelFamily(modelId, "alibaba");
     }
     getName() {
       return "QwenAdapter";
@@ -34582,7 +34799,7 @@ var init_minimax_adapter = __esm(() => {
       return request;
     }
     shouldHandle(modelId) {
-      return modelId.includes("minimax");
+      return matchesModelFamily(modelId, "minimax");
     }
     getName() {
       return "MiniMaxAdapter";
@@ -34611,7 +34828,7 @@ var init_deepseek_adapter = __esm(() => {
       return request;
     }
     shouldHandle(modelId) {
-      return modelId.includes("deepseek");
+      return matchesModelFamily(modelId, "deepseek");
     }
     getName() {
       return "DeepSeekAdapter";
@@ -34660,7 +34877,7 @@ var init_glm_adapter = __esm(() => {
       return request;
     }
     shouldHandle(modelId) {
-      return modelId.includes("glm-") || modelId.includes("zhipu/");
+      return matchesModelFamily(modelId, "glm-") || matchesModelFamily(modelId, "chatglm-") || modelId.toLowerCase().includes("zhipu/");
     }
     getName() {
       return "GLMAdapter";
@@ -34708,8 +34925,7 @@ var init_xiaomi_adapter = __esm(() => {
       return request;
     }
     shouldHandle(modelId) {
-      const lower = modelId.toLowerCase();
-      return lower.includes("xiaomi") || lower.includes("mimo");
+      return matchesModelFamily(modelId, "xiaomi") || matchesModelFamily(modelId, "mimo");
     }
     getName() {
       return "XiaomiAdapter";
@@ -36373,7 +36589,7 @@ async function fetchGLMCodingModels() {
     return [];
   }
 }
-var __filename4, __dirname4, VERSION = "5.15.0", CACHE_MAX_AGE_DAYS2 = 2, CLAUDISH_CACHE_DIR2, BUNDLED_MODELS_PATH, CACHED_MODELS_PATH, ALL_MODELS_JSON_PATH;
+var __filename4, __dirname4, VERSION = "5.16.0", CACHE_MAX_AGE_DAYS2 = 2, CLAUDISH_CACHE_DIR2, BUNDLED_MODELS_PATH, CACHED_MODELS_PATH, ALL_MODELS_JSON_PATH;
 var init_cli = __esm(() => {
   init_config();
   init_model_loader();
@@ -83471,9 +83687,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
         }
         function getWrappedDisplayName(outerType, innerType, wrapperName, fallbackName) {
           var displayName = outerType === null || outerType === undefined ? undefined : outerType.displayName;
-          return displayName || "".concat(wrapperName, "(").concat(getDisplayName(innerType, fallbackName), ")");
+          return displayName || "".concat(wrapperName, "(").concat(getDisplayName2(innerType, fallbackName), ")");
         }
-        function getDisplayName(type) {
+        function getDisplayName2(type) {
           var fallbackName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Anonymous";
           var nameFromCache = cachedDisplayNames.get(type);
           if (nameFromCache != null) {
@@ -84016,7 +84232,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               if (typeof type === "string") {
                 return type;
               } else if (typeof type === "function") {
-                return getDisplayName(type, "Anonymous");
+                return getDisplayName2(type, "Anonymous");
               } else if (type != null) {
                 return "NotImplementedInDevtools";
               } else {
@@ -89944,7 +90160,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               case IncompleteFunctionComponent:
               case FunctionComponent:
               case IndeterminateComponent:
-                return getDisplayName(resolvedType);
+                return getDisplayName2(resolvedType);
               case ForwardRef:
                 return getWrappedDisplayName(elementType, resolvedType, "ForwardRef", "Anonymous");
               case HostRoot:
@@ -94899,7 +95115,7 @@ The error thrown in the component is:
             if (typeof elementType === "string") {
               displayName = elementType;
             } else if (typeof elementType === "function") {
-              displayName = getDisplayName(elementType);
+              displayName = getDisplayName2(elementType);
             }
           }
           return {
@@ -99326,7 +99542,7 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
   }
   config3.claudeArgs.splice(idx, 2);
 }
-async function runClaudeWithProxy(config3, proxyUrl) {
+async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
   const hasProfileMappings = config3.modelOpus || config3.modelSonnet || config3.modelHaiku || config3.modelSubagent;
   const modelId = config3.model || (hasProfileMappings || config3.monitor ? undefined : "unknown");
   const portMatch = proxyUrl.match(/:(\d+)/);
@@ -99418,7 +99634,7 @@ Or set CLAUDE_PATH to your custom installation:`);
     stdio: "inherit",
     shell: needsShell
   });
-  setupSignalHandlers(proc, tempSettingsPath, config3.quiet);
+  setupSignalHandlers(proc, tempSettingsPath, config3.quiet, onCleanup);
   const exitCode = await new Promise((resolve3) => {
     proc.on("exit", (code) => {
       resolve3(code ?? 1);
@@ -99429,7 +99645,7 @@ Or set CLAUDE_PATH to your custom installation:`);
   } catch (error46) {}
   return exitCode;
 }
-function setupSignalHandlers(proc, tempSettingsPath, quiet) {
+function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
   const signals2 = isWindows2() ? ["SIGINT", "SIGTERM"] : ["SIGINT", "SIGTERM", "SIGHUP"];
   for (const signal of signals2) {
     process.on(signal, () => {
@@ -99438,6 +99654,11 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet) {
 [claudish] Received ${signal}, shutting down...`);
       }
       proc.kill();
+      if (onCleanup) {
+        try {
+          onCleanup();
+        } catch {}
+      }
       try {
         unlinkSync7(tempSettingsPath);
       } catch {}
@@ -99521,6 +99742,105 @@ var init_claude_runner = __esm(() => {
   init_model_parser();
 });
 
+// src/diag-output.ts
+var exports_diag_output = {};
+__export(exports_diag_output, {
+  createDiagOutput: () => createDiagOutput,
+  TmuxDiagOutput: () => TmuxDiagOutput,
+  NullDiagOutput: () => NullDiagOutput,
+  LogFileDiagOutput: () => LogFileDiagOutput
+});
+import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync11, writeFileSync as writeFileSync12, unlinkSync as unlinkSync8 } from "fs";
+import { execFileSync } from "child_process";
+import { homedir as homedir17 } from "os";
+import { join as join20 } from "path";
+function getClaudishDir() {
+  const dir = join20(homedir17(), ".claudish");
+  try {
+    mkdirSync11(dir, { recursive: true });
+  } catch {}
+  return dir;
+}
+function getDiagLogPath() {
+  return join20(getClaudishDir(), `diag-${process.pid}.log`);
+}
+
+class LogFileDiagOutput {
+  logPath;
+  stream;
+  constructor() {
+    this.logPath = getDiagLogPath();
+    try {
+      writeFileSync12(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+`);
+    } catch {}
+    this.stream = createWriteStream2(this.logPath, { flags: "a" });
+    this.stream.on("error", () => {});
+  }
+  write(msg) {
+    const timestamp = new Date().toISOString();
+    const line = `[${timestamp}] ${msg}
+`;
+    try {
+      this.stream.write(line);
+    } catch {}
+  }
+  cleanup() {
+    try {
+      this.stream.end();
+    } catch {}
+    try {
+      unlinkSync8(this.logPath);
+    } catch {}
+  }
+  getLogPath() {
+    return this.logPath;
+  }
+}
+
+class NullDiagOutput {
+  write(_msg) {}
+  cleanup() {}
+}
+function createDiagOutput(options) {
+  if (!options.interactive) {
+    return new NullDiagOutput;
+  }
+  if (process.env.TMUX) {
+    return new TmuxDiagOutput;
+  }
+  return new LogFileDiagOutput;
+}
+var TmuxDiagOutput;
+var init_diag_output = __esm(() => {
+  TmuxDiagOutput = class TmuxDiagOutput extends LogFileDiagOutput {
+    paneId = null;
+    constructor() {
+      super();
+      this.openTmuxPane();
+    }
+    openTmuxPane() {
+      try {
+        const output = execFileSync("tmux", ["split-window", "-v", "-l", "5", "-d", "-P", "-F", "#{pane_id}", "tail", "-f", this.logPath], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        this.paneId = output.trim();
+      } catch {
+        this.paneId = null;
+      }
+    }
+    cleanup() {
+      if (this.paneId) {
+        try {
+          execFileSync("tmux", ["kill-pane", "-t", this.paneId], {
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+        } catch {}
+        this.paneId = null;
+      }
+      super.cleanup();
+    }
+  };
+});
+
 // src/port-manager.ts
 var exports_port_manager = {};
 __export(exports_port_manager, {
@@ -103104,9 +103424,9 @@ var init_middleware = __esm(() => {
 });
 
 // src/handlers/shared/token-tracker.ts
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync12 } from "fs";
-import { homedir as homedir17 } from "os";
-import { join as join20 } from "path";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir18 } from "os";
+import { join as join21 } from "path";
 
 class TokenTracker {
   port;
@@ -103220,9 +103540,9 @@ class TokenTracker {
         is_free: isFreeModel,
         is_estimated: isEstimate || false
       };
-      const claudishDir = join20(homedir17(), ".claudish");
-      mkdirSync11(claudishDir, { recursive: true });
-      writeFileSync12(join20(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+      const claudishDir = join21(homedir18(), ".claudish");
+      mkdirSync12(claudishDir, { recursive: true });
+      writeFileSync13(join21(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
     } catch (e) {
       log(`[TokenTracker] Error writing token file: ${e}`);
     }
@@ -104643,9 +104963,9 @@ var init_composed_handler = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync13, existsSync as existsSync19, mkdirSync as mkdirSync12, statSync as statSync2 } from "fs";
-import { homedir as homedir18 } from "os";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync14, existsSync as existsSync19, mkdirSync as mkdirSync13, statSync as statSync2 } from "fs";
+import { homedir as homedir19 } from "os";
+import { join as join22 } from "path";
 function getDynamicPricingSync(provider, modelName) {
   if (provider === "openrouter") {
     const direct = pricingMap.get(modelName);
@@ -104727,12 +105047,12 @@ function loadDiskCache() {
 }
 function saveDiskCache() {
   try {
-    mkdirSync12(CACHE_DIR, { recursive: true });
+    mkdirSync13(CACHE_DIR, { recursive: true });
     const data = {};
     for (const [key, pricing] of pricingMap) {
       data[key] = pricing;
     }
-    writeFileSync13(CACHE_FILE, JSON.stringify(data), "utf-8");
+    writeFileSync14(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch (error46) {
     log(`[PricingCache] Error saving disk cache: ${error46}`);
   }
@@ -104762,8 +105082,8 @@ var init_pricing_cache = __esm(() => {
   init_model_loader();
   init_remote_provider_types();
   pricingMap = new Map;
-  CACHE_DIR = join21(homedir18(), ".claudish");
-  CACHE_FILE = join21(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join22(homedir19(), ".claudish");
+  CACHE_FILE = join22(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS = 24 * 60 * 60 * 1000;
   PROVIDER_TO_OR_PREFIX = {
     openai: ["openai/"],
@@ -105223,9 +105543,9 @@ class AnthropicCompatProvider {
     if (this.provider.name === "kimi-coding" && !this.apiKey) {
       try {
         const { existsSync: existsSync20, readFileSync: readFileSync18 } = await import("fs");
-        const { join: join22 } = await import("path");
-        const { homedir: homedir19 } = await import("os");
-        const credPath = join22(homedir19(), ".claudish", "kimi-oauth.json");
+        const { join: join23 } = await import("path");
+        const { homedir: homedir20 } = await import("os");
+        const credPath = join23(homedir20(), ".claudish", "kimi-oauth.json");
         if (existsSync20(credPath)) {
           const data = JSON.parse(readFileSync18(credPath, "utf-8"));
           if (data.access_token && data.refresh_token) {
@@ -105538,8 +105858,8 @@ var init_litellm2 = __esm(() => {
 // src/adapters/litellm-adapter.ts
 import { existsSync as existsSync20, readFileSync as readFileSync18 } from "fs";
 import { createHash as createHash5 } from "crypto";
-import { homedir as homedir19 } from "os";
-import { join as join22 } from "path";
+import { homedir as homedir20 } from "os";
+import { join as join23 } from "path";
 var INLINE_IMAGE_MODEL_PATTERNS, LiteLLMAdapter;
 var init_litellm_adapter = __esm(() => {
   init_base_adapter();
@@ -105635,7 +105955,7 @@ var init_litellm_adapter = __esm(() => {
     checkVisionSupport() {
       try {
         const hash2 = createHash5("sha256").update(this.baseUrl).digest("hex").substring(0, 16);
-        const cachePath = join22(homedir19(), ".claudish", `litellm-models-${hash2}.json`);
+        const cachePath = join23(homedir20(), ".claudish", `litellm-models-${hash2}.json`);
         if (!existsSync20(cachePath))
           return true;
         const cacheData = JSON.parse(readFileSync18(cachePath, "utf-8"));
@@ -105656,8 +105976,8 @@ var init_litellm_adapter = __esm(() => {
 import { exec as exec4 } from "child_process";
 import { promisify as promisify3 } from "util";
 import { existsSync as existsSync21 } from "fs";
-import { homedir as homedir20 } from "os";
-import { join as join23 } from "path";
+import { homedir as homedir21 } from "os";
+import { join as join24 } from "path";
 
 class VertexAuthManager {
   cachedToken = null;
@@ -105711,7 +106031,7 @@ class VertexAuthManager {
   }
   async tryADC() {
     try {
-      const adcPath = join23(homedir20(), ".config/gcloud/application_default_credentials.json");
+      const adcPath = join24(homedir21(), ".config/gcloud/application_default_credentials.json");
       if (!existsSync21(adcPath)) {
         log("[VertexAuth] ADC credentials file not found");
         return null;
@@ -105775,7 +106095,7 @@ function validateVertexOAuthConfig() {
 ` + `  export VERTEX_PROJECT='your-gcp-project-id'
 ` + "  export VERTEX_LOCATION='us-central1'  # optional";
   }
-  const adcPath = join23(homedir20(), ".config/gcloud/application_default_credentials.json");
+  const adcPath = join24(homedir21(), ".config/gcloud/application_default_credentials.json");
   const hasADC = existsSync21(adcPath);
   const hasServiceAccount = !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
   if (!hasADC && !hasServiceAccount) {
@@ -106413,12 +106733,12 @@ var init_proxy_server = __esm(() => {
 // src/index.ts
 var import_dotenv2 = __toESM(require_main(), 1);
 import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
-import { homedir as homedir21 } from "os";
-import { join as join24 } from "path";
+import { homedir as homedir22 } from "os";
+import { join as join25 } from "path";
 import_dotenv2.config({ quiet: true });
 function loadStoredApiKeys() {
   try {
-    const configPath = join24(homedir21(), ".claudish", "config.json");
+    const configPath = join25(homedir22(), ".claudish", "config.json");
     if (!existsSync23(configPath))
       return;
     const raw2 = readFileSync20(configPath, "utf-8");
@@ -106554,7 +106874,8 @@ async function runCli() {
     getMissingKeyResolutions: getMissingKeyResolutions2,
     getMissingKeysError: getMissingKeysError2
   } = await Promise.resolve().then(() => (init_provider_resolver(), exports_provider_resolver));
-  const { initLogger: initLogger2, getLogFilePath: getLogFilePath2, getAlwaysOnLogPath: getAlwaysOnLogPath2, setStderrQuiet: setStderrQuiet2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
+  const { initLogger: initLogger2, getLogFilePath: getLogFilePath2, getAlwaysOnLogPath: getAlwaysOnLogPath2, setDiagOutput: setDiagOutput2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
+  const { createDiagOutput: createDiagOutput2, LogFileDiagOutput: LogFileDiagOutput2 } = await Promise.resolve().then(() => (init_diag_output(), exports_diag_output));
   const { findAvailablePort: findAvailablePort2 } = await Promise.resolve().then(() => (init_port_manager(), exports_port_manager));
   const { createProxyServer: createProxyServer2 } = await Promise.resolve().then(() => (init_proxy_server(), exports_proxy_server));
   const { checkForUpdates: checkForUpdates2 } = await Promise.resolve().then(() => (init_update_checker(), exports_update_checker));
@@ -106672,14 +106993,19 @@ async function runCli() {
       quiet: cliConfig.quiet,
       isInteractive: cliConfig.interactive
     });
+    const diag = createDiagOutput2({ interactive: cliConfig.interactive });
     if (cliConfig.interactive) {
-      setStderrQuiet2(true);
+      setDiagOutput2(diag);
+      if (!process.env.TMUX && !cliConfig.quiet && diag instanceof LogFileDiagOutput2) {
+        console.log(`[claudish] Diagnostic log: ${diag.getLogPath()}`);
+      }
     }
     let exitCode = 0;
     try {
-      exitCode = await runClaudeWithProxy2(cliConfig, proxy.url);
+      exitCode = await runClaudeWithProxy2(cliConfig, proxy.url, () => diag.cleanup());
     } finally {
-      setStderrQuiet2(false);
+      setDiagOutput2(null);
+      diag.cleanup();
       if (!cliConfig.quiet) {
         console.log(`
 [claudish] Shutting down proxy server...`);