claudish 3.7.8 → 3.8.0

package/dist/index.js

@@ -32119,6 +32119,250 @@ var init_openai_compat = __esm(() => {
   init_tool_call_recovery();
 });
 
+// ../core/dist/handlers/shared/openrouter-queue.js
+class OpenRouterRequestQueue {
+  static instance = null;
+  queue = [];
+  processing = false;
+  rateLimitState = {
+    limitRequests: null,
+    limitTokens: null,
+    remainingRequests: null,
+    remainingTokens: null,
+    resetTime: null,
+    lastRequestTime: 0,
+    consecutiveErrors: 0,
+    currentDelayMs: 1000,
+    totalProcessed: 0,
+    totalErrors: 0,
+    total429Errors: 0
+  };
+  baseDelayMs = 1000;
+  maxDelayMs = 1e4;
+  maxQueueSize = 100;
+  constructor() {
+    if (getLogLevel() === "debug") {
+      log("[OpenRouterQueue] Queue initialized with baseDelay=1000ms, maxQueueSize=100");
+    }
+  }
+  static getInstance() {
+    if (!OpenRouterRequestQueue.instance) {
+      OpenRouterRequestQueue.instance = new OpenRouterRequestQueue;
+    }
+    return OpenRouterRequestQueue.instance;
+  }
+  async enqueue(fetchFn) {
+    if (this.queue.length >= this.maxQueueSize) {
+      if (getLogLevel() === "debug") {
+        log(`[OpenRouterQueue] Queue full (${this.queue.length}/${this.maxQueueSize}), rejecting request`);
+      }
+      throw new Error(`OpenRouter request queue full (${this.queue.length}/${this.maxQueueSize}). The API is rate-limited. Please wait and try again.`);
+    }
+    return new Promise((resolve, reject) => {
+      const queuedRequest = {
+        fetchFn,
+        resolve,
+        reject
+      };
+      this.queue.push(queuedRequest);
+      if (getLogLevel() === "debug") {
+        log(`[OpenRouterQueue] Request enqueued (queue length: ${this.queue.length})`);
+      }
+      if (!this.processing) {
+        this.processQueue();
+      }
+    });
+  }
+  async processQueue() {
+    if (this.processing) {
+      return;
+    }
+    this.processing = true;
+    if (getLogLevel() === "debug") {
+      log("[OpenRouterQueue] Worker started");
+    }
+    while (this.queue.length > 0) {
+      const request = this.queue.shift();
+      if (!request)
+        break;
+      if (getLogLevel() === "debug") {
+        log(`[OpenRouterQueue] Processing request (${this.queue.length} remaining in queue)`);
+      }
+      try {
+        await this.waitForNextSlot();
+        const response = await request.fetchFn();
+        this.rateLimitState.lastRequestTime = Date.now();
+        this.parseRateLimitHeaders(response);
+        if (response.status === 429) {
+          this.rateLimitState.totalErrors++;
+          this.rateLimitState.total429Errors++;
+          await this.handleRateLimitError(response);
+          if (getLogLevel() === "debug") {
+            log(`[OpenRouterQueue] Rate limit hit (429), adjusted delay to ${this.rateLimitState.currentDelayMs}ms`);
+          }
+        } else {
+          this.handleSuccessResponse();
+        }
+        this.rateLimitState.totalProcessed++;
+        request.resolve(response);
+      } catch (error46) {
+        this.rateLimitState.totalErrors++;
+        this.rateLimitState.consecutiveErrors++;
+        if (getLogLevel() === "debug") {
+          log(`[OpenRouterQueue] Request failed with error: ${error46}`);
+        }
+        request.reject(error46 instanceof Error ? error46 : new Error(String(error46)));
+      }
+    }
+    this.processing = false;
+    if (getLogLevel() === "debug") {
+      log("[OpenRouterQueue] Worker stopped (queue empty)");
+    }
+  }
+  async waitForNextSlot() {
+    const now = Date.now();
+    const timeSinceLastRequest = now - this.rateLimitState.lastRequestTime;
+    const delayMs = this.calculateDelay();
+    this.rateLimitState.currentDelayMs = delayMs;
+    if (timeSinceLastRequest < delayMs) {
+      const waitMs = delayMs - timeSinceLastRequest;
+      if (getLogLevel() === "debug") {
+        log(`[OpenRouterQueue] Waiting ${waitMs}ms before next request`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, waitMs));
+    }
+  }
+  calculateDelay() {
+    let delayMs = this.baseDelayMs;
+    if (this.rateLimitState.remainingRequests !== null && this.rateLimitState.limitRequests !== null && this.rateLimitState.limitRequests > 0) {
+      const quotaPercent = this.rateLimitState.remainingRequests / this.rateLimitState.limitRequests;
+      if (quotaPercent < 0.2) {
+        delayMs = Math.max(delayMs, 3000);
+        if (getLogLevel() === "debug") {
+          log(`[OpenRouterQueue] Low quota (${(quotaPercent * 100).toFixed(1)}%), increasing delay to ${delayMs}ms`);
+        }
+      } else if (quotaPercent < 0.5) {
+        delayMs = Math.max(delayMs, 2000);
+        if (getLogLevel() === "debug") {
+          log(`[OpenRouterQueue] Medium quota (${(quotaPercent * 100).toFixed(1)}%), increasing delay to ${delayMs}ms`);
+        }
+      }
+    }
+    if (this.rateLimitState.resetTime !== null && this.rateLimitState.remainingRequests !== null) {
+      const now = Date.now() / 1000;
+      const timeUntilReset = this.rateLimitState.resetTime - now;
+      if (timeUntilReset > 0 && this.rateLimitState.remainingRequests > 0) {
+        const optimalDelay = timeUntilReset * 1000 / Math.max(this.rateLimitState.remainingRequests, 1);
+        delayMs = Math.max(delayMs, Math.min(optimalDelay, this.maxDelayMs));
+        if (getLogLevel() === "debug") {
+          log(`[OpenRouterQueue] Spreading ${this.rateLimitState.remainingRequests} requests ` + `over ${timeUntilReset.toFixed(1)}s, optimal delay: ${optimalDelay.toFixed(0)}ms`);
+        }
+      }
+    }
+    if (this.rateLimitState.consecutiveErrors > 0) {
+      const backoffMultiplier = 1 + this.rateLimitState.consecutiveErrors * 0.5;
+      delayMs = delayMs * backoffMultiplier;
+      if (getLogLevel() === "debug") {
+        log(`[OpenRouterQueue] Applying backoff (${this.rateLimitState.consecutiveErrors} errors): ${delayMs.toFixed(0)}ms`);
+      }
+    }
+    return Math.min(delayMs, this.maxDelayMs);
+  }
+  parseRateLimitHeaders(response) {
+    const limitRequests = response.headers.get("X-RateLimit-Limit-Requests");
+    if (limitRequests) {
+      this.rateLimitState.limitRequests = Number.parseInt(limitRequests, 10);
+    }
+    const remainingRequests = response.headers.get("X-RateLimit-Remaining-Requests");
+    if (remainingRequests) {
+      this.rateLimitState.remainingRequests = Number.parseInt(remainingRequests, 10);
+    }
+    const resetRequests = response.headers.get("X-RateLimit-Reset-Requests");
+    if (resetRequests) {
+      this.rateLimitState.resetTime = Number.parseFloat(resetRequests);
+    }
+    const limitTokens = response.headers.get("X-RateLimit-Limit-Tokens");
+    if (limitTokens) {
+      this.rateLimitState.limitTokens = Number.parseInt(limitTokens, 10);
+    }
+    const remainingTokens = response.headers.get("X-RateLimit-Remaining-Tokens");
+    if (remainingTokens) {
+      this.rateLimitState.remainingTokens = Number.parseInt(remainingTokens, 10);
+    }
+    if (getLogLevel() === "debug") {
+      const headers = {
+        limitRequests: this.rateLimitState.limitRequests,
+        remainingRequests: this.rateLimitState.remainingRequests,
+        resetTime: this.rateLimitState.resetTime ? new Date(this.rateLimitState.resetTime * 1000).toISOString() : null,
+        limitTokens: this.rateLimitState.limitTokens,
+        remainingTokens: this.rateLimitState.remainingTokens
+      };
+      log(`[OpenRouterQueue] Rate limit headers: ${JSON.stringify(headers)}`);
+    }
+  }
+  async handleRateLimitError(response) {
+    this.rateLimitState.consecutiveErrors++;
+    this.rateLimitState.remainingRequests = 0;
+    const retryAfter = response.headers.get("Retry-After");
+    if (retryAfter) {
+      const retryAfterSeconds = Number.parseInt(retryAfter, 10);
+      if (!Number.isNaN(retryAfterSeconds)) {
+        const retryAfterMs = retryAfterSeconds * 1000;
+        this.rateLimitState.currentDelayMs = Math.min(retryAfterMs, this.maxDelayMs);
+        if (getLogLevel() === "debug") {
+          log(`[OpenRouterQueue] Retry-After header: ${retryAfterSeconds}s (${retryAfterMs}ms)`);
+        }
+      }
+    }
+    try {
+      const errorText = await response.clone().text();
+      const errorData = JSON.parse(errorText);
+      if (errorData?.error?.message) {
+        if (getLogLevel() === "debug") {
+          log(`[OpenRouterQueue] 429 error message: ${errorData.error.message}`);
+        }
+      }
+    } catch {}
+    const backoffMultiplier = 1 + this.rateLimitState.consecutiveErrors * 0.5;
+    const backoffDelay = Math.min(this.baseDelayMs * backoffMultiplier, this.maxDelayMs);
+    this.rateLimitState.currentDelayMs = Math.max(this.rateLimitState.currentDelayMs, backoffDelay);
+    if (getLogLevel() === "debug") {
+      log(`[OpenRouterQueue] Applied exponential backoff: ${this.rateLimitState.currentDelayMs}ms ` + `(${this.rateLimitState.consecutiveErrors} consecutive errors)`);
+    }
+  }
+  handleSuccessResponse() {
+    if (this.rateLimitState.consecutiveErrors > 0) {
+      if (getLogLevel() === "debug") {
+        log(`[OpenRouterQueue] Success after ${this.rateLimitState.consecutiveErrors} errors, resetting counter`);
+      }
+      this.rateLimitState.consecutiveErrors = 0;
+    }
+    if (this.rateLimitState.currentDelayMs > this.baseDelayMs) {
+      this.rateLimitState.currentDelayMs = Math.max(this.baseDelayMs, this.rateLimitState.currentDelayMs * 0.9);
+      if (getLogLevel() === "debug") {
+        log(`[OpenRouterQueue] Reducing delay to ${this.rateLimitState.currentDelayMs}ms`);
+      }
+    }
+  }
+  getStats() {
+    return {
+      queueLength: this.queue.length,
+      processing: this.processing,
+      consecutiveErrors: this.rateLimitState.consecutiveErrors,
+      currentDelayMs: this.rateLimitState.currentDelayMs,
+      totalProcessed: this.rateLimitState.totalProcessed,
+      totalErrors: this.rateLimitState.totalErrors,
+      total429Errors: this.rateLimitState.total429Errors,
+      remainingRequests: this.rateLimitState.remainingRequests,
+      remainingTokens: this.rateLimitState.remainingTokens,
+      resetTime: this.rateLimitState.resetTime
+    };
+  }
+}
+var init_openrouter_queue = __esm(() => {
+  init_logger();
+});
+
 // ../core/dist/handlers/openrouter-handler.js
 import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "node:fs";
 import { homedir } from "node:os";
