claudish 3.9.0 → 3.11.0

package/dist/index.js

@@ -53247,6 +53247,157 @@ var init_undici = __esm(() => {
   ({ EventSource } = require_eventsource());
 });
 
+// ../core/dist/handlers/shared/local-queue.js
+class LocalModelQueue {
+  static instance = null;
+  queue = [];
+  activeRequests = 0;
+  maxParallel;
+  maxQueueSize = 100;
+  requestDelay = 100;
+  totalProcessed = 0;
+  totalErrors = 0;
+  totalOOMErrors = 0;
+  constructor() {
+    this.maxParallel = this.getMaxParallelFromEnv();
+    if (getLogLevel() === "debug") {
+      log(`[LocalQueue] Queue initialized with maxParallel=${this.maxParallel}, maxQueueSize=${this.maxQueueSize}`);
+    }
+  }
+  static getInstance() {
+    if (!LocalModelQueue.instance) {
+      LocalModelQueue.instance = new LocalModelQueue;
+    }
+    return LocalModelQueue.instance;
+  }
+  static isEnabled() {
+    const enabled = process.env.CLAUDISH_LOCAL_QUEUE_ENABLED;
+    if (enabled === undefined || enabled === "")
+      return true;
+    return enabled !== "false" && enabled !== "0";
+  }
+  async enqueue(fetchFn, providerId) {
+    if (this.queue.length >= this.maxQueueSize) {
+      if (getLogLevel() === "debug") {
+        log(`[LocalQueue] Queue full (${this.queue.length}/${this.maxQueueSize}), rejecting request`);
+      }
+      throw new Error(`Local model queue full (${this.queue.length}/${this.maxQueueSize}). GPU is overloaded. Please wait for current requests to complete.`);
+    }
+    return new Promise((resolve, reject) => {
+      const queuedRequest = {
+        fetchFn,
+        resolve,
+        reject,
+        providerId
+      };
+      this.queue.push(queuedRequest);
+      if (getLogLevel() === "debug") {
+        log(`[LocalQueue] Request enqueued for ${providerId} (queue length: ${this.queue.length}, active: ${this.activeRequests}/${this.maxParallel})`);
+      }
+      this.processQueue();
+    });
+  }
+  async processQueue() {
+    while (this.queue.length > 0 && this.activeRequests < this.maxParallel) {
+      const request = this.queue.shift();
+      if (!request)
+        break;
+      if (getLogLevel() === "debug") {
+        log(`[LocalQueue] Processing request for ${request.providerId} (${this.queue.length} remaining in queue, ${this.activeRequests + 1}/${this.maxParallel} active)`);
+      }
+      this.executeRequest(request).catch((err) => {
+        if (getLogLevel() === "debug") {
+          log(`[LocalQueue] Request execution failed: ${err}`);
+        }
+      });
+      await this.delay(this.requestDelay);
+    }
+  }
+  async executeRequest(request) {
+    this.activeRequests++;
+    try {
+      const response = await request.fetchFn();
+      if (response.status === 500) {
+        const errorBody = await response.clone().text();
+        if (this.isOOMError(errorBody)) {
+          this.totalOOMErrors++;
+          if (getLogLevel() === "debug") {
+            log(`[LocalQueue] GPU out-of-memory detected for ${request.providerId}. Consider reducing CLAUDISH_LOCAL_MAX_PARALLEL (current: ${this.maxParallel})`);
+          }
+          await this.delay(2000);
+          const retryResponse = await request.fetchFn();
+          if (retryResponse.status === 500) {
+            const retryErrorBody = await retryResponse.clone().text();
+            if (this.isOOMError(retryErrorBody)) {
+              throw new Error(`GPU out-of-memory error persisted after retry. Try setting CLAUDISH_LOCAL_MAX_PARALLEL=1 for sequential processing.`);
+            }
+          }
+          this.totalProcessed++;
+          request.resolve(retryResponse);
+          return;
+        }
+      }
+      this.totalProcessed++;
+      request.resolve(response);
+    } catch (error46) {
+      this.totalErrors++;
+      if (getLogLevel() === "debug") {
+        log(`[LocalQueue] Request failed for ${request.providerId}: ${error46}`);
+      }
+      request.reject(error46 instanceof Error ? error46 : new Error(String(error46)));
+    } finally {
+      this.activeRequests--;
+      if (this.queue.length > 0) {
+        this.processQueue();
+      }
+    }
+  }
+  isOOMError(errorBody) {
+    const oomPatterns = [
+      "failed to allocate memory",
+      "CUDA out of memory",
+      "OOM",
+      "out of memory",
+      "memory allocation failed",
+      "insufficient memory",
+      "GPU memory"
+    ];
+    const bodyLower = errorBody.toLowerCase();
+    return oomPatterns.some((pattern) => bodyLower.includes(pattern.toLowerCase()));
+  }
+  getMaxParallelFromEnv() {
+    const envValue = process.env.CLAUDISH_LOCAL_MAX_PARALLEL;
+    if (!envValue)
+      return 1;
+    const parsed = Number.parseInt(envValue, 10);
+    if (Number.isNaN(parsed) || parsed < 1) {
+      log(`[LocalQueue] Invalid CLAUDISH_LOCAL_MAX_PARALLEL: ${envValue}, using default: 1`);
+      return 1;
+    }
+    if (parsed > 8) {
+      log(`[LocalQueue] CLAUDISH_LOCAL_MAX_PARALLEL too high: ${parsed}, capping at 8`);
+      return 8;
+    }
+    return parsed;
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  getStats() {
+    return {
+      queueLength: this.queue.length,
+      activeRequests: this.activeRequests,
+      maxParallel: this.maxParallel,
+      totalProcessed: this.totalProcessed,
+      totalErrors: this.totalErrors,
+      totalOOMErrors: this.totalOOMErrors
+    };
+  }
+}
+var init_local_queue = __esm(() => {
+  init_logger();
+});
+
 // ../core/dist/handlers/local-provider-handler.js
 import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
@@ -53620,7 +53771,7 @@ If you cannot use structured tool_calls, format as JSON:
         log(`[LocalProvider:${this.provider.name}] Request timeout (10 min) - aborting`);
         controller.abort();
       }, 600000);
