claudish 3.0.5 → 3.1.0

package/dist/index.js

@@ -31121,9 +31121,11 @@ Tokens: ${result.usage.input} input, ${result.usage.output} output`;
 ## Quick Picks
 `;
     output += "- **Fast & cheap**: `x-ai/grok-code-fast-1` ($0.85/1M)\n";
-    output += "- **Code specialist**: `openai/gpt-5.1-codex` ($5.63/1M)\n";
+    output += "- **Most advanced**: `openai/gpt-5.2` ($5.00/1M)\n";
     output += "- **Large context**: `google/gemini-3-pro-preview` (1M tokens)\n";
-    output += "- **Budget**: `minimax/minimax-m2` ($0.60/1M)\n";
+    output += "- **Reasoning**: `moonshotai/kimi-k2-thinking` ($2.50/1M)\n";
+    output += "- **Budget**: `minimax/minimax-m2.1` ($0.60/1M)\n";
+    output += "- **Code specialist**: `deepseek/deepseek-v3.2` ($1.00/1M)\n";
     return { content: [{ type: "text", text: output }] };
   });
   server.tool("search_models", "Search all OpenRouter models by name, provider, or capability", {
@@ -34237,7 +34239,7 @@ __export(exports_config, {
   DEFAULT_PORT_RANGE: () => DEFAULT_PORT_RANGE,
   DEFAULT_MODEL: () => DEFAULT_MODEL
 });
-var DEFAULT_MODEL = "x-ai/grok-code-fast-1", DEFAULT_PORT_RANGE, MODEL_INFO, ENV, OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions", OPENROUTER_HEADERS;
+var DEFAULT_MODEL = "openai/gpt-5.2", DEFAULT_PORT_RANGE, MODEL_INFO, ENV, OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions", OPENROUTER_HEADERS;
 var init_config = __esm(() => {
   DEFAULT_PORT_RANGE = { start: 3000, end: 9000 };
   MODEL_INFO = {
@@ -34247,41 +34249,47 @@ var init_config = __esm(() => {
       priority: 1,
       provider: "xAI"
     },
-    "minimax/minimax-m2": {
-      name: "Compact high-efficiency",
-      description: "Compact high-efficiency",
+    "minimax/minimax-m2.1": {
+      name: "Compact high-efficiency v2.1",
+      description: "Compact high-efficiency v2.1",
       priority: 2,
       provider: "MiniMax"
     },
-    "google/gemini-2.5-flash": {
-      name: "Advanced reasoning + vision",
-      description: "Advanced reasoning + vision",
-      priority: 6,
-      provider: "Google"
+    "z-ai/glm-4.7": {
+      name: "GLM 4.7 balanced model",
+      description: "GLM 4.7 balanced model",
+      priority: 3,
+      provider: "Z.AI"
     },
-    "openai/gpt-5": {
-      name: "Most advanced reasoning",
-      description: "Most advanced reasoning",
+    "google/gemini-3-pro-preview": {
+      name: "Gemini 3 Pro preview",
+      description: "Gemini 3 Pro preview (1M context)",
       priority: 4,
-      provider: "OpenAI"
+      provider: "Google"
     },
-    "openai/gpt-5.1-codex": {
-      name: "Specialized for software engineering",
-      description: "Specialized for software engineering",
+    "openai/gpt-5.2": {
+      name: "GPT-5.2 most advanced",
+      description: "GPT-5.2 most advanced reasoning",
       priority: 5,
       provider: "OpenAI"
     },
-    "qwen/qwen3-vl-235b-a22b-instruct": {
-      name: "Multimodal with OCR",
-      description: "Multimodal with OCR",
+    "moonshotai/kimi-k2-thinking": {
+      name: "Kimi K2 with reasoning",
+      description: "Kimi K2 with extended thinking",
+      priority: 6,
+      provider: "MoonShot"
+    },
+    "deepseek/deepseek-v3.2": {
+      name: "DeepSeek V3.2 coding",
+      description: "DeepSeek V3.2 coding specialist",
       priority: 7,
-      provider: "Alibaba"
+      provider: "DeepSeek"
     },
-    "openrouter/polaris-alpha": {
-      name: "FREE experimental (logs usage)",
-      description: "FREE experimental (logs usage)",
+    "qwen/qwen3-vl-235b-a22b-thinking": {
+      name: "Qwen3 VL thinking",
+      description: "Qwen3 VL 235B with reasoning",
       priority: 8,
-      provider: "OpenRouter"
+      provider: "Alibaba"
     },
     custom: {
       name: "Custom Model",
@@ -34309,6 +34317,10 @@ var init_config = __esm(() => {
     OLLAMA_HOST: "OLLAMA_HOST",
     LMSTUDIO_BASE_URL: "LMSTUDIO_BASE_URL",
     VLLM_BASE_URL: "VLLM_BASE_URL",
+    GEMINI_API_KEY: "GEMINI_API_KEY",
+    GEMINI_BASE_URL: "GEMINI_BASE_URL",
+    OPENAI_API_KEY: "OPENAI_API_KEY",
+    OPENAI_BASE_URL: "OPENAI_BASE_URL",
     CLAUDISH_SUMMARIZE_TOOLS: "CLAUDISH_SUMMARIZE_TOOLS"
   };
   OPENROUTER_HEADERS = {
@@ -34402,7 +34414,7 @@ function createTempSettingsFile(modelDisplay, port) {
     const DIM2 = "\\033[2m";
     const RESET2 = "\\033[0m";
     const BOLD2 = "\\033[1m";
-    statusCommand = `JSON=$(cat) && DIR=$(basename "$(pwd)") && [ \${#DIR} -gt 15 ] && DIR="\${DIR:0:12}..." || true && CTX=100 && COST="0" && if [ -f "${tokenFilePath}" ]; then TOKENS=$(cat "${tokenFilePath}" 2>/dev/null) && REAL_COST=$(echo "$TOKENS" | grep -o '"total_cost":[0-9.]*' | cut -d: -f2) && REAL_CTX=$(echo "$TOKENS" | grep -o '"context_left_percent":[0-9]*' | grep -o '[0-9]*') && if [ ! -z "$REAL_COST" ]; then COST="$REAL_COST"; else COST=$(echo "$JSON" | grep -o '"total_cost_usd":[0-9.]*' | cut -d: -f2); fi && if [ ! -z "$REAL_CTX" ]; then CTX="$REAL_CTX"; fi; else COST=$(echo "$JSON" | grep -o '"total_cost_usd":[0-9.]*' | cut -d: -f2); fi && [ -z "$COST" ] && COST="0" || true && if [ "$CLAUDISH_IS_LOCAL" = "true" ]; then COST_DISPLAY="LOCAL"; else COST_DISPLAY=$(printf "\\$%.3f" "$COST"); fi && printf "${CYAN2}${BOLD2}%s${RESET2} ${DIM2}•${RESET2} ${YELLOW2}%s${RESET2} ${DIM2}•${RESET2} ${GREEN2}%s${RESET2} ${DIM2}•${RESET2} ${MAGENTA}%s%%${RESET2}\\n" "$DIR" "$CLAUDISH_ACTIVE_MODEL_NAME" "$COST_DISPLAY" "$CTX"`;
+    statusCommand = `JSON=$(cat) && DIR=$(basename "$(pwd)") && [ \${#DIR} -gt 15 ] && DIR="\${DIR:0:12}..." || true && CTX=100 && COST="0" && if [ -f "${tokenFilePath}" ]; then TOKENS=$(cat "${tokenFilePath}" 2>/dev/null) && REAL_CTX=$(echo "$TOKENS" | grep -o '"context_left_percent":[0-9]*' | grep -o '[0-9]*') && if [ ! -z "$REAL_CTX" ]; then CTX="$REAL_CTX"; fi; fi && COST=$(echo "$JSON" | grep -o '"total_cost_usd":[0-9.]*' | cut -d: -f2) && [ -z "$COST" ] && COST="0" || true && if [ "$CLAUDISH_IS_LOCAL" = "true" ]; then COST_DISPLAY="LOCAL"; else COST_DISPLAY=$(printf "\\$%.3f" "$COST"); fi && printf "${CYAN2}${BOLD2}%s${RESET2} ${DIM2}•${RESET2} ${YELLOW2}%s${RESET2} ${DIM2}•${RESET2} ${GREEN2}%s${RESET2} ${DIM2}•${RESET2} ${MAGENTA}%s%%${RESET2}\\n" "$DIR" "$CLAUDISH_ACTIVE_MODEL_NAME" "$COST_DISPLAY" "$CTX"`;
   }
   const settings = {
     statusLine: {
@@ -34540,12 +34552,13 @@ var OPENROUTER_MODELS;
 var init_types4 = __esm(() => {
   OPENROUTER_MODELS = [
     "x-ai/grok-code-fast-1",
-    "minimax/minimax-m2",
-    "google/gemini-2.5-flash",
-    "openai/gpt-5",
-    "openai/gpt-5.1-codex",
-    "qwen/qwen3-vl-235b-a22b-instruct",
-    "openrouter/polaris-alpha",
+    "minimax/minimax-m2.1",
+    "z-ai/glm-4.7",
+    "google/gemini-3-pro-preview",
+    "openai/gpt-5.2",
+    "moonshotai/kimi-k2-thinking",
+    "deepseek/deepseek-v3.2",
+    "qwen/qwen3-vl-235b-a22b-thinking",
     "custom"
   ];
 });
@@ -35236,18 +35249,17 @@ async function updateModelsFromOpenRouter() {
   console.error("\uD83D\uDD04 Updating model recommendations from OpenRouter...");
   try {
     const topWeeklyProgrammingModels = [
-      "google/gemini-3-pro-preview",
-      "openai/gpt-5.1-codex",
       "x-ai/grok-code-fast-1",
+      "minimax/minimax-m2.1",
+      "z-ai/glm-4.7",
+      "google/gemini-3-pro-preview",
+      "openai/gpt-5.2",
+      "moonshotai/kimi-k2-thinking",
+      "deepseek/deepseek-v3.2",
+      "qwen/qwen3-vl-235b-a22b-thinking",
       "anthropic/claude-sonnet-4.5",
-      "google/gemini-2.5-flash",
-      "minimax/minimax-m2",
       "anthropic/claude-sonnet-4",
-      "z-ai/glm-4.6",
-      "anthropic/claude-haiku-4.5",
-      "openai/gpt-5",
-      "qwen/qwen3-vl-235b-a22b-instruct",
-      "openrouter/polaris-alpha"
+      "anthropic/claude-haiku-4.5"
     ];
     const apiResponse = await fetch("https://openrouter.ai/api/v1/models");
     if (!apiResponse.ok) {
@@ -61057,6 +61069,754 @@ var init_local_provider_handler = __esm(() => {
   });
 });
 
+// src/handlers/shared/remote-provider-types.ts
+function getModelPricing(provider, modelName) {
+  let pricingTable;
+  switch (provider) {
+    case "gemini":
+    case "google":
+      pricingTable = GEMINI_PRICING;
+      break;
+    case "openai":
+    case "oai":
+      pricingTable = OPENAI_PRICING;
+      break;
+    default:
+      return { inputCostPer1M: 1, outputCostPer1M: 4 };
+  }
+  if (pricingTable[modelName]) {
+    return pricingTable[modelName];
+  }
+  for (const [key, pricing] of Object.entries(pricingTable)) {
+    if (key !== "default" && modelName.startsWith(key)) {
+      return pricing;
+    }
+  }
+  return pricingTable["default"];
+}
+var GEMINI_PRICING, OPENAI_PRICING;
+var init_remote_provider_types = __esm(() => {
+  GEMINI_PRICING = {
+    "gemini-2.5-flash": { inputCostPer1M: 0.15, outputCostPer1M: 0.6 },
+    "gemini-2.5-flash-preview-05-20": { inputCostPer1M: 0.15, outputCostPer1M: 0.6 },
+    "gemini-2.5-pro": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gemini-2.5-pro-preview-05-06": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gemini-3-pro-preview": { inputCostPer1M: 2.5, outputCostPer1M: 10 },
+    "gemini-3.0-flash": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
+    "gemini-2.0-flash": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
+    "gemini-2.0-flash-thinking": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
+    default: { inputCostPer1M: 0.5, outputCostPer1M: 2 }
+  };
+  OPENAI_PRICING = {
+    "gpt-5": { inputCostPer1M: 2, outputCostPer1M: 8 },
+    "gpt-5.2": { inputCostPer1M: 2.5, outputCostPer1M: 10 },
+    "gpt-5-turbo": { inputCostPer1M: 1.5, outputCostPer1M: 6 },
+    "gpt-5.1-codex": { inputCostPer1M: 3, outputCostPer1M: 12 },
+    "gpt-4o": { inputCostPer1M: 2.5, outputCostPer1M: 10 },
+    "gpt-4o-mini": { inputCostPer1M: 0.15, outputCostPer1M: 0.6 },
+    "gpt-4o-audio": { inputCostPer1M: 2.5, outputCostPer1M: 10 },
+    o1: { inputCostPer1M: 15, outputCostPer1M: 60 },
+    "o1-mini": { inputCostPer1M: 3, outputCostPer1M: 12 },
+    "o1-preview": { inputCostPer1M: 15, outputCostPer1M: 60 },
+    o3: { inputCostPer1M: 15, outputCostPer1M: 60 },
+    "o3-mini": { inputCostPer1M: 3, outputCostPer1M: 12 },
+    "gpt-4-turbo": { inputCostPer1M: 10, outputCostPer1M: 30 },
+    "gpt-4-turbo-preview": { inputCostPer1M: 10, outputCostPer1M: 30 },
+    "gpt-4": { inputCostPer1M: 30, outputCostPer1M: 60 },
+    "gpt-3.5-turbo": { inputCostPer1M: 0.5, outputCostPer1M: 1.5 },
+    default: { inputCostPer1M: 2, outputCostPer1M: 8 }
+  };
+});
+
+// src/handlers/gemini-handler.ts
+import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync7 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join10 } from "node:path";
+
+class GeminiHandler {
+  provider;
+  modelName;
+  apiKey;
+  port;
+  adapterManager;
+  middlewareManager;
+  sessionTotalCost = 0;
+  sessionInputTokens = 0;
+  sessionOutputTokens = 0;
+  contextWindow = 1e6;
+  toolCallMap = new Map;
+  constructor(provider, modelName, apiKey, port) {
+    this.provider = provider;
+    this.modelName = modelName;
+    this.apiKey = apiKey;
+    this.port = port;
+    this.adapterManager = new AdapterManager(`gemini/${modelName}`);
+    this.middlewareManager = new MiddlewareManager;
+    this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
+    this.middlewareManager.initialize().catch((err) => log(`[GeminiHandler:${modelName}] Middleware init error: ${err}`));
+  }
+  getPricing() {
+    return getModelPricing("gemini", this.modelName);
+  }
+  getApiEndpoint() {
+    const baseUrl = this.provider.baseUrl;
+    const apiPath = this.provider.apiPath.replace("{model}", this.modelName);
+    return `${baseUrl}${apiPath}`;
+  }
+  writeTokenFile(input, output) {
+    try {
+      const total = input + output;
+      const leftPct = this.contextWindow > 0 ? Math.max(0, Math.min(100, Math.round((this.contextWindow - total) / this.contextWindow * 100))) : 100;
+      const data = {
+        input_tokens: input,
+        output_tokens: output,
+        total_tokens: total,
+        total_cost: this.sessionTotalCost,
+        context_window: this.contextWindow,
+        context_left_percent: leftPct,
+        updated_at: Date.now()
+      };
+      const claudishDir = join10(homedir4(), ".claudish");
+      mkdirSync7(claudishDir, { recursive: true });
+      writeFileSync10(join10(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+    } catch (e) {
+      log(`[GeminiHandler] Error writing token file: ${e}`);
+    }
+  }
+  updateTokenTracking(inputTokens, outputTokens) {
+    this.sessionInputTokens = inputTokens;
+    this.sessionOutputTokens += outputTokens;
+    const pricing = this.getPricing();
+    const cost = inputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M;
+    this.sessionTotalCost += cost;
+    this.writeTokenFile(inputTokens, this.sessionOutputTokens);
+  }
+  convertToGeminiMessages(claudeRequest) {
+    const messages = [];
+    if (claudeRequest.messages) {
+      for (const msg of claudeRequest.messages) {
+        if (msg.role === "user") {
+          const parts = this.convertUserMessageParts(msg);
+          if (parts.length > 0) {
+            messages.push({ role: "user", parts });
+          }
+        } else if (msg.role === "assistant") {
+          const parts = this.convertAssistantMessageParts(msg);
+          if (parts.length > 0) {
+            messages.push({ role: "model", parts });
+          }
+        }
+      }
+    }
+    return messages;
+  }
+  convertUserMessageParts(msg) {
+    const parts = [];
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          parts.push({ text: block.text });
+        } else if (block.type === "image") {
+          parts.push({
+            inlineData: {
+              mimeType: block.source.media_type,
+              data: block.source.data
+            }
+          });
+        } else if (block.type === "tool_result") {
+          const functionName = this.toolCallMap.get(block.tool_use_id);
+          if (!functionName) {
+            log(`[GeminiHandler:${this.modelName}] Warning: No function name found for tool_use_id ${block.tool_use_id}`);
+            continue;
+          }
+          parts.push({
+            functionResponse: {
+              name: functionName,
+              response: {
+                content: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+              }
+            }
+          });
+        }
+      }
+    } else if (typeof msg.content === "string") {
+      parts.push({ text: msg.content });
+    }
+    return parts;
+  }
+  convertAssistantMessageParts(msg) {
+    const parts = [];
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          parts.push({ text: block.text });
+        } else if (block.type === "tool_use") {
+          this.toolCallMap.set(block.id, block.name);
+          parts.push({
+            functionCall: {
+              name: block.name,
+              args: block.input
+            }
+          });
+        }
+      }
+    } else if (typeof msg.content === "string") {
+      parts.push({ text: msg.content });
+    }
+    return parts;
+  }
+  convertToGeminiTools(claudeRequest) {
+    if (!claudeRequest.tools || claudeRequest.tools.length === 0) {
+      return;
+    }
+    const functionDeclarations = claudeRequest.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: this.convertJsonSchemaToGemini(tool.input_schema)
+    }));
+    return [{ functionDeclarations }];
+  }
+  convertJsonSchemaToGemini(schema) {
+    if (!schema)
+      return {};
+    const geminiSchema = {
+      type: schema.type || "object"
+    };
+    if (schema.properties) {
+      geminiSchema.properties = {};
+      for (const [key, prop] of Object.entries(schema.properties)) {
+        geminiSchema.properties[key] = this.convertPropertyToGemini(prop);
+      }
+    }
+    if (schema.required) {
+      geminiSchema.required = schema.required;
+    }
+    return geminiSchema;
+  }
+  convertPropertyToGemini(prop) {
+    const result = {
+      type: prop.type || "string"
+    };
+    if (prop.description)
+      result.description = prop.description;
+    if (prop.enum)
+      result.enum = prop.enum;
+    if (prop.items)
+      result.items = this.convertPropertyToGemini(prop.items);
+    if (prop.properties) {
+      result.properties = {};
+      for (const [k, v] of Object.entries(prop.properties)) {
+        result.properties[k] = this.convertPropertyToGemini(v);
+      }
+    }
+    return result;
+  }
+  buildGeminiPayload(claudeRequest) {
+    const contents = this.convertToGeminiMessages(claudeRequest);
+    const tools = this.convertToGeminiTools(claudeRequest);
+    const payload = {
+      contents,
+      generationConfig: {
+        temperature: claudeRequest.temperature ?? 1,
+        maxOutputTokens: claudeRequest.max_tokens
+      }
+    };
+    if (claudeRequest.system) {
+      let systemContent = Array.isArray(claudeRequest.system) ? claudeRequest.system.map((i) => i.text || i).join(`
+
+`) : claudeRequest.system;
+      systemContent = filterIdentity(systemContent);
+      systemContent += `
+
+CRITICAL INSTRUCTION FOR OUTPUT FORMAT:
+1. Keep ALL internal reasoning INTERNAL. Never output your thought process as visible text.
+2. Do NOT start responses with phrases like "Wait, I'm...", "Let me think...", "Okay, so..."
+3. Only output: final responses, tool calls, and code. Nothing else.`;
+      payload.systemInstruction = { parts: [{ text: systemContent }] };
+    }
+    if (tools) {
+      payload.tools = tools;
+    }
+    if (claudeRequest.thinking) {
+      const { budget_tokens } = claudeRequest.thinking;
+      if (this.modelName.includes("gemini-3")) {
+        payload.generationConfig.thinkingConfig = {
+          thinkingLevel: budget_tokens >= 16000 ? "high" : "low"
+        };
+      } else {
+        const MAX_GEMINI_BUDGET = 24576;
+        const budget = Math.min(budget_tokens, MAX_GEMINI_BUDGET);
+        payload.generationConfig.thinkingConfig = {
+          thinkingBudget: budget
+        };
+      }
+    }
+    return payload;
+  }
+  handleStreamingResponse(c, response, _claudeRequest) {
+    let isClosed = false;
+    let ping2 = null;
+    const encoder = new TextEncoder;
+    const decoder = new TextDecoder;
+    const streamMetadata = new Map;
+    const adapter = this.adapterManager.getAdapter();
+    if (typeof adapter.reset === "function")
+      adapter.reset();
+    return c.body(new ReadableStream({
+      start: async (controller) => {
+        const send = (e, d) => {
+          if (!isClosed) {
+            controller.enqueue(encoder.encode(`event: ${e}
+data: ${JSON.stringify(d)}
+
+`));
+          }
+        };
+        const msgId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        let usage = null;
+        let finalized = false;
+        let textStarted = false;
+        let textIdx = -1;
+        let thinkingStarted = false;
+        let thinkingIdx = -1;
+        let curIdx = 0;
+        const tools = new Map;
+        let lastActivity = Date.now();
+        let accumulatedText = "";
+        send("message_start", {
+          type: "message_start",
+          message: {
+            id: msgId,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model: `gemini/${this.modelName}`,
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 100, output_tokens: 1 }
+          }
+        });
+        send("ping", { type: "ping" });
+        ping2 = setInterval(() => {
+          if (!isClosed && Date.now() - lastActivity > 1000) {
+            send("ping", { type: "ping" });
+          }
+        }, 1000);
+        const finalize = async (reason, err) => {
+          if (finalized)
+            return;
+          finalized = true;
+          if (thinkingStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
+          }
+          if (textStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: textIdx });
+          }
+          for (const t of Array.from(tools.values())) {
+            if (t.started && !t.closed) {
+              send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+              t.closed = true;
+            }
+          }
+          await this.middlewareManager.afterStreamComplete(`gemini/${this.modelName}`, streamMetadata);
+          if (usage) {
+            log(`[GeminiHandler] Usage: prompt=${usage.promptTokenCount || 0}, completion=${usage.candidatesTokenCount || 0}`);
+            this.updateTokenTracking(usage.promptTokenCount || 0, usage.candidatesTokenCount || 0);
+          }
+          if (reason === "error") {
+            log(`[GeminiHandler] Stream error: ${err}`);
+            send("error", { type: "error", error: { type: "api_error", message: err } });
+          } else {
+            const hasToolCalls = tools.size > 0;
+            send("message_delta", {
+              type: "message_delta",
+              delta: { stop_reason: hasToolCalls ? "tool_use" : "end_turn", stop_sequence: null },
+              usage: { output_tokens: usage?.candidatesTokenCount || 0 }
+            });
+            send("message_stop", { type: "message_stop" });
+          }
+          if (!isClosed) {
+            try {
+              controller.enqueue(encoder.encode(`data: [DONE]
+
+
+`));
+            } catch (e) {}
+            controller.close();
+            isClosed = true;
+            if (ping2)
+              clearInterval(ping2);
+          }
+        };
+        try {
+          const reader = response.body.getReader();
+          let buffer = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim() || !line.startsWith("data: "))
+                continue;
+              const dataStr = line.slice(6);
+              if (dataStr === "[DONE]") {
+                await finalize("done");
+                return;
+              }
+              try {
+                const chunk = JSON.parse(dataStr);
+                if (chunk.usageMetadata) {
+                  usage = chunk.usageMetadata;
+                }
+                const candidate = chunk.candidates?.[0];
+                if (candidate?.content?.parts) {
+                  for (const part of candidate.content.parts) {
+                    lastActivity = Date.now();
+                    if (part.thought || part.thoughtText) {
+                      const thinkingContent = part.thought || part.thoughtText;
+                      if (!thinkingStarted) {
+                        thinkingIdx = curIdx++;
+                        send("content_block_start", {
+                          type: "content_block_start",
+                          index: thinkingIdx,
+                          content_block: { type: "thinking", thinking: "" }
+                        });
+                        thinkingStarted = true;
+                      }
+                      send("content_block_delta", {
+                        type: "content_block_delta",
+                        index: thinkingIdx,
+                        delta: { type: "thinking_delta", thinking: thinkingContent }
+                      });
+                    }
+                    if (part.text) {
+                      if (thinkingStarted) {
+                        send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
+                        thinkingStarted = false;
+                      }
+                      const res = adapter.processTextContent(part.text, accumulatedText);
+                      accumulatedText += res.cleanedText || "";
+                      if (res.cleanedText) {
+                        if (!textStarted) {
+                          textIdx = curIdx++;
+                          send("content_block_start", {
+                            type: "content_block_start",
+                            index: textIdx,
+                            content_block: { type: "text", text: "" }
+                          });
+                          textStarted = true;
+                        }
+                        send("content_block_delta", {
+                          type: "content_block_delta",
+                          index: textIdx,
+                          delta: { type: "text_delta", text: res.cleanedText }
+                        });
+                      }
+                    }
+                    if (part.functionCall) {
+                      if (thinkingStarted) {
+                        send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
+                        thinkingStarted = false;
+                      }
+                      if (textStarted) {
+                        send("content_block_stop", { type: "content_block_stop", index: textIdx });
+                        textStarted = false;
+                      }
+                      const toolIdx = tools.size;
+                      const toolId = `tool_${Date.now()}_${toolIdx}`;
+                      const t = {
+                        id: toolId,
+                        name: part.functionCall.name,
+                        blockIndex: curIdx++,
+                        started: true,
+                        closed: false,
+                        arguments: JSON.stringify(part.functionCall.args || {})
+                      };
+                      tools.set(toolIdx, t);
+                      send("content_block_start", {
+                        type: "content_block_start",
+                        index: t.blockIndex,
+                        content_block: { type: "tool_use", id: t.id, name: t.name }
+                      });
+                      send("content_block_delta", {
+                        type: "content_block_delta",
+                        index: t.blockIndex,
+                        delta: { type: "input_json_delta", partial_json: t.arguments }
+                      });
+                      send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+                      t.closed = true;
+                    }
+                  }
+                }
+                if (candidate?.finishReason) {
+                  if (candidate.finishReason === "STOP" || candidate.finishReason === "MAX_TOKENS") {
+                    await finalize("done");
+                    return;
+                  }
+                }
+              } catch (e) {
+                log(`[GeminiHandler] Parse error: ${e}`);
+              }
+            }
+          }
+          await finalize("unexpected");
+        } catch (e) {
+          await finalize("error", String(e));
+        }
+      },
+      cancel() {
+        isClosed = true;
+        if (ping2)
+          clearInterval(ping2);
+      }
+    }), {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  async handle(c, payload) {
+    const { claudeRequest, droppedParams } = transformOpenAIToClaude(payload);
+    const systemPromptLength = typeof claudeRequest.system === "string" ? claudeRequest.system.length : 0;
+    logStructured("Gemini Request", {
+      targetModel: `gemini/${this.modelName}`,
+      originalModel: payload.model,
+      messageCount: claudeRequest.messages?.length || 0,
+      toolCount: claudeRequest.tools?.length || 0,
+      systemPromptLength,
+      maxTokens: claudeRequest.max_tokens
+    });
+    const geminiPayload = this.buildGeminiPayload(claudeRequest);
+    await this.middlewareManager.beforeRequest({
+      modelId: `gemini/${this.modelName}`,
+      messages: geminiPayload.contents,
+      tools: claudeRequest.tools || [],
+      stream: true
+    });
+    const endpoint = this.getApiEndpoint();
+    log(`[GeminiHandler] Calling API: ${endpoint}`);
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-goog-api-key": this.apiKey
+      },
+      body: JSON.stringify(geminiPayload)
+    });
+    log(`[GeminiHandler] Response status: ${response.status}`);
+    if (!response.ok) {
+      const errorText = await response.text();
+      log(`[GeminiHandler] Error: ${errorText}`);
+      return c.json({ error: errorText }, response.status);
+    }
+    if (droppedParams.length > 0) {
+      c.header("X-Dropped-Params", droppedParams.join(", "));
+    }
+    return this.handleStreamingResponse(c, response, claudeRequest);
+  }
+  async shutdown() {}
+}
+var init_gemini_handler = __esm(() => {
+  init_adapter_manager();
+  init_middleware();
+  init_transform();
+  init_logger();
+  init_openai_compat();
+  init_remote_provider_types();
+});
+
+// src/handlers/openai-handler.ts
+import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync8 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join11 } from "node:path";
+
+class OpenAIHandler {
+  provider;
+  modelName;
+  apiKey;
+  port;
+  adapterManager;
+  middlewareManager;
+  sessionTotalCost = 0;
+  sessionInputTokens = 0;
+  sessionOutputTokens = 0;
+  contextWindow = 128000;
+  constructor(provider, modelName, apiKey, port) {
+    this.provider = provider;
+    this.modelName = modelName;
+    this.apiKey = apiKey;
+    this.port = port;
+    this.adapterManager = new AdapterManager(`openai/${modelName}`);
+    this.middlewareManager = new MiddlewareManager;
+    this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
+    this.middlewareManager.initialize().catch((err) => log(`[OpenAIHandler:${modelName}] Middleware init error: ${err}`));
+    this.setContextWindow();
+  }
+  setContextWindow() {
+    const model = this.modelName.toLowerCase();
+    if (model.includes("gpt-4o") || model.includes("gpt-4-turbo")) {
+      this.contextWindow = 128000;
+    } else if (model.includes("gpt-5")) {
+      this.contextWindow = 256000;
+    } else if (model.includes("o1") || model.includes("o3")) {
+      this.contextWindow = 200000;
+    } else if (model.includes("gpt-3.5")) {
+      this.contextWindow = 16385;
+    } else {
+      this.contextWindow = 128000;
+    }
+  }
+  getPricing() {
+    return getModelPricing("openai", this.modelName);
+  }
+  getApiEndpoint() {
+    return `${this.provider.baseUrl}${this.provider.apiPath}`;
+  }
+  writeTokenFile(input, output) {
+    try {
+      const total = input + output;
+      const leftPct = this.contextWindow > 0 ? Math.max(0, Math.min(100, Math.round((this.contextWindow - total) / this.contextWindow * 100))) : 100;
+      const data = {
+        input_tokens: input,
+        output_tokens: output,
+        total_tokens: total,
+        total_cost: this.sessionTotalCost,
+        context_window: this.contextWindow,
+        context_left_percent: leftPct,
+        updated_at: Date.now()
+      };
+      const claudishDir = join11(homedir5(), ".claudish");
+      mkdirSync8(claudishDir, { recursive: true });
+      writeFileSync11(join11(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+    } catch (e) {
+      log(`[OpenAIHandler] Error writing token file: ${e}`);
+    }
+  }
+  updateTokenTracking(inputTokens, outputTokens) {
+    this.sessionInputTokens = inputTokens;
+    this.sessionOutputTokens += outputTokens;
+    const pricing = this.getPricing();
+    const cost = inputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M;
+    this.sessionTotalCost += cost;
+    this.writeTokenFile(inputTokens, this.sessionOutputTokens);
+  }
+  convertMessages(claudeRequest) {
+    return convertMessagesToOpenAI(claudeRequest, `openai/${this.modelName}`, filterIdentity);
+  }
+  convertTools(claudeRequest) {
+    return convertToolsToOpenAI(claudeRequest);
+  }
+  supportsReasoning() {
+    const model = this.modelName.toLowerCase();
+    return model.includes("o1") || model.includes("o3");
+  }
+  buildOpenAIPayload(claudeRequest, messages, tools) {
+    const payload = {
+      model: this.modelName,
+      messages,
+      temperature: claudeRequest.temperature ?? 1,
+      stream: true,
+      max_tokens: claudeRequest.max_tokens,
+      stream_options: { include_usage: true }
+    };
+    if (tools.length > 0) {
+      payload.tools = tools;
+    }
+    if (claudeRequest.tool_choice) {
+      const { type, name } = claudeRequest.tool_choice;
+      if (type === "tool" && name) {
+        payload.tool_choice = { type: "function", function: { name } };
+      } else if (type === "auto" || type === "none") {
+        payload.tool_choice = type;
+      }
+    }
+    if (claudeRequest.thinking && this.supportsReasoning()) {
+      const { budget_tokens } = claudeRequest.thinking;
+      let effort = "medium";
+      if (budget_tokens < 4000)
+        effort = "minimal";
+      else if (budget_tokens < 16000)
+        effort = "low";
+      else if (budget_tokens >= 32000)
+        effort = "high";
+      payload.reasoning_effort = effort;
+      log(`[OpenAIHandler] Mapped thinking.budget_tokens ${budget_tokens} -> reasoning_effort: ${effort}`);
+    }
+    return payload;
+  }
+  async handle(c, payload) {
+    const { claudeRequest, droppedParams } = transformOpenAIToClaude(payload);
+    const messages = this.convertMessages(claudeRequest);
+    const tools = this.convertTools(claudeRequest);
+    const systemPromptLength = typeof claudeRequest.system === "string" ? claudeRequest.system.length : 0;
+    logStructured("OpenAI Request", {
+      targetModel: `openai/${this.modelName}`,
+      originalModel: payload.model,
+      messageCount: messages.length,
+      toolCount: tools.length,
+      systemPromptLength,
+      maxTokens: claudeRequest.max_tokens
+    });
+    if (getLogLevel() === "debug") {
+      const lastUserMsg = messages.filter((m) => m.role === "user").pop();
+      if (lastUserMsg) {
+        const content = typeof lastUserMsg.content === "string" ? lastUserMsg.content : JSON.stringify(lastUserMsg.content);
+        log(`[OpenAI] Last user message: ${truncateContent(content, 500)}`);
+      }
+      if (tools.length > 0) {
+        const toolNames = tools.map((t) => t.function?.name || t.name).join(", ");
+        log(`[OpenAI] Tools: ${toolNames}`);
+      }
+    }
+    const openAIPayload = this.buildOpenAIPayload(claudeRequest, messages, tools);
+    const adapter = this.adapterManager.getAdapter();
+    if (typeof adapter.reset === "function")
+      adapter.reset();
+    adapter.prepareRequest(openAIPayload, claudeRequest);
+    await this.middlewareManager.beforeRequest({
+      modelId: `openai/${this.modelName}`,
+      messages,
+      tools,
+      stream: true
+    });
+    const endpoint = this.getApiEndpoint();
+    log(`[OpenAIHandler] Calling API: ${endpoint}`);
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(openAIPayload)
+    });
+    log(`[OpenAIHandler] Response status: ${response.status}`);
+    if (!response.ok) {
+      const errorText = await response.text();
+      log(`[OpenAIHandler] Error: ${errorText}`);
+      return c.json({ error: errorText }, response.status);
+    }
+    if (droppedParams.length > 0) {
+      c.header("X-Dropped-Params", droppedParams.join(", "));
+    }
+    return createStreamingResponseHandler(c, response, adapter, `openai/${this.modelName}`, this.middlewareManager, (input, output) => this.updateTokenTracking(input, output), claudeRequest.tools);
+  }
+  async shutdown() {}
+}
+var init_openai_handler = __esm(() => {
+  init_adapter_manager();
+  init_middleware();
+  init_transform();
+  init_logger();
+  init_openai_compat();
+  init_remote_provider_types();
+});
+
 // src/providers/provider-registry.ts
 function resolveProvider(modelId) {
   const providers = getProviders();
@@ -61168,6 +61928,86 @@ var getProviders = () => [
   }
 ];
 
+// src/providers/remote-provider-registry.ts
+function resolveRemoteProvider(modelId) {
+  const providers = getRemoteProviders();
+  for (const provider of providers) {
+    for (const prefix of provider.prefixes) {
+      if (modelId.startsWith(prefix)) {
+        return {
+          provider,
+          modelName: modelId.slice(prefix.length)
+        };
+      }
+    }
+  }
+  return null;
+}
+function validateRemoteProviderApiKey(provider) {
+  const apiKey = process.env[provider.apiKeyEnvVar];
+  if (!apiKey) {
+    const examples = {
+      GEMINI_API_KEY: "export GEMINI_API_KEY='your-key' (get from https://aistudio.google.com/app/apikey)",
+      OPENAI_API_KEY: "export OPENAI_API_KEY='sk-...' (get from https://platform.openai.com/api-keys)",
+      OPENROUTER_API_KEY: "export OPENROUTER_API_KEY='sk-or-...' (get from https://openrouter.ai/keys)"
+    };
+    const example = examples[provider.apiKeyEnvVar] || `export ${provider.apiKeyEnvVar}='your-key'`;
+    return `Missing ${provider.apiKeyEnvVar} environment variable.
+
+Set it with:
+  ${example}`;
+  }
+  return null;
+}
+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/", "google/"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      supportsReasoning: true
+    }
+  },
+  {
+    name: "openai",
+    baseUrl: process.env.OPENAI_BASE_URL || "https://api.openai.com",
+    apiPath: "/v1/chat/completions",
+    apiKeyEnvVar: "OPENAI_API_KEY",
+    prefixes: ["oai/", "openai/"],
+    capabilities: {
+      supportsTools: true,
+      supportsVision: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      supportsReasoning: true
+    }
+  },
+  {
+    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"
+    },
+    capabilities: {
+      supportsTools: true,
+      supportsVision: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      supportsReasoning: true
+    }
+  }
+];
+
 // src/proxy-server.ts
 var exports_proxy_server = {};
 __export(exports_proxy_server, {
@@ -61177,6 +62017,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
   const nativeHandler = new NativeHandler(anthropicApiKey);
   const openRouterHandlers = new Map;
   const localProviderHandlers = new Map;
+  const remoteProviderHandlers = new Map;
   const getOpenRouterHandler = (targetModel) => {
     if (!openRouterHandlers.has(targetModel)) {
       openRouterHandlers.set(targetModel, new OpenRouterHandler(targetModel, openrouterApiKey, port));
@@ -61207,6 +62048,35 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     }
     return null;
   };
+  const getRemoteProviderHandler = (targetModel) => {
+    if (remoteProviderHandlers.has(targetModel)) {
+      return remoteProviderHandlers.get(targetModel);
+    }
+    const resolved = resolveRemoteProvider(targetModel);
+    if (!resolved) {
+      return null;
+    }
+    if (resolved.provider.name === "openrouter") {
+      return null;
+    }
+    const apiKeyError = validateRemoteProviderApiKey(resolved.provider);
+    if (apiKeyError) {
+      throw new Error(apiKeyError);
+    }
+    const apiKey = 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 === "openai") {
+      handler = new OpenAIHandler(resolved.provider, resolved.modelName, apiKey, port);
+      log(`[Proxy] Created OpenAI handler: ${resolved.modelName}`);
+    } else {
+      return null;
+    }
+    remoteProviderHandlers.set(targetModel, handler);
+    return handler;
+  };
   const getHandlerForRequest = (requestedModel) => {
     if (monitorMode)
       return nativeHandler;
@@ -61220,6 +62090,9 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
       else if (req.includes("haiku") && modelMap.haiku)
         target = modelMap.haiku;
     }
+    const remoteHandler = getRemoteProviderHandler(target);
+    if (remoteHandler)
+      return remoteHandler;
     const localHandler = getLocalProviderHandler(target);
     if (localHandler)
       return localHandler;
@@ -61284,6 +62157,8 @@ var init_proxy_server = __esm(() => {
   init_native_handler();
   init_openrouter_handler();
   init_local_provider_handler();
+  init_gemini_handler();
+  init_openai_handler();
 });
 
 // src/update-checker.ts
@@ -61293,24 +62168,24 @@ __export(exports_update_checker, {
 });
 import { execSync } from "node:child_process";
 import { createInterface as createInterface2 } from "node:readline";
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync10, mkdirSync as mkdirSync7, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join10 } from "node:path";
-import { tmpdir as tmpdir2, homedir as homedir4, platform } from "node:os";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync12, mkdirSync as mkdirSync9, unlinkSync as unlinkSync2 } from "node:fs";
+import { join as join12 } from "node:path";
+import { tmpdir as tmpdir2, homedir as homedir6, platform } from "node:os";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows2) {
-    const localAppData = process.env.LOCALAPPDATA || join10(homedir4(), "AppData", "Local");
-    cacheDir = join10(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join12(homedir6(), "AppData", "Local");
+    cacheDir = join12(localAppData, "claudish");
   } else {
-    cacheDir = join10(homedir4(), ".cache", "claudish");
+    cacheDir = join12(homedir6(), ".cache", "claudish");
   }
   try {
     if (!existsSync7(cacheDir)) {
-      mkdirSync7(cacheDir, { recursive: true });
+      mkdirSync9(cacheDir, { recursive: true });
     }
-    return join10(cacheDir, "update-check.json");
+    return join12(cacheDir, "update-check.json");
   } catch {
-    return join10(tmpdir2(), "claudish-update-check.json");
+    return join12(tmpdir2(), "claudish-update-check.json");
   }
 }
 function readCache() {
@@ -61332,7 +62207,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync10(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync12(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache) {

package/package.json

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

package/recommended-models.json

@@ -0,0 +1,133 @@
+{
+  "version": "1.1.5",
+  "lastUpdated": "2026-01-04",
+  "source": "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
+  "models": [
+    {
+      "id": "google/gemini-3-pro-preview",
+      "name": "Google: Gemini 3 Pro Preview",
+      "description": "Gemini 3 Pro is Google’s flagship frontier model for high-precision multimodal reasoning, combining strong performance across text, image, video, audio, and code with a 1M-token context window. Reasoning Details must be preserved when using multi-turn tool calling, see our docs here: https://openrouter.ai/docs/use-cases/reasoning-tokens#preserving-reasoning-blocks. It delivers state-of-the-art benchmark results in general reasoning, STEM problem solving, factual QA, and multimodal understanding, including leading scores on LMArena, GPQA Diamond, MathArena Apex, MMMU-Pro, and Video-MMMU. Interactions emphasize depth and interpretability: the model is designed to infer intent with minimal prompting and produce direct, insight-focused responses.\n\nBuilt for advanced development and agentic workflows, Gemini 3 Pro provides robust tool-calling, long-horizon planning stability, and strong zero-shot generation for complex UI, visualization, and coding tasks. It excels at agentic coding (SWE-Bench Verified, Terminal-Bench 2.0), multimodal analysis, and structured long-form tasks such as research synthesis, planning, and interactive learning experiences. Suitable applications include autonomous agents, coding assistants, multimodal analytics, scientific reasoning, and high-context information processing.",
+      "provider": "Google",
+      "category": "vision",
+      "priority": 1,
+      "pricing": {
+        "input": "$2.00/1M",
+        "output": "$12.00/1M",
+        "average": "$7.00/1M"
+      },
+      "context": "1048K",
+      "maxOutputTokens": 65536,
+      "modality": "text+image->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": true,
+      "isModerated": false,
+      "recommended": true
+    },
+    {
+      "id": "openai/gpt-5.1-codex",
+      "name": "OpenAI: GPT-5.1-Codex",
+      "description": "GPT-5.1-Codex is a specialized version of GPT-5.1 optimized for software engineering and coding workflows. It is designed for both interactive development sessions and long, independent execution of complex engineering tasks. The model supports building projects from scratch, feature development, debugging, large-scale refactoring, and code review. Compared to GPT-5.1, Codex is more steerable, adheres closely to developer instructions, and produces cleaner, higher-quality code outputs. Reasoning effort can be adjusted with the `reasoning.effort` parameter. Read the [docs here](https://openrouter.ai/docs/use-cases/reasoning-tokens#reasoning-effort-level)\n\nCodex integrates into developer environments including the CLI, IDE extensions, GitHub, and cloud tasks. It adapts reasoning effort dynamically—providing fast responses for small tasks while sustaining extended multi-hour runs for large projects. The model is trained to perform structured code reviews, catching critical flaws by reasoning over dependencies and validating behavior against tests. It also supports multimodal inputs such as images or screenshots for UI development and integrates tool use for search, dependency installation, and environment setup. Codex is intended specifically for agentic coding applications.",
+      "provider": "Openai",
+      "category": "vision",
+      "priority": 2,
+      "pricing": {
+        "input": "$1.25/1M",
+        "output": "$10.00/1M",
+        "average": "$5.63/1M"
+      },
+      "context": "400K",
+      "maxOutputTokens": 128000,
+      "modality": "text+image->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": true,
+      "isModerated": true,
+      "recommended": true
+    },
+    {
+      "id": "x-ai/grok-code-fast-1",
+      "name": "xAI: Grok Code Fast 1",
+      "description": "Grok Code Fast 1 is a speedy and economical reasoning model that excels at agentic coding. With reasoning traces visible in the response, developers can steer Grok Code for high-quality work flows.",
+      "provider": "X-ai",
+      "category": "reasoning",
+      "priority": 3,
+      "pricing": {
+        "input": "$0.20/1M",
+        "output": "$1.50/1M",
+        "average": "$0.85/1M"
+      },
+      "context": "256K",
+      "maxOutputTokens": 10000,
+      "modality": "text->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": false,
+      "isModerated": false,
+      "recommended": true
+    },
+    {
+      "id": "minimax/minimax-m2",
+      "name": "MiniMax: MiniMax M2",
+      "description": "MiniMax-M2 is a compact, high-efficiency large language model optimized for end-to-end coding and agentic workflows. With 10 billion activated parameters (230 billion total), it delivers near-frontier intelligence across general reasoning, tool use, and multi-step task execution while maintaining low latency and deployment efficiency.\n\nThe model excels in code generation, multi-file editing, compile-run-fix loops, and test-validated repair, showing strong results on SWE-Bench Verified, Multi-SWE-Bench, and Terminal-Bench. It also performs competitively in agentic evaluations such as BrowseComp and GAIA, effectively handling long-horizon planning, retrieval, and recovery from execution errors.\n\nBenchmarked by [Artificial Analysis](https://artificialanalysis.ai/models/minimax-m2), MiniMax-M2 ranks among the top open-source models for composite intelligence, spanning mathematics, science, and instruction-following. Its small activation footprint enables fast inference, high concurrency, and improved unit economics, making it well-suited for large-scale agents, developer assistants, and reasoning-driven applications that require responsiveness and cost efficiency.\n\nTo avoid degrading this model's performance, MiniMax highly recommends preserving reasoning between turns. Learn more about using reasoning_details to pass back reasoning in our [docs](https://openrouter.ai/docs/use-cases/reasoning-tokens#preserving-reasoning-blocks).",
+      "provider": "Minimax",
+      "category": "reasoning",
+      "priority": 4,
+      "pricing": {
+        "input": "$0.20/1M",
+        "output": "$1.00/1M",
+        "average": "$0.60/1M"
+      },
+      "context": "196K",
+      "maxOutputTokens": 65536,
+      "modality": "text->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": false,
+      "isModerated": false,
+      "recommended": true
+    },
+    {
+      "id": "z-ai/glm-4.6",
+      "name": "Z.AI: GLM 4.6",
+      "description": "Compared with GLM-4.5, this generation brings several key improvements:\n\nLonger context window: The context window has been expanded from 128K to 200K tokens, enabling the model to handle more complex agentic tasks.\nSuperior coding performance: The model achieves higher scores on code benchmarks and demonstrates better real-world performance in applications such as Claude Code、Cline、Roo Code and Kilo Code, including improvements in generating visually polished front-end pages.\nAdvanced reasoning: GLM-4.6 shows a clear improvement in reasoning performance and supports tool use during inference, leading to stronger overall capability.\nMore capable agents: GLM-4.6 exhibits stronger performance in tool using and search-based agents, and integrates more effectively within agent frameworks.\nRefined writing: Better aligns with human preferences in style and readability, and performs more naturally in role-playing scenarios.",
+      "provider": "Z-ai",
+      "category": "reasoning",
+      "priority": 5,
+      "pricing": {
+        "input": "$0.35/1M",
+        "output": "$1.50/1M",
+        "average": "$0.93/1M"
+      },
+      "context": "202K",
+      "maxOutputTokens": 65536,
+      "modality": "text->text",
+      "supportsTools": true,
+      "supportsReasoning": true,
+      "supportsVision": false,
+      "isModerated": false,
+      "recommended": true
+    },
+    {
+      "id": "qwen/qwen3-vl-235b-a22b-instruct",
+      "name": "Qwen: Qwen3 VL 235B A22B Instruct",
+      "description": "Qwen3-VL-235B-A22B Instruct is an open-weight multimodal model that unifies strong text generation with visual understanding across images and video. The Instruct model targets general vision-language use (VQA, document parsing, chart/table extraction, multilingual OCR). The series emphasizes robust perception (recognition of diverse real-world and synthetic categories), spatial understanding (2D/3D grounding), and long-form visual comprehension, with competitive results on public multimodal benchmarks for both perception and reasoning.\n\nBeyond analysis, Qwen3-VL supports agentic interaction and tool use: it can follow complex instructions over multi-image, multi-turn dialogues; align text to video timelines for precise temporal queries; and operate GUI elements for automation tasks. The models also enable visual coding workflows—turning sketches or mockups into code and assisting with UI debugging—while maintaining strong text-only performance comparable to the flagship Qwen3 language models. This makes Qwen3-VL suitable for production scenarios spanning document AI, multilingual OCR, software/UI assistance, spatial/embodied tasks, and research on vision-language agents.",
+      "provider": "Qwen",
+      "category": "vision",
+      "priority": 6,
+      "pricing": {
+        "input": "$0.20/1M",
+        "output": "$1.20/1M",
+        "average": "$0.70/1M"
+      },
+      "context": "262K",
+      "maxOutputTokens": null,
+      "modality": "text+image->text",
+      "supportsTools": true,
+      "supportsReasoning": false,
+      "supportsVision": true,
+      "isModerated": false,
+      "recommended": true
+    }
+  ]
+}