@@ -32133,6 +32377,7 @@ class OpenRouterHandler {
   port;
   sessionTotalCost = 0;
   CLAUDE_INTERNAL_CONTEXT_MAX = 200000;
+  queue;
   constructor(targetModel, apiKey, port) {
     this.targetModel = targetModel;
     this.apiKey = apiKey;
@@ -32142,6 +32387,7 @@ class OpenRouterHandler {
     this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
     this.middlewareManager.initialize().catch((err) => log(`[Handler:${targetModel}] Middleware init error: ${err}`));
     this.fetchContextWindow(targetModel);
+    this.queue = OpenRouterRequestQueue.getInstance();
   }
   async fetchContextWindow(model) {
     if (this.contextWindowCache.has(model))
@@ -32161,6 +32407,7 @@ class OpenRouterHandler {
       const limit = this.contextWindowCache.get(this.targetModel) || 200000;
       const leftPct = limit > 0 ? Math.max(0, Math.min(100, Math.round((limit - total) / limit * 100))) : 100;
       const displayModelName = this.targetModel.replace(/^(go|g|gemini|v|vertex|oai|mmax|mm|kimi|moonshot|glm|zhipu|oc|ollama|lmstudio|vllm|mlx)[\/:]/, "");
+      const isFreeModel = this.targetModel.endsWith(":free") || this.sessionTotalCost === 0;
       const data = {
         input_tokens: input,
         output_tokens: output,
@@ -32170,7 +32417,8 @@ class OpenRouterHandler {
         context_left_percent: leftPct,
         provider_name: "OpenRouter",
         model_name: displayModelName,
-        updated_at: Date.now()
+        updated_at: Date.now(),
+        is_free: isFreeModel
       };
       const claudishDir = join4(homedir(), ".claudish");
       mkdirSync2(claudishDir, { recursive: true });
@@ -32232,7 +32480,7 @@ class OpenRouterHandler {
     await this.middlewareManager.beforeRequest({ modelId: target, messages, tools, stream: true });
     let response;
     try {
-      response = await fetch(OPENROUTER_API_URL2, {
+      response = await this.queue.enqueue(() => fetch(OPENROUTER_API_URL2, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -32240,16 +32488,26 @@ class OpenRouterHandler {
           ...OPENROUTER_HEADERS2
         },
         body: JSON.stringify(openRouterPayload)
-      });
+      }));
     } catch (fetchError) {
       log(`[OpenRouter] Fetch error: ${fetchError.message || fetchError}`);
       return this.createStreamingErrorResponse(c, target, `Network error: ${fetchError.message || "Connection failed"}`);
     }
     log(`[OpenRouter] Response status: ${response.status}`);
+    if (getLogLevel() === "debug") {
+      const rateLimitHeaders = {
+        remaining: response.headers.get("X-RateLimit-Remaining-Requests"),
+        limit: response.headers.get("X-RateLimit-Limit-Requests"),
+        reset: response.headers.get("X-RateLimit-Reset-Requests"),
+        remainingTokens: response.headers.get("X-RateLimit-Remaining-Tokens")
+      };
+      log(`[OpenRouter] Rate limit headers: ${JSON.stringify(rateLimitHeaders)}`);
+    }
     if (!response.ok) {
       const errorText = await response.text().catch(() => "Unknown error");
       log(`[OpenRouter] API error ${response.status}: ${errorText}`);
-      return this.createStreamingErrorResponse(c, target, `OpenRouter API error (${response.status}): ${errorText}`);
+      const friendlyMessage = this.formatErrorMessage(response.status, errorText, target);
+      return this.createStreamingErrorResponse(c, target, friendlyMessage);
     }
     if (droppedParams.length > 0)
       c.header("X-Dropped-Params", droppedParams.join(", "));
@@ -32677,6 +32935,36 @@ data: ${JSON.stringify(d)}
       }
     });
   }
+  formatErrorMessage(status, errorText, model) {
+    try {
+      const error46 = JSON.parse(errorText);
+      const msg = error46?.error?.message || "";
+      const metadata = error46?.error?.metadata || {};
+      if (status === 429) {
+        const provider = metadata.provider_name || "Provider";
+        if (msg.includes("rate-limited")) {
+          return `⏳ Rate limited by ${provider}. The model "${model}" is temporarily unavailable. Please wait a moment and try again, or try a different model.`;
+        }
+        return `⏳ Rate limit exceeded. Please wait and try again.`;
+      }
+      if (status === 404) {
+        if (msg.includes("tool use")) {
+          return `❌ Model "${model}" does not support tool calling, which is required by Claude Code. Try a different model with tool support.`;
+        }
+        return `❌ Model not found or unavailable: ${model}`;
+      }
+      if (status === 401 || status === 403) {
+        return `\uD83D\uDD11 Authentication error. Please check your OPENROUTER_API_KEY.`;
+      }
+      if (status >= 500) {
+        return `⚠️ OpenRouter server error (${status}). Please try again later.`;
+      }
+      if (msg) {
+        return `OpenRouter error (${status}): ${msg}`;
+      }
+    } catch {}
+    return `OpenRouter API error (${status}): ${errorText}`;
+  }
   createStreamingErrorResponse(c, model, errorMessage) {
     const encoder = new TextEncoder;
     const msgId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
@@ -32744,6 +33032,7 @@ var init_openrouter_handler = __esm(() => {
   init_logger();
   init_model_loader();
   init_openai_compat();
+  init_openrouter_queue();
   OPENROUTER_HEADERS2 = {
     "HTTP-Referer": "https://claudish.com",
     "X-Title": "Claudish - OpenRouter Proxy"
@@ -53726,6 +54015,10 @@ function getModelPricing(provider, modelName) {
     case "oc":
       pricingTable = OLLAMACLOUD_PRICING;
       break;
+    case "opencode-zen":
+    case "zen":
+      pricingTable = OPENCODE_ZEN_PRICING;
+      break;
     default:
       return { inputCostPer1M: 1, outputCostPer1M: 4 };
   }
@@ -53745,7 +54038,7 @@ function calculateCost(provider, modelName, inputTokens, outputTokens) {
   const outputCost = outputTokens / 1e6 * pricing.outputCostPer1M;
   return inputCost + outputCost;
 }
-var GEMINI_PRICING, OPENAI_PRICING, MINIMAX_PRICING, KIMI_PRICING, GLM_PRICING, OLLAMACLOUD_PRICING, VERTEX_PRICING;
+var GEMINI_PRICING, OPENAI_PRICING, MINIMAX_PRICING, KIMI_PRICING, GLM_PRICING, OLLAMACLOUD_PRICING, VERTEX_PRICING, OPENCODE_ZEN_PRICING;
 var init_remote_provider_types = __esm(() => {
   GEMINI_PRICING = {
     "gemini-2.5-flash": { inputCostPer1M: 0.15, outputCostPer1M: 0.6 },
@@ -53834,6 +54127,15 @@ var init_remote_provider_types = __esm(() => {
     "gemini-2.0-flash-thinking": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
     default: { inputCostPer1M: 0.5, outputCostPer1M: 2, isEstimate: true }
   };
+  OPENCODE_ZEN_PRICING = {
+    "grok-code": { inputCostPer1M: 0, outputCostPer1M: 0, isFree: true },
+    "grok-code-fast-1": { inputCostPer1M: 0, outputCostPer1M: 0, isFree: true },
+    "glm-4.7-free": { inputCostPer1M: 0, outputCostPer1M: 0, isFree: true },
+    "minimax-m2.1-free": { inputCostPer1M: 0, outputCostPer1M: 0, isFree: true },
+    "big-pickle": { inputCostPer1M: 0, outputCostPer1M: 0, isFree: true },
+    "gpt-5-nano": { inputCostPer1M: 0, outputCostPer1M: 0, isFree: true },
+    default: { inputCostPer1M: 0, outputCostPer1M: 0, isFree: true }
+  };
 });
 
 // ../core/dist/handlers/base-gemini-handler.js
@@ -55344,7 +55646,7 @@ class OpenAIHandler {
     }
   }
   getPricing() {
-    return getModelPricing("openai", this.modelName);
+    return getModelPricing(this.provider.name, this.modelName);
   }
   getApiEndpoint() {
     if (this.isCodexModel()) {
@@ -55356,7 +55658,16 @@ class OpenAIHandler {
     try {
       const total = input + output;
       const leftPct = this.contextWindow > 0 ? Math.max(0, Math.min(100, Math.round((this.contextWindow - total) / this.contextWindow * 100))) : 100;
-      const displayModelName = this.modelName.replace(/^(go|g|gemini|v|vertex|oai|mmax|mm|kimi|moonshot|glm|zhipu|oc|ollama|lmstudio|vllm|mlx)[\/:]/, "");
+      const displayModelName = this.modelName.replace(/^(go|g|gemini|v|vertex|oai|mmax|mm|kimi|moonshot|glm|zhipu|oc|zen|ollama|lmstudio|vllm|mlx)[\/:]/, "");
+      const formatProviderName = (name) => {
+        if (name === "opencode-zen")
+          return "Zen";
+        if (name === "glm")
+          return "GLM";
+        return name.charAt(0).toUpperCase() + name.slice(1);
+      };
+      const pricing = this.getPricing();
+      const isFreeModel = pricing.isFree || pricing.inputCostPer1M === 0 && pricing.outputCostPer1M === 0;
       const data = {
         input_tokens: input,
         output_tokens: output,
@@ -55364,13 +55675,12 @@ class OpenAIHandler {
         total_cost: this.sessionTotalCost,
         context_window: this.contextWindow,
         context_left_percent: leftPct,
-        provider_name: "OpenAI",
+        provider_name: formatProviderName(this.provider.name),
         model_name: displayModelName,
-        updated_at: Date.now()
+        updated_at: Date.now(),
+        is_free: isFreeModel,
+        is_estimated: isEstimate || false
       };
-      if (isEstimate) {
-        data.cost_is_estimate = true;
-      }
       const claudishDir = join9(homedir6(), ".claudish");
       mkdirSync6(claudishDir, { recursive: true });
       writeFileSync7(join9(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
@@ -55831,7 +56141,7 @@ data: ${JSON.stringify(data)}
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${this.apiKey}`
+          ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
         },
         body: JSON.stringify(apiPayload),
         signal: controller.signal
@@ -58121,7 +58431,8 @@ function validateRemoteProviderApiKey(provider) {
       MINIMAX_API_KEY: "export MINIMAX_API_KEY='your-key' (get from https://www.minimaxi.com/)",
       MOONSHOT_API_KEY: "export MOONSHOT_API_KEY='your-key' (get from https://platform.moonshot.cn/)",
       ZHIPU_API_KEY: "export ZHIPU_API_KEY='your-key' (get from https://open.bigmodel.cn/)",
-      OLLAMA_API_KEY: "export OLLAMA_API_KEY='your-key' (get from https://ollama.com/account)"
+      OLLAMA_API_KEY: "export OLLAMA_API_KEY='your-key' (get from https://ollama.com/account)",
+      OPENCODE_API_KEY: "export OPENCODE_API_KEY='your-key' (get from https://opencode.ai/)"
     };
     const example = examples[provider.apiKeyEnvVar] || `export ${provider.apiKeyEnvVar}='your-key'`;
     return `Missing ${provider.apiKeyEnvVar} environment variable.
@@ -58250,6 +58561,20 @@ var getRemoteProviders = () => [
       supportsJsonMode: false,
       supportsReasoning: false
     }
+  },
+  {
+    name: "opencode-zen",
+    baseUrl: process.env.OPENCODE_BASE_URL || "https://opencode.ai/zen",
+    apiPath: "/v1/chat/completions",
+    apiKeyEnvVar: "",
+    prefixes: ["zen/"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: false,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      supportsReasoning: false
+    }
   }
 ];
 
@@ -58319,7 +58644,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     if (apiKeyError) {
       throw new Error(apiKeyError);
     }
-    const apiKey = process.env[resolved.provider.apiKeyEnvVar];
+    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);
@@ -58336,6 +58661,14 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     } 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")) {
+        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}`);
@@ -60899,6 +61232,40 @@ __export(exports_model_selector, {
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync12, existsSync as existsSync7 } from "node:fs";
 import { join as join15, dirname as dirname3 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
+async function fetchZenModels() {
+  try {
+    const response = await fetch("https://models.dev/api.json", {
+      signal: AbortSignal.timeout(5000)
+    });
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    const opencode = data.opencode;
+    if (!opencode?.models)
+      return [];
+    return Object.entries(opencode.models).map(([id, m]) => {
+      const isFree = m.cost?.input === 0 && m.cost?.output === 0;
+      return {
+        id: `zen/${id}`,
+        name: m.name || id,
+        description: isFree ? "OpenCode Zen - FREE (no API key needed)" : `OpenCode Zen - $${((m.cost?.input || 0) + (m.cost?.output || 0)).toFixed(1)}/M`,
+        provider: "zen",
+        pricing: { input: String(m.cost?.input || 0), output: String(m.cost?.output || 0), average: isFree ? "FREE" : `$${((m.cost?.input || 0) + (m.cost?.output || 0)).toFixed(1)}/M` },
+        context: m.limit?.context ? `${Math.round(m.limit.context / 1000)}K` : "128K",
+        contextLength: m.limit?.context || 128000,
+        supportsTools: m.tool_call || false,
+        supportsReasoning: m.reasoning || false,
+        isFree
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+async function fetchZenFreeModels() {
+  const allZen = await fetchZenModels();
+  return allZen.filter((m) => m.isFree);
+}
 function loadRecommendedModels2() {
   if (existsSync7(RECOMMENDED_MODELS_JSON_PATH)) {
     try {
@@ -60977,13 +61344,19 @@ function toModelInfo(model) {
   };
 }
 async function getFreeModels() {
-  const allModels = await fetchAllModels();
+  const [allModels, zenModels] = await Promise.all([
+    fetchAllModels(),
+    fetchZenFreeModels()
+  ]);
   const freeModels = allModels.filter((model) => {
     const promptPrice = parseFloat(model.pricing?.prompt || "0");
     const completionPrice = parseFloat(model.pricing?.completion || "0");
     const isFree = promptPrice === 0 && completionPrice === 0;
     if (!isFree)
       return false;
+    const supportsTools = (model.supported_parameters || []).includes("tools");
+    if (!supportsTools)
+      return false;
     const provider = model.id.split("/")[0].toLowerCase();
     return TRUSTED_FREE_PROVIDERS.includes(provider);
   });
@@ -61000,7 +61373,8 @@ async function getFreeModels() {
     seenBase.add(baseId);
     return true;
   });
-  return dedupedModels.slice(0, 20).map(toModelInfo);
+  const openRouterFree = dedupedModels.slice(0, 15).map(toModelInfo);
+  return [...zenModels, ...openRouterFree];
 }
 async function getAllModelsForSearch() {
   const allModels = await fetchAllModels();
@@ -61191,7 +61565,8 @@ var init_model_selector = __esm(() => {
     "microsoft",
     "mistralai",
     "nvidia",
-    "cohere"
+    "cohere",
+    "zen"
   ];
 });
 
@@ -61812,8 +62187,15 @@ async function parseArgs(args) {
       console.log("[claudish] Ensure you are logged in to Claude Code (claude auth login)");
     }
   } else {
-    const usingLocalModel = isLocalModel(config3.model);
-    if (!usingLocalModel) {
+    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) {
@@ -62003,7 +62385,10 @@ Found ${results.length} matching models:
 }
 async function printAllModels(jsonOutput, forceUpdate) {
   let models = [];
-  const ollamaModels = await fetchOllamaModels();
+  const [ollamaModels, zenModels] = await Promise.all([
+    fetchOllamaModels(),
+    fetchZenModels2()
+  ]);
   if (!forceUpdate && existsSync9(ALL_MODELS_JSON_PATH2)) {
     try {
       const cacheData = JSON.parse(readFileSync7(ALL_MODELS_JSON_PATH2, "utf-8"));
@@ -62037,17 +62422,19 @@ async function printAllModels(jsonOutput, forceUpdate) {
     }
   }
   if (jsonOutput) {
-    const allModels = [...ollamaModels, ...models];
+    const allModels = [...ollamaModels, ...zenModels, ...models];
     console.log(JSON.stringify({
       count: allModels.length,
       localCount: ollamaModels.length,
+      zenCount: zenModels.length,
       lastUpdated: new Date().toISOString().split("T")[0],
       models: allModels.map((m) => ({
         id: m.id,
         name: m.name,
         context: m.context_length || m.top_provider?.context_length,
         pricing: m.pricing,
-        isLocal: m.isLocal || false
+        isLocal: m.isLocal || false,
+        isZen: m.isZen || false
       }))
     }, null, 2));
     return;
@@ -62089,6 +62476,35 @@ async function printAllModels(jsonOutput, forceUpdate) {
     console.log("   Start Ollama: ollama serve");
     console.log("   Pull a model: ollama pull llama3.2");
   }
+  if (zenModels.length > 0) {
+    const freeCount = zenModels.filter((m) => m.isFree).length;
+    console.log(`
+\uD83D\uDD2E OPENCODE ZEN (${zenModels.length} models, ${freeCount} FREE - no API key needed):
+`);
+    console.log("    Model                          Context    Pricing      Tools");
+    console.log("  " + "─".repeat(68));
+    const sortedModels = [...zenModels].sort((a, b) => {
+      if (a.isFree && !b.isFree)
+        return -1;
+      if (!a.isFree && b.isFree)
+        return 1;
+      return (b.context_length || 0) - (a.context_length || 0);
+    });
+    for (const model of sortedModels) {
+      const modelId = model.id.length > 30 ? model.id.substring(0, 27) + "..." : model.id;
+      const modelIdPadded = modelId.padEnd(32);
+      const contextLen = model.context_length || 0;
+      const context = contextLen > 0 ? `${Math.round(contextLen / 1000)}K` : "N/A";
+      const contextPadded = context.padEnd(10);
+      const pricing = model.isFree ? `${GREEN2}FREE${RESET2}` : `$${(parseFloat(model.pricing?.prompt || "0") + parseFloat(model.pricing?.completion || "0")).toFixed(1)}/M`;
+      const pricingPadded = model.isFree ? "FREE        " : pricing.padEnd(12);
+      const tools = model.supportsTools ? `${GREEN2}✓${RESET2}` : `${RED}✗${RESET2}`;
+      console.log(`    ${modelIdPadded} ${contextPadded} ${pricingPadded} ${tools}`);
+    }
+    console.log("");
+    console.log(`  ${DIM2}FREE models work without API key!${RESET2}`);
+    console.log("  Use: claudish --model zen/<model-id>");
+  }
   const byProvider = new Map;
   for (const model of models) {
     const provider = model.id.split("/")[0];
@@ -62290,6 +62706,7 @@ MODEL ROUTING (prefix-based):
   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"
   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"
   lmstudio/        LM Studio (local)      claudish --model lmstudio/qwen "task"
   vllm/            vLLM (local)           claudish --model vllm/model "task"
@@ -62314,7 +62731,7 @@ OPTIONS:
   --cost-tracker           Enable cost tracking for API usage (NB!)
   --audit-costs            Show cost analysis report
   --reset-costs            Reset accumulated cost statistics
-  --models                 List ALL OpenRouter models grouped by provider
+  --models                 List ALL models (OpenRouter + OpenCode Zen + Ollama)
   --models <query>         Fuzzy search all models by name, ID, or description
   --top-models             List recommended/top programming models (curated)
   --json                   Output in JSON format (use with --models or --top-models)
@@ -62379,6 +62796,7 @@ ENVIRONMENT VARIABLES:
   ZHIPU_API_KEY                   GLM/Zhipu API key (for glm/, zhipu/ prefix)
   GLM_API_KEY                     Alias for ZHIPU_API_KEY
   OLLAMA_API_KEY                  OllamaCloud API key (for oc/ prefix)
+  OPENCODE_API_KEY                OpenCode Zen API key (optional - free models work without it)
   ANTHROPIC_API_KEY               Placeholder (prevents Claude Code dialog)
   ANTHROPIC_AUTH_TOKEN            Placeholder (prevents Claude Code login screen)
 
@@ -62391,6 +62809,7 @@ ENVIRONMENT VARIABLES:
   ZHIPU_BASE_URL                  Custom GLM/Zhipu endpoint
   GLM_BASE_URL                    Alias for ZHIPU_BASE_URL
   OLLAMACLOUD_BASE_URL            Custom OllamaCloud endpoint (default: https://ollama.com)
+  OPENCODE_BASE_URL               Custom OpenCode Zen endpoint (default: https://opencode.ai/zen)
 
   Local providers:
   OLLAMA_BASE_URL                 Ollama server (default: http://localhost:11434)
@@ -62451,6 +62870,11 @@ EXAMPLES:
   claudish --model glm/glm-4.7 "code generation"
   claudish --model zhipu/glm-4-plus "complex task"
 
+  # OpenCode Zen (free models)
+  claudish --model zen/grok-code "implement feature"
+  claudish --model zen/glm-4.7-free "code review"
+  claudish --model zen/minimax-m2.1-free "complex task"
+
   # Local models (free, private)
   claudish --model ollama/llama3.2 "code review"
   claudish --model lmstudio/qwen2.5-coder "refactor"
@@ -62503,10 +62927,11 @@ LOCAL MODELS (Ollama, LM Studio, vLLM):
   OLLAMA_HOST=http://192.168.1.50:11434 claudish --model ollama/llama3.2 "task"
 
 AVAILABLE MODELS:
-  List all models:     claudish --models
+  List all models:     claudish --models  (includes OpenRouter, OpenCode Zen, Ollama)
   Search models:       claudish --models <query>
   Top recommended:     claudish --top-models
-  JSON output:         claudish --models --json  |  claudish --top-models --json
+  Free models only:    claudish --free  (interactive selector with free models)
+  JSON output:         claudish --models --json
   Force cache update:  claudish --models --force-update
   (Cache auto-updates every 2 days)
 
@@ -62684,7 +63109,37 @@ function printAvailableModelsJSON() {
     console.log(JSON.stringify(output, null, 2));
   }
 }
-var __filename6, __dirname6, VERSION = "3.7.8", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, ALL_MODELS_JSON_PATH2;
+async function fetchZenModels2() {
+  try {
+    const response = await fetch("https://models.dev/api.json", {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    const opencode = data.opencode;
+    if (!opencode?.models)
+      return [];
+    return Object.entries(opencode.models).map(([id, m]) => {
+      const isFree = m.cost?.input === 0 && m.cost?.output === 0;
+      return {
+        id: `zen/${id}`,
+        name: m.name || id,
+        context_length: m.limit?.context || 128000,
+        max_output: m.limit?.output || 32000,
+        pricing: isFree ? { prompt: "0", completion: "0" } : { prompt: String(m.cost?.input || 0), completion: String(m.cost?.output || 0) },
+        isZen: true,
+        isFree,
+        supportsTools: m.tool_call || false,
+        supportsReasoning: m.reasoning || false
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+var __filename6, __dirname6, VERSION = "3.8.0", CACHE_MAX_AGE_DAYS3 = 2, MODELS_JSON_PATH, ALL_MODELS_JSON_PATH2;
 var init_cli = __esm(() => {
   init_dist3();
   init_model_loader2();

package/package.json

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