claudish 3.0.6 → 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 = {
@@ -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.6",
+  "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

@@ -1,6 +1,6 @@
 {
   "version": "1.1.5",
-  "lastUpdated": "2025-12-28",
+  "lastUpdated": "2026-01-04",
   "source": "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
   "models": [
     {
@@ -79,7 +79,7 @@
         "average": "$0.60/1M"
       },
       "context": "196K",
-      "maxOutputTokens": 131072,
+      "maxOutputTokens": 65536,
       "modality": "text->text",
       "supportsTools": true,
       "supportsReasoning": true,
@@ -95,12 +95,12 @@
       "category": "reasoning",
       "priority": 5,
       "pricing": {
-        "input": "$0.39/1M",
-        "output": "$1.90/1M",
-        "average": "$1.15/1M"
+        "input": "$0.35/1M",
+        "output": "$1.50/1M",
+        "average": "$0.93/1M"
       },
-      "context": "204K",
-      "maxOutputTokens": 204800,
+      "context": "202K",
+      "maxOutputTokens": 65536,
       "modality": "text->text",
       "supportsTools": true,
       "supportsReasoning": true,