-      const response = await fetch(apiUrl, {
+      const doFetch = () => fetch(apiUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
@@ -53629,6 +53780,7 @@ If you cannot use structured tool_calls, format as JSON:
         signal: controller.signal,
         dispatcher: localProviderAgent
       });
+      const response = LocalModelQueue.isEnabled() ? await LocalModelQueue.getInstance().enqueue(doFetch, this.provider.name) : await doFetch();
       clearTimeout(timeoutId);
       log(`[LocalProvider:${this.provider.name}] Response status: ${response.status}`);
       if (!response.ok) {
@@ -53706,6 +53858,7 @@ var init_local_provider_handler = __esm(() => {
   init_logger();
   init_undici();
   init_openai_compat();
+  init_local_queue();
   localProviderAgent = new $Agent({
     headersTimeout: 600000,
     bodyTimeout: 600000,
@@ -58545,7 +58698,21 @@ var getRemoteProviders = () => [
       supportsVision: true,
       supportsStreaming: true,
       supportsJsonMode: true,
-      supportsReasoning: false
+      supportsReasoning: true
+    }
+  },
+  {
+    name: "zai",
+    baseUrl: process.env.ZAI_BASE_URL || "https://api.z.ai",
+    apiPath: "/api/anthropic/v1/messages",
+    apiKeyEnvVar: "ZAI_API_KEY",
+    prefixes: ["zai/"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      supportsReasoning: true
     }
   },
   {
@@ -58578,6 +58745,323 @@ var getRemoteProviders = () => [
   }
 ];
 
+// ../core/dist/providers/provider-resolver.js
+function isApiKeyAvailable(info) {
+  if (!info.envVar) {
+    return true;
+  }
+  if (process.env[info.envVar]) {
+    return true;
+  }
+  if (info.aliases) {
+    for (const alias of info.aliases) {
+      if (process.env[alias]) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function resolveModelProvider(modelId) {
+  if (!modelId) {
+    const info2 = API_KEY_INFO.openrouter;
+    return {
+      category: "openrouter",
+      providerName: "OpenRouter",
+      modelName: "",
+      fullModelId: "",
+      requiredApiKeyEnvVar: info2.envVar,
+      apiKeyAvailable: isApiKeyAvailable(info2),
+      apiKeyDescription: info2.description,
+      apiKeyUrl: info2.url
+    };
+  }
+  const lowerModelId = modelId.toLowerCase();
+  if (LOCAL_PREFIXES.some((prefix) => lowerModelId.startsWith(prefix))) {
+    const resolved = resolveProvider(modelId);
+    const urlParsed = parseUrlModel(modelId);
+    let providerName = "Local";
+    let modelName = modelId;
+    if (resolved) {
+      providerName = resolved.provider.name.charAt(0).toUpperCase() + resolved.provider.name.slice(1);
+      modelName = resolved.modelName;
+    } else if (urlParsed) {
+      providerName = "Custom URL";
+      modelName = urlParsed.modelName;
+    }
+    return {
+      category: "local",
+      providerName,
+      modelName,
+      fullModelId: modelId,
+      requiredApiKeyEnvVar: null,
+      apiKeyAvailable: true,
+      apiKeyDescription: null,
+      apiKeyUrl: null
+    };
+  }
+  const remoteResolved = resolveRemoteProvider(modelId);
+  if (remoteResolved) {
+    const provider = remoteResolved.provider;
+    if (provider.name === "openrouter") {
+      const info3 = API_KEY_INFO.openrouter;
+      return {
+        category: "openrouter",
+        providerName: "OpenRouter",
+        modelName: remoteResolved.modelName,
+        fullModelId: modelId,
+        requiredApiKeyEnvVar: info3.envVar,
+        apiKeyAvailable: isApiKeyAvailable(info3),
+        apiKeyDescription: info3.description,
+        apiKeyUrl: info3.url
+      };
+    }
+    const info2 = API_KEY_INFO[provider.name] || {
+      envVar: provider.apiKeyEnvVar,
+      description: `${provider.name} API Key`,
+      url: ""
+    };
+    if (isApiKeyAvailable(info2)) {
+      const providerDisplayName2 = PROVIDER_DISPLAY_NAMES[provider.name] || provider.name.charAt(0).toUpperCase() + provider.name.slice(1);
+      return {
+        category: "direct-api",
+        providerName: providerDisplayName2,
+        modelName: remoteResolved.modelName,
+        fullModelId: modelId,
+        requiredApiKeyEnvVar: info2.envVar || null,
+        apiKeyAvailable: isApiKeyAvailable(info2),
+        apiKeyDescription: info2.envVar ? info2.description : null,
+        apiKeyUrl: info2.envVar ? info2.url : null
+      };
+    }
+    if (isApiKeyAvailable(API_KEY_INFO.openrouter)) {
+      const orInfo = API_KEY_INFO.openrouter;
+      return {
+        category: "openrouter",
+        providerName: "OpenRouter (fallback)",
+        modelName: modelId,
+        fullModelId: modelId,
+        requiredApiKeyEnvVar: orInfo.envVar,
+        apiKeyAvailable: true,
+        apiKeyDescription: orInfo.description,
+        apiKeyUrl: orInfo.url
+      };
+    }
+    if (isApiKeyAvailable(API_KEY_INFO.vertex)) {
+      const vertexInfo = API_KEY_INFO.vertex;
+      return {
+        category: "direct-api",
+        providerName: "Vertex AI (fallback)",
+        modelName: modelId,
+        fullModelId: modelId,
+        requiredApiKeyEnvVar: vertexInfo.envVar,
+        apiKeyAvailable: true,
+        apiKeyDescription: vertexInfo.description,
+        apiKeyUrl: vertexInfo.url
+      };
+    }
+    const providerDisplayName = PROVIDER_DISPLAY_NAMES[provider.name] || provider.name.charAt(0).toUpperCase() + provider.name.slice(1);
+    return {
+      category: "direct-api",
+      providerName: providerDisplayName,
+      modelName: remoteResolved.modelName,
+      fullModelId: modelId,
+      requiredApiKeyEnvVar: info2.envVar || null,
+      apiKeyAvailable: false,
+      apiKeyDescription: info2.envVar ? info2.description : null,
+      apiKeyUrl: info2.envVar ? info2.url : null
+    };
+  }
+  if (!modelId.includes("/")) {
+    return {
+      category: "native-anthropic",
+      providerName: "Anthropic (Native)",
+      modelName: modelId,
+      fullModelId: modelId,
+      requiredApiKeyEnvVar: null,
+      apiKeyAvailable: true,
+      apiKeyDescription: null,
+      apiKeyUrl: null
+    };
+  }
+  const info = API_KEY_INFO.openrouter;
+  return {
+    category: "openrouter",
+    providerName: "OpenRouter",
+    modelName: modelId,
+    fullModelId: modelId,
+    requiredApiKeyEnvVar: info.envVar,
+    apiKeyAvailable: isApiKeyAvailable(info),
+    apiKeyDescription: info.description,
+    apiKeyUrl: info.url
+  };
+}
+function validateApiKeysForModels(models) {
+  return models.filter((m) => m !== undefined).map((m) => resolveModelProvider(m));
+}
+function getMissingKeyResolutions(resolutions) {
+  return resolutions.filter((r) => r.requiredApiKeyEnvVar && !r.apiKeyAvailable);
+}
+function getMissingKeyError(resolution) {
+  if (!resolution.requiredApiKeyEnvVar || resolution.apiKeyAvailable) {
+    return "";
+  }
+  const lines = [];
+  lines.push(`Error: ${resolution.apiKeyDescription} is required for model "${resolution.fullModelId}"`);
+  lines.push("");
+  lines.push("Set it with:");
+  lines.push(`  export ${resolution.requiredApiKeyEnvVar}='your-key-here'`);
+  if (resolution.apiKeyUrl) {
+    lines.push("");
+    lines.push(`Get your API key from: ${resolution.apiKeyUrl}`);
+  }
+  if (resolution.category === "openrouter") {
+    const provider = resolution.fullModelId.split("/")[0];
+    lines.push("");
+    lines.push(`Tip: "${resolution.fullModelId}" is an OpenRouter model.`);
+    lines.push(`     OpenRouter routes to ${provider}'s API through their unified interface.`);
+    if (provider === "google") {
+      lines.push("");
+      lines.push("     For direct Gemini API (no OpenRouter), use prefix 'g/' or 'gemini/':");
+      lines.push('       claudish --model g/gemini-2.0-flash "task"');
+    } else if (provider === "openai") {
+      lines.push("");
+      lines.push("     For direct OpenAI API (no OpenRouter), use prefix 'oai/':");
+      lines.push('       claudish --model oai/gpt-4o "task"');
+    }
+  }
+  return lines.join(`
+`);
+}
+function getMissingKeysError(resolutions) {
+  const missing = getMissingKeyResolutions(resolutions);
+  if (missing.length === 0) {
+    return "";
+  }
+  if (missing.length === 1) {
+    return getMissingKeyError(missing[0]);
+  }
+  const lines = [];
+  lines.push("Error: Multiple API keys are required for the configured models:");
+  lines.push("");
+  const byEnvVar = new Map;
+  for (const r of missing) {
+    if (r.requiredApiKeyEnvVar && !byEnvVar.has(r.requiredApiKeyEnvVar)) {
+      byEnvVar.set(r.requiredApiKeyEnvVar, r);
+    }
+  }
+  for (const [envVar, resolution] of byEnvVar) {
+    lines.push(`  ${resolution.apiKeyDescription}:`);
+    lines.push(`    export ${envVar}='your-key-here'`);
+    if (resolution.apiKeyUrl) {
+      lines.push(`    Get from: ${resolution.apiKeyUrl}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function requiresOpenRouterKey(modelId) {
+  const resolution = resolveModelProvider(modelId);
+  return resolution.category === "openrouter";
+}
+function isLocalModel(modelId) {
+  if (!modelId)
+    return false;
+  const resolution = resolveModelProvider(modelId);
+  return resolution.category === "local";
+}
+var API_KEY_INFO, LOCAL_PREFIXES, PROVIDER_DISPLAY_NAMES;
+var init_provider_resolver = __esm(() => {
+  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/"
+    },
+    kimi: {
+      envVar: "MOONSHOT_API_KEY",
+      description: "Kimi/Moonshot API Key",
+      url: "https://platform.moonshot.cn/",
+      aliases: ["KIMI_API_KEY"]
+    },
+    glm: {
+      envVar: "ZHIPU_API_KEY",
+      description: "GLM/Zhipu API Key",
+      url: "https://open.bigmodel.cn/",
+      aliases: ["GLM_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/"
+    }
+  };
+  LOCAL_PREFIXES = [
+    "ollama/",
+    "ollama:",
+    "lmstudio/",
+    "lmstudio:",
+    "mlstudio/",
+    "mlstudio:",
+    "vllm/",
+    "vllm:",
+    "mlx/",
+    "mlx:",
+    "http://",
+    "https://localhost"
+  ];
+  PROVIDER_DISPLAY_NAMES = {
+    gemini: "Gemini",
+    "gemini-codeassist": "Gemini Code Assist",
+    vertex: "Vertex AI",
+    openai: "OpenAI",
+    openrouter: "OpenRouter",
+    minimax: "MiniMax",
+    kimi: "Kimi",
+    glm: "GLM",
+    zai: "Z.AI",
+    ollamacloud: "OllamaCloud",
+    "opencode-zen": "OpenCode Zen"
+  };
+});
+
 // ../core/dist/proxy-server.js
 async function createProxyServer(port, openrouterApiKey, model, monitorMode = false, anthropicApiKey, modelMap, options = {}) {
   const nativeHandler = new NativeHandler(anthropicApiKey);
@@ -58633,68 +59117,70 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     if (remoteProviderHandlers.has(targetModel)) {
       return remoteProviderHandlers.get(targetModel);
     }
-    const resolved = resolveRemoteProvider(targetModel);
-    if (!resolved) {
+    const resolution = resolveModelProvider(targetModel);
+    if (resolution.category === "openrouter") {
       return null;
     }
-    if (resolved.provider.name === "openrouter") {
-      return null;
-    }
-    const apiKeyError = validateRemoteProviderApiKey(resolved.provider);
-    if (apiKeyError) {
-      throw new Error(apiKeyError);
-    }
-    const apiKey = resolved.provider.apiKeyEnvVar ? process.env[resolved.provider.apiKeyEnvVar] || "" : "";
-    let handler;
-    if (resolved.provider.name === "gemini") {
-      handler = new GeminiHandler(resolved.provider, resolved.modelName, apiKey, port);
-      log(`[Proxy] Created Gemini handler: ${resolved.modelName}`);
-    } else if (resolved.provider.name === "gemini-codeassist") {
-      handler = new GeminiCodeAssistHandler(resolved.modelName, port);
-      log(`[Proxy] Created Gemini Code Assist handler: ${resolved.modelName}`);
-    } else if (resolved.provider.name === "openai") {
-      handler = new OpenAIHandler(resolved.provider, resolved.modelName, apiKey, port);
-      log(`[Proxy] Created OpenAI handler: ${resolved.modelName}`);
-    } else if (resolved.provider.name === "minimax" || resolved.provider.name === "kimi") {
-      handler = new AnthropicCompatHandler(resolved.provider, resolved.modelName, apiKey, port);
-      log(`[Proxy] Created ${resolved.provider.name} handler: ${resolved.modelName}`);
-    } else if (resolved.provider.name === "glm") {
-      handler = new OpenAIHandler(resolved.provider, resolved.modelName, apiKey, port);
-      log(`[Proxy] Created ${resolved.provider.name} handler: ${resolved.modelName}`);
-    } else if (resolved.provider.name === "opencode-zen") {
-      if (resolved.modelName.toLowerCase().includes("minimax")) {
+    if (resolution.category === "direct-api" && resolution.apiKeyAvailable) {
+      const resolved = resolveRemoteProvider(targetModel);
+      if (!resolved)
+        return null;
+      if (resolved.provider.name === "openrouter") {
+        return null;
+      }
+      const apiKey = resolved.provider.apiKeyEnvVar ? process.env[resolved.provider.apiKeyEnvVar] || "" : "";
+      let handler;
+      if (resolved.provider.name === "gemini") {
+        handler = new GeminiHandler(resolved.provider, resolved.modelName, apiKey, port);
+        log(`[Proxy] Created Gemini handler: ${resolved.modelName}`);
+      } else if (resolved.provider.name === "gemini-codeassist") {
+        handler = new GeminiCodeAssistHandler(resolved.modelName, port);
+        log(`[Proxy] Created Gemini Code Assist handler: ${resolved.modelName}`);
+      } else if (resolved.provider.name === "openai") {
+        handler = new OpenAIHandler(resolved.provider, resolved.modelName, apiKey, port);
+        log(`[Proxy] Created OpenAI handler: ${resolved.modelName}`);
+      } else if (resolved.provider.name === "minimax" || resolved.provider.name === "kimi" || resolved.provider.name === "zai") {
         handler = new AnthropicCompatHandler(resolved.provider, resolved.modelName, apiKey, port);
-        log(`[Proxy] Created OpenCode Zen (Anthropic) handler: ${resolved.modelName}`);
-      } else {
+        log(`[Proxy] Created ${resolved.provider.name} handler: ${resolved.modelName}`);
+      } else if (resolved.provider.name === "glm") {
         handler = new OpenAIHandler(resolved.provider, resolved.modelName, apiKey, port);
-        log(`[Proxy] Created OpenCode Zen (OpenAI) handler: ${resolved.modelName}`);
-      }
-    } else if (resolved.provider.name === "ollamacloud") {
-      handler = new OllamaCloudHandler(resolved.provider, resolved.modelName, apiKey, port);
-      log(`[Proxy] Created OllamaCloud handler: ${resolved.modelName}`);
-    } else if (resolved.provider.name === "vertex") {
-      const hasApiKey = !!process.env.VERTEX_API_KEY;
-      const vertexConfig = getVertexConfig();
-      if (hasApiKey) {
-        handler = new GeminiHandler(resolved.provider, resolved.modelName, apiKey, port);
-        log(`[Proxy] Created Vertex AI Express handler: ${resolved.modelName}`);
-      } else if (vertexConfig) {
-        const oauthError = validateVertexOAuthConfig();
-        if (oauthError) {
-          log(`[Proxy] Vertex OAuth config error: ${oauthError}`);
+        log(`[Proxy] Created ${resolved.provider.name} handler: ${resolved.modelName}`);
+      } else if (resolved.provider.name === "opencode-zen") {
+        if (resolved.modelName.toLowerCase().includes("minimax")) {
+          handler = new AnthropicCompatHandler(resolved.provider, resolved.modelName, apiKey, port);
+          log(`[Proxy] Created OpenCode Zen (Anthropic) handler: ${resolved.modelName}`);
+        } else {
+          handler = new OpenAIHandler(resolved.provider, resolved.modelName, apiKey, port);
+          log(`[Proxy] Created OpenCode Zen (OpenAI) handler: ${resolved.modelName}`);
+        }
+      } else if (resolved.provider.name === "ollamacloud") {
+        handler = new OllamaCloudHandler(resolved.provider, resolved.modelName, apiKey, port);
+        log(`[Proxy] Created OllamaCloud handler: ${resolved.modelName}`);
+      } else if (resolved.provider.name === "vertex") {
+        const hasApiKey = !!process.env.VERTEX_API_KEY;
+        const vertexConfig = getVertexConfig();
+        if (hasApiKey) {
+          handler = new GeminiHandler(resolved.provider, resolved.modelName, apiKey, port);
+          log(`[Proxy] Created Vertex AI Express handler: ${resolved.modelName}`);
+        } else if (vertexConfig) {
+          const oauthError = validateVertexOAuthConfig();
+          if (oauthError) {
+            log(`[Proxy] Vertex OAuth config error: ${oauthError}`);
+            return null;
+          }
+          handler = new VertexOAuthHandler(resolved.modelName, port);
+          log(`[Proxy] Created Vertex AI OAuth handler: ${resolved.modelName} (project: ${vertexConfig.projectId})`);
+        } else {
+          log(`[Proxy] Vertex AI requires either VERTEX_API_KEY or VERTEX_PROJECT`);
           return null;
         }
-        handler = new VertexOAuthHandler(resolved.modelName, port);
-        log(`[Proxy] Created Vertex AI OAuth handler: ${resolved.modelName} (project: ${vertexConfig.projectId})`);
       } else {
-        log(`[Proxy] Vertex AI requires either VERTEX_API_KEY or VERTEX_PROJECT`);
         return null;
       }
-    } else {
-      return null;
+      remoteProviderHandlers.set(targetModel, handler);
+      return handler;
     }
-    remoteProviderHandlers.set(targetModel, handler);
-    return handler;
+    return null;
   };
   const getHandlerForRequest = (requestedModel) => {
     if (monitorMode)
@@ -58799,18 +59285,22 @@ var init_proxy_server = __esm(() => {
   init_poe_handler();
   init_ollamacloud_handler();
   init_vertex_auth();
+  init_provider_resolver();
 });
 
 // ../core/dist/index.js
 var exports_dist = {};
 __export(exports_dist, {
   validateRemoteProviderApiKey: () => validateRemoteProviderApiKey,
+  validateApiKeysForModels: () => validateApiKeysForModels,
   transformOpenAIToClaude: () => transformOpenAIToClaude,
   transformMessages: () => transformMessages,
   setupGeminiUser: () => setupGeminiUser,
   sanitizeRoot: () => sanitizeRoot,
   resolveRemoteProvider: () => resolveRemoteProvider,
   resolveProvider: () => resolveProvider,
+  resolveModelProvider: () => resolveModelProvider,
+  requiresOpenRouterKey: () => requiresOpenRouterKey,
   removeUriFormat: () => removeUriFormat,
   parseUrlModel: () => parseUrlModel,
   mapTools: () => mapTools,
@@ -58819,10 +59309,14 @@ __export(exports_dist, {
   log: () => log,
   isLoggingEnabled: () => isLoggingEnabled,
   isLocalProvider: () => isLocalProvider,
+  isLocalModel: () => isLocalModel,
   initLogger: () => initLogger,
   getValidAccessToken: () => getValidAccessToken,
   getRegisteredRemoteProviders: () => getRegisteredRemoteProviders,
   getRegisteredProviders: () => getRegisteredProviders,
+  getMissingKeysError: () => getMissingKeysError,
+  getMissingKeyResolutions: () => getMissingKeyResolutions,
+  getMissingKeyError: () => getMissingKeyError,
   getLogFilePath: () => getLogFilePath,
   createUrlProvider: () => createUrlProvider,
   createProxyServer: () => createProxyServer,
@@ -58851,6 +59345,7 @@ var init_dist3 = __esm(() => {
   init_poe_handler();
   init_gemini_codeassist_handler();
   init_gemini_oauth();
+  init_provider_resolver();
   init_transform();
   init_manager();
   init_gemini_thought_signature();
@@ -61983,9 +62478,15 @@ function fuzzyScore2(text, query) {
 // src/cli.ts
 var exports_cli = {};
 __export(exports_cli, {
+  validateApiKeysForModels: () => validateApiKeysForModels,
+  resolveModelProvider: () => resolveModelProvider,
+  requiresOpenRouterKey: () => requiresOpenRouterKey,
   parseArgs: () => parseArgs,
   isLocalModel: () => isLocalModel,
-  getVersion: () => getVersion
+  getVersion: () => getVersion,
+  getMissingKeysError: () => getMissingKeysError,
+  getMissingKeyResolutions: () => getMissingKeyResolutions,
+  getMissingKeyError: () => getMissingKeyError
 });
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync13, existsSync as existsSync9, mkdirSync as mkdirSync11, copyFileSync } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
@@ -61993,20 +62494,6 @@ import { dirname as dirname5, join as join17 } from "node:path";
 function getVersion() {
   return VERSION;
 }
-function isLocalModel(modelId) {
-  if (!modelId)
-    return false;
-  const localPrefixes = [
-    "ollama/",
-    "ollama:",
-    "lmstudio/",
-    "vllm/",
-    "mlx/",
-    "http://",
-    "https://localhost"
-  ];
-  return localPrefixes.some((prefix) => modelId.toLowerCase().startsWith(prefix));
-}
 async function parseArgs(args) {
   const config3 = {
     model: undefined,
@@ -62186,35 +62673,9 @@ async function parseArgs(args) {
       console.log("[claudish] API key will be extracted from Claude Code's requests");
       console.log("[claudish] Ensure you are logged in to Claude Code (claude auth login)");
     }
-  } else {
-    const allModels = [
-      config3.model,
-      config3.modelOpus,
-      config3.modelSonnet,
-      config3.modelHaiku,
-      config3.modelSubagent
-    ];
-    const hasNonLocalModel = allModels.some((m) => m && !isLocalModel(m));
-    if (hasNonLocalModel) {
-      const apiKey = process.env[ENV.OPENROUTER_API_KEY];
-      if (!apiKey) {
-        if (!config3.interactive) {
-          console.error("Error: OPENROUTER_API_KEY environment variable is required");
-          console.error("Get your API key from: https://openrouter.ai/keys");
-          console.error("");
-          console.error("Set it now:");
-          console.error("  export OPENROUTER_API_KEY='sk-or-v1-...'");
-          process.exit(1);
-        }
-        config3.openrouterApiKey = undefined;
-      } else {
-        config3.openrouterApiKey = apiKey;
-      }
-    } else {
-      config3.openrouterApiKey = process.env[ENV.OPENROUTER_API_KEY];
-    }
-    config3.anthropicApiKey = process.env.ANTHROPIC_API_KEY;
   }
+  config3.openrouterApiKey = process.env[ENV.OPENROUTER_API_KEY];
+  config3.anthropicApiKey = process.env.ANTHROPIC_API_KEY;
   if (config3.quiet === undefined) {
     config3.quiet = !config3.interactive;
   }
@@ -62691,7 +63152,7 @@ function printVersion() {
 }
 function printHelp() {
   console.log(`
-claudish - Run Claude Code with any AI model (OpenRouter, Gemini, OpenAI, MiniMax, Kimi, GLM, Local)
+claudish - Run Claude Code with any AI model (OpenRouter, Gemini, OpenAI, MiniMax, Kimi, GLM, Z.AI, Local)
 
 USAGE:
   claudish                                # Interactive mode (default, shows model selector)
@@ -62705,6 +63166,7 @@ MODEL ROUTING (prefix-based):
   mmax/, mm/       MiniMax Direct API     claudish --model mmax/MiniMax-M2.1 "task"
   kimi/, moonshot/ Kimi Direct API        claudish --model kimi/kimi-k2-thinking-turbo "task"
   glm/, zhipu/     GLM Direct API         claudish --model glm/glm-4.7 "task"
+  zai/             Z.AI Direct API        claudish --model zai/glm-4.7 "task"
   oc/              OllamaCloud            claudish --model oc/gpt-oss:20b "task"
   zen/             OpenCode Zen (free)    claudish --model zen/grok-code "task"
   ollama/          Ollama (local)         claudish --model ollama/llama3.2 "task"
@@ -63139,11 +63601,12 @@ async function fetchZenModels2() {
     return [];
   }
 }
-var __filename6, __dirname6, VERSION = "3.9.0", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, ALL_MODELS_JSON_PATH2;
+var __filename6, __dirname6, VERSION = "3.11.0", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, ALL_MODELS_JSON_PATH2;
 var init_cli = __esm(() => {
   init_dist3();
   init_model_loader2();
   init_profile_config();
+  init_dist3();
   __filename6 = fileURLToPath5(import.meta.url);
   __dirname6 = dirname5(__filename6);
   try {
@@ -63842,6 +64305,12 @@ async function runCli() {
   const { parseArgs: parseArgs2, getVersion: getVersion2 } = await Promise.resolve().then(() => (init_cli(), exports_cli));
   const { DEFAULT_PORT_RANGE: DEFAULT_PORT_RANGE2 } = await Promise.resolve().then(() => (init_dist3(), exports_dist));
   const { selectModel: selectModel2, promptForApiKey: promptForApiKey2 } = await Promise.resolve().then(() => (init_model_selector(), exports_model_selector));
+  const {
+    resolveModelProvider: resolveModelProvider2,
+    validateApiKeysForModels: validateApiKeysForModels2,
+    getMissingKeyResolutions: getMissingKeyResolutions2,
+    getMissingKeysError: getMissingKeysError2
+  } = await Promise.resolve().then(() => (init_dist3(), exports_dist));
   const { initLogger: initLogger2, getLogFilePath: getLogFilePath2 } = await Promise.resolve().then(() => (init_dist3(), exports_dist));
   const { findAvailablePort: findAvailablePort2 } = await Promise.resolve().then(() => (init_port_manager(), exports_port_manager));
   const { createProxyServer: createProxyServer2 } = await Promise.resolve().then(() => (init_dist3(), exports_dist));
@@ -63879,12 +64348,6 @@ async function runCli() {
       console.error("  export CLAUDE_PATH=~/.claude/local/claude");
       process.exit(1);
     }
-    const { isLocalModel: isLocalModel2 } = await Promise.resolve().then(() => (init_cli(), exports_cli));
-    const usingLocalModel = isLocalModel2(cliConfig.model);
-    if (cliConfig.interactive && !cliConfig.monitor && !cliConfig.openrouterApiKey && !usingLocalModel) {
-      cliConfig.openrouterApiKey = await promptForApiKey2();
-      console.log("");
-    }
     if (cliConfig.interactive && !cliConfig.monitor && !cliConfig.model) {
       cliConfig.model = await selectModel2({ freeOnly: cliConfig.freeOnly });
       console.log("");
@@ -63895,6 +64358,37 @@ async function runCli() {
       console.error("Try: claudish --list-models");
       process.exit(1);
     }
+    if (!cliConfig.monitor) {
+      const hasExplicitModel = typeof cliConfig.model === "string";
+      const modelsToValidate = hasExplicitModel ? [cliConfig.model] : [
+        cliConfig.model,
+        cliConfig.modelOpus,
+        cliConfig.modelSonnet,
+        cliConfig.modelHaiku,
+        cliConfig.modelSubagent
+      ];
+      const resolutions = validateApiKeysForModels2(modelsToValidate);
+      const missingKeys = getMissingKeyResolutions2(resolutions);
+      if (missingKeys.length > 0) {
+        if (cliConfig.interactive) {
+          const needsOpenRouter = missingKeys.some((r) => r.category === "openrouter");
+          if (needsOpenRouter && !cliConfig.openrouterApiKey) {
+            cliConfig.openrouterApiKey = await promptForApiKey2();
+            console.log("");
+            process.env.OPENROUTER_API_KEY = cliConfig.openrouterApiKey;
+          }
+          const stillMissing = getMissingKeyResolutions2(validateApiKeysForModels2(modelsToValidate));
+          const nonOpenRouterMissing = stillMissing.filter((r) => r.category !== "openrouter");
+          if (nonOpenRouterMissing.length > 0) {
+            console.error(getMissingKeysError2(nonOpenRouterMissing));
+            process.exit(1);
+          }
+        } else {
+          console.error(getMissingKeysError2(missingKeys));
+          process.exit(1);
+        }
+      }
+    }
     if (cliConfig.model && typeof cliConfig.model === "string" && cliConfig.model.startsWith("go/")) {
       const { GeminiOAuth: GeminiOAuth2 } = await Promise.resolve().then(() => (init_dist3(), exports_dist));
       const oauth = GeminiOAuth2.getInstance();

package/package.json

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