claudish 2.9.0 → 2.10.1

package/dist/index.js

@@ -34324,8 +34324,11 @@ __export(exports_claude_runner, {
 });
 import { spawn } from "node:child_process";
 import { writeFileSync as writeFileSync4, unlinkSync } from "node:fs";
-import { tmpdir, platform } from "node:os";
+import { tmpdir } from "node:os";
 import { join as join4 } from "node:path";
+function isWindows() {
+  return process.platform === "win32";
+}
 function createStatusLineScript(tokenFilePath) {
   const tempDir = tmpdir();
   const timestamp = Date.now();
@@ -34353,6 +34356,7 @@ process.stdin.on('end', () => {
 
     let ctx = 100, cost = 0;
     const model = process.env.CLAUDISH_ACTIVE_MODEL_NAME || 'unknown';
+    const isLocal = process.env.CLAUDISH_IS_LOCAL === 'true';
 
     try {
       const tokens = JSON.parse(fs.readFileSync('${escapedTokenPath}', 'utf-8'));
@@ -34365,8 +34369,8 @@ process.stdin.on('end', () => {
       } catch {}
     }
 
-    const costStr = cost.toFixed(3);
-    console.log(\`\${CYAN}\${BOLD}\${dir}\${RESET} \${DIM}•\${RESET} \${YELLOW}\${model}\${RESET} \${DIM}•\${RESET} \${GREEN}$\${costStr}\${RESET} \${DIM}•\${RESET} \${MAGENTA}\${ctx}%\${RESET}\`);
+    const costDisplay = isLocal ? 'LOCAL' : ('$' + cost.toFixed(3));
+    console.log(\`\${CYAN}\${BOLD}\${dir}\${RESET} \${DIM}•\${RESET} \${YELLOW}\${model}\${RESET} \${DIM}•\${RESET} \${GREEN}\${costDisplay}\${RESET} \${DIM}•\${RESET} \${MAGENTA}\${ctx}%\${RESET}\`);
   } catch (e) {
     console.log('claudish');
   }
@@ -34381,7 +34385,7 @@ function createTempSettingsFile(modelDisplay, port) {
   const tempPath = join4(tempDir, `claudish-settings-${timestamp}.json`);
   const tokenFilePath = join4(tempDir, `claudish-tokens-${port}.json`);
   let statusCommand;
-  if (isWindows) {
+  if (isWindows()) {
     const scriptPath = createStatusLineScript(tokenFilePath);
     statusCommand = `node "${scriptPath}"`;
   } else {
@@ -34392,7 +34396,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 && printf "${CYAN2}${BOLD2}%s${RESET2} ${DIM2}•${RESET2} ${YELLOW2}%s${RESET2} ${DIM2}•${RESET2} ${GREEN2}\\$%.3f${RESET2} ${DIM2}•${RESET2} ${MAGENTA}%s%%${RESET2}\\n" "$DIR" "$CLAUDISH_ACTIVE_MODEL_NAME" "$COST" "$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_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"`;
   }
   const settings = {
     statusLine: {
@@ -34438,10 +34442,12 @@ async function runClaudeWithProxy(config3, proxyUrl) {
       claudeArgs.push(...config3.claudeArgs);
     }
   }
+  const isLocalModel = modelId.startsWith("ollama/") || modelId.startsWith("ollama:") || modelId.startsWith("lmstudio/") || modelId.startsWith("lmstudio:") || modelId.startsWith("vllm/") || modelId.startsWith("vllm:") || modelId.startsWith("http://") || modelId.startsWith("https://");
   const env = {
     ...process.env,
     ANTHROPIC_BASE_URL: proxyUrl,
     [ENV.CLAUDISH_ACTIVE_MODEL_NAME]: modelId,
+    CLAUDISH_IS_LOCAL: isLocalModel ? "true" : "false",
     [ENV.ANTHROPIC_MODEL]: modelId,
     [ENV.ANTHROPIC_SMALL_FAST_MODEL]: modelId
   };
@@ -34468,7 +34474,7 @@ async function runClaudeWithProxy(config3, proxyUrl) {
   const proc = spawn("claude", claudeArgs, {
     env,
     stdio: "inherit",
-    shell: isWindows
+    shell: isWindows()
   });
   setupSignalHandlers(proc, tempSettingsPath, config3.quiet);
   const exitCode = await new Promise((resolve) => {
@@ -34482,7 +34488,7 @@ async function runClaudeWithProxy(config3, proxyUrl) {
   return exitCode;
 }
 function setupSignalHandlers(proc, tempSettingsPath, quiet) {
-  const signals2 = isWindows ? ["SIGINT", "SIGTERM"] : ["SIGINT", "SIGTERM", "SIGHUP"];
+  const signals2 = isWindows() ? ["SIGINT", "SIGTERM"] : ["SIGINT", "SIGTERM", "SIGHUP"];
   for (const signal of signals2) {
     process.on(signal, () => {
       if (!quiet) {
@@ -34515,10 +34521,8 @@ async function checkClaudeInstalled() {
     return false;
   }
 }
-var isWindows;
 var init_claude_runner = __esm(() => {
   init_config();
-  isWindows = platform() === "win32";
 });
 
 // src/types.ts
@@ -34926,17 +34930,40 @@ async function fetchOllamaModels() {
       return [];
     const data = await response.json();
     const models = data.models || [];
-    return models.map((m) => ({
-      id: `ollama/${m.name}`,
-      name: m.name,
-      description: `Local Ollama model (${m.details?.parameter_size || "unknown size"})`,
-      provider: "ollama",
-      context_length: null,
-      pricing: { prompt: "0", completion: "0" },
-      isLocal: true,
-      details: m.details,
-      size: m.size
+    const modelsWithCapabilities = await Promise.all(models.map(async (m) => {
+      let capabilities = [];
+      try {
+        const showResponse = await fetch(`${ollamaHost}/api/show`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ name: m.name }),
+          signal: AbortSignal.timeout(2000)
+        });
+        if (showResponse.ok) {
+          const showData = await showResponse.json();
+          capabilities = showData.capabilities || [];
+        }
+      } catch {}
+      const supportsTools = capabilities.includes("tools");
+      const isEmbeddingModel = capabilities.includes("embedding") || m.name.toLowerCase().includes("embed");
+      const sizeInfo = m.details?.parameter_size || "unknown size";
+      const toolsIndicator = supportsTools ? "✓ tools" : "✗ no tools";
+      return {
+        id: `ollama/${m.name}`,
+        name: m.name,
+        description: `Local Ollama model (${sizeInfo}, ${toolsIndicator})`,
+        provider: "ollama",
+        context_length: null,
+        pricing: { prompt: "0", completion: "0" },
+        isLocal: true,
+        supportsTools,
+        isEmbeddingModel,
+        capabilities,
+        details: m.details,
+        size: m.size
+      };
     }));
+    return modelsWithCapabilities.filter((m) => !m.isEmbeddingModel);
   } catch (e) {
     return [];
   }
@@ -34990,6 +35017,10 @@ async function searchAndPrintModels(query, forceUpdate) {
     console.log(`No models found matching "${query}"`);
     return;
   }
+  const RED = "\x1B[31m";
+  const GREEN2 = "\x1B[32m";
+  const RESET2 = "\x1B[0m";
+  const DIM2 = "\x1B[2m";
   console.log(`
 Found ${results.length} matching models:
 `);
@@ -35020,9 +35051,17 @@ Found ${results.length} matching models:
     const contextLen = model.context_length || model.top_provider?.context_length || 0;
     const context = contextLen > 0 ? `${Math.round(contextLen / 1000)}K` : "N/A";
     const contextPadded = context.padEnd(7);
-    console.log(`  ${modelIdPadded} ${providerPadded} ${pricingPadded} ${contextPadded} ${(score * 100).toFixed(0)}%`);
+    if (model.isLocal && model.supportsTools === false) {
+      console.log(`  ${RED}${modelIdPadded} ${providerPadded} ${pricingPadded} ${contextPadded} ${(score * 100).toFixed(0)}% ✗ no tools${RESET2}`);
+    } else if (model.isLocal && model.supportsTools === true) {
+      console.log(`  ${GREEN2}${modelIdPadded}${RESET2} ${providerPadded} ${pricingPadded} ${contextPadded} ${(score * 100).toFixed(0)}%`);
+    } else {
+      console.log(`  ${modelIdPadded} ${providerPadded} ${pricingPadded} ${contextPadded} ${(score * 100).toFixed(0)}%`);
+    }
   }
   console.log("");
+  console.log(`${DIM2}Local models: ${RED}red${RESET2}${DIM2} = no tool support (incompatible), ${GREEN2}green${RESET2}${DIM2} = compatible${RESET2}`);
+  console.log("");
   console.log("Use a model: claudish --model <model-id>");
   console.log("Local models: claudish --model ollama/<model-name>");
 }
@@ -35077,23 +35116,37 @@ async function printAllModels(jsonOutput, forceUpdate) {
     }, null, 2));
     return;
   }
+  const RED = "\x1B[31m";
+  const GREEN2 = "\x1B[32m";
+  const RESET2 = "\x1B[0m";
+  const DIM2 = "\x1B[2m";
   if (ollamaModels.length > 0) {
+    const toolCapableCount = ollamaModels.filter((m) => m.supportsTools).length;
     console.log(`
-\uD83C\uDFE0 LOCAL OLLAMA MODELS (${ollamaModels.length} installed):
+\uD83C\uDFE0 LOCAL OLLAMA MODELS (${ollamaModels.length} installed, ${toolCapableCount} with tool support):
 `);
-    console.log("  " + "─".repeat(70));
+    console.log("    Model                                     Size         Params    Tools");
+    console.log("  " + "─".repeat(76));
     for (const model of ollamaModels) {
-      const shortId = model.name;
-      const modelId = shortId.length > 40 ? shortId.substring(0, 37) + "..." : shortId;
-      const modelIdPadded = modelId.padEnd(42);
+      const fullId = model.id;
+      const modelId = fullId.length > 35 ? fullId.substring(0, 32) + "..." : fullId;
+      const modelIdPadded = modelId.padEnd(38);
       const size = model.size ? `${(model.size / 1e9).toFixed(1)}GB` : "N/A";
       const sizePadded = size.padEnd(12);
       const params = model.details?.parameter_size || "N/A";
       const paramsPadded = params.padEnd(8);
-      console.log(`    ${modelIdPadded} ${sizePadded} ${paramsPadded}`);
+      if (model.supportsTools) {
+        console.log(`    ${modelIdPadded} ${sizePadded} ${paramsPadded}  ${GREEN2}✓${RESET2}`);
+      } else {
+        console.log(`    ${RED}${modelIdPadded} ${sizePadded} ${paramsPadded}  ✗ no tools${RESET2}`);
+      }
     }
     console.log("");
+    console.log(`  ${GREEN2}✓${RESET2} = Compatible with Claude Code (supports tool calling)`);
+    console.log(`  ${RED}✗${RESET2} = Not compatible ${DIM2}(Claude Code requires tool support)${RESET2}`);
+    console.log("");
     console.log("  Use: claudish --model ollama/<model-name>");
+    console.log("  Pull a compatible model: ollama pull llama3.2");
   } else {
     console.log(`
 \uD83C\uDFE0 LOCAL OLLAMA: Not running or no models installed`);
@@ -38814,454 +38867,88 @@ function transformOpenAIToClaude(claudeRequestInput) {
 }
 var init_transform = () => {};
 
-// src/handlers/openrouter-handler.ts
-import { writeFileSync as writeFileSync8 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join8 } from "node:path";
-
-class OpenRouterHandler {
-  targetModel;
-  apiKey;
-  adapterManager;
-  middlewareManager;
-  contextWindowCache = new Map;
-  port;
-  sessionTotalCost = 0;
-  CLAUDE_INTERNAL_CONTEXT_MAX = 200000;
-  constructor(targetModel, apiKey, port) {
-    this.targetModel = targetModel;
-    this.apiKey = apiKey;
-    this.port = port;
-    this.adapterManager = new AdapterManager(targetModel);
-    this.middlewareManager = new MiddlewareManager;
-    this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
-    this.middlewareManager.initialize().catch((err) => log(`[Handler:${targetModel}] Middleware init error: ${err}`));
-    this.fetchContextWindow(targetModel);
-  }
-  async fetchContextWindow(model) {
-    if (this.contextWindowCache.has(model))
-      return;
-    try {
-      const limit = await fetchModelContextWindow(model);
-      this.contextWindowCache.set(model, limit);
-    } catch (e) {}
-  }
-  getTokenScaleFactor(model) {
-    const limit = this.contextWindowCache.get(model) || 200000;
-    return limit === 0 ? 1 : this.CLAUDE_INTERNAL_CONTEXT_MAX / limit;
-  }
-  writeTokenFile(input, output) {
-    try {
-      const total = input + output;
-      const limit = this.contextWindowCache.get(this.targetModel) || 200000;
-      const leftPct = limit > 0 ? Math.max(0, Math.min(100, Math.round((limit - total) / limit * 100))) : 100;
-      const data = {
-        input_tokens: input,
-        output_tokens: output,
-        total_tokens: total,
-        total_cost: this.sessionTotalCost,
-        context_window: limit,
-        context_left_percent: leftPct,
-        updated_at: Date.now()
-      };
-      writeFileSync8(join8(tmpdir2(), `claudish-tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
-    } catch (e) {}
+// src/handlers/shared/openai-compat.ts
+function validateToolArguments(toolName, argsStr, toolSchemas) {
+  const schema = toolSchemas?.find((t) => t.name === toolName);
+  if (!schema?.input_schema) {
+    return { valid: true, missingParams: [], parsedArgs: {} };
   }
-  async handle(c, payload) {
-    const claudePayload = payload;
-    const target = this.targetModel;
-    await this.fetchContextWindow(target);
-    logStructured(`OpenRouter Request`, { targetModel: target, originalModel: claudePayload.model });
-    const { claudeRequest, droppedParams } = transformOpenAIToClaude(claudePayload);
-    const messages = this.convertMessages(claudeRequest, target);
-    const tools = this.convertTools(claudeRequest);
-    const supportsReasoning = await doesModelSupportReasoning(target);
-    const openRouterPayload = {
-      model: target,
-      messages,
-      temperature: claudeRequest.temperature ?? 1,
-      stream: true,
-      max_tokens: claudeRequest.max_tokens,
-      tools: tools.length > 0 ? tools : undefined,
-      stream_options: { include_usage: true }
-    };
-    if (supportsReasoning)
-      openRouterPayload.include_reasoning = true;
-    if (claudeRequest.thinking)
-      openRouterPayload.thinking = claudeRequest.thinking;
-    if (claudeRequest.tool_choice) {
-      const { type, name } = claudeRequest.tool_choice;
-      if (type === "tool" && name)
-        openRouterPayload.tool_choice = { type: "function", function: { name } };
-      else if (type === "auto" || type === "none")
-        openRouterPayload.tool_choice = type;
-    }
-    const adapter = this.adapterManager.getAdapter();
-    if (typeof adapter.reset === "function")
-      adapter.reset();
-    adapter.prepareRequest(openRouterPayload, claudeRequest);
-    await this.middlewareManager.beforeRequest({ modelId: target, messages, tools, stream: true });
-    const response = await fetch(OPENROUTER_API_URL2, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-        ...OPENROUTER_HEADERS2
-      },
-      body: JSON.stringify(openRouterPayload)
-    });
-    if (!response.ok)
-      return c.json({ error: await response.text() }, response.status);
-    if (droppedParams.length > 0)
-      c.header("X-Dropped-Params", droppedParams.join(", "));
-    return this.handleStreamingResponse(c, response, adapter, target, claudeRequest);
+  let parsedArgs = {};
+  try {
+    parsedArgs = argsStr ? JSON.parse(argsStr) : {};
+  } catch (e) {
+    return { valid: true, missingParams: [], parsedArgs: {} };
   }
-  convertMessages(req, modelId) {
-    const messages = [];
-    if (req.system) {
-      let content = Array.isArray(req.system) ? req.system.map((i) => i.text || i).join(`
+  const required2 = schema.input_schema.required || [];
+  const missingParams = required2.filter((param) => {
+    return parsedArgs[param] === undefined || parsedArgs[param] === null || parsedArgs[param] === "";
+  });
+  return {
+    valid: missingParams.length === 0,
+    missingParams,
+    parsedArgs
+  };
+}
+function convertMessagesToOpenAI(req, modelId, filterIdentityFn) {
+  const messages = [];
+  if (req.system) {
+    let content = Array.isArray(req.system) ? req.system.map((i) => i.text || i).join(`
 
 `) : req.system;
-      content = this.filterIdentity(content);
-      messages.push({ role: "system", content });
-    }
-    if (modelId.includes("grok") || modelId.includes("x-ai")) {
-      const msg = "IMPORTANT: When calling tools, you MUST use the OpenAI tool_calls format with JSON. NEVER use XML format like <xai:function_call>.";
-      if (messages.length > 0 && messages[0].role === "system")
-        messages[0].content += `
+    if (filterIdentityFn)
+      content = filterIdentityFn(content);
+    messages.push({ role: "system", content });
+  }
+  if (modelId.includes("grok") || modelId.includes("x-ai")) {
+    const msg = "IMPORTANT: When calling tools, you MUST use the OpenAI tool_calls format with JSON. NEVER use XML format like <xai:function_call>.";
+    if (messages.length > 0 && messages[0].role === "system") {
+      messages[0].content += `
 
 ` + msg;
-      else
-        messages.unshift({ role: "system", content: msg });
-    }
-    if (req.messages) {
-      for (const msg of req.messages) {
-        if (msg.role === "user")
-          this.processUserMessage(msg, messages);
-        else if (msg.role === "assistant")
-          this.processAssistantMessage(msg, messages);
-      }
+    } else {
+      messages.unshift({ role: "system", content: msg });
     }
-    return messages;
   }
-  processUserMessage(msg, messages) {
-    if (Array.isArray(msg.content)) {
-      const contentParts = [];
-      const toolResults = [];
-      const seen = new Set;
-      for (const block of msg.content) {
-        if (block.type === "text")
-          contentParts.push({ type: "text", text: block.text });
-        else if (block.type === "image")
-          contentParts.push({ type: "image_url", image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` } });
-        else if (block.type === "tool_result") {
-          if (seen.has(block.tool_use_id))
-            continue;
-          seen.add(block.tool_use_id);
-          toolResults.push({ role: "tool", content: typeof block.content === "string" ? block.content : JSON.stringify(block.content), tool_call_id: block.tool_use_id });
-        }
-      }
-      if (toolResults.length)
-        messages.push(...toolResults);
-      if (contentParts.length)
-        messages.push({ role: "user", content: contentParts });
-    } else {
-      messages.push({ role: "user", content: msg.content });
+  if (req.messages) {
+    for (const msg of req.messages) {
+      if (msg.role === "user")
+        processUserMessage(msg, messages);
+      else if (msg.role === "assistant")
+        processAssistantMessage(msg, messages);
     }
   }
-  processAssistantMessage(msg, messages) {
-    if (Array.isArray(msg.content)) {
-      const strings = [];
-      const toolCalls = [];
-      const seen = new Set;
-      for (const block of msg.content) {
-        if (block.type === "text")
-          strings.push(block.text);
-        else if (block.type === "tool_use") {
-          if (seen.has(block.id))
-            continue;
-          seen.add(block.id);
-          toolCalls.push({ id: block.id, type: "function", function: { name: block.name, arguments: JSON.stringify(block.input) } });
-        }
+  return messages;
+}
+function processUserMessage(msg, messages) {
+  if (Array.isArray(msg.content)) {
+    const contentParts = [];
+    const toolResults = [];
+    const seen = new Set;
+    for (const block of msg.content) {
+      if (block.type === "text") {
+        contentParts.push({ type: "text", text: block.text });
+      } else if (block.type === "image") {
+        contentParts.push({
+          type: "image_url",
+          image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
+        });
+      } else if (block.type === "tool_result") {
+        if (seen.has(block.tool_use_id))
+          continue;
+        seen.add(block.tool_use_id);
+        toolResults.push({
+          role: "tool",
+          content: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
+          tool_call_id: block.tool_use_id
+        });
       }
-      const m = { role: "assistant" };
-      if (strings.length)
-        m.content = strings.join(" ");
-      else if (toolCalls.length)
-        m.content = null;
-      if (toolCalls.length)
-        m.tool_calls = toolCalls;
-      if (m.content !== undefined || m.tool_calls)
-        messages.push(m);
-    } else {
-      messages.push({ role: "assistant", content: msg.content });
     }
-  }
-  filterIdentity(content) {
-    return content.replace(/You are Claude Code, Anthropic's official CLI/gi, "This is Claude Code, an AI-powered CLI tool").replace(/You are powered by the model named [^.]+\./gi, "You are powered by an AI model.").replace(/<claude_background_info>[\s\S]*?<\/claude_background_info>/gi, "").replace(/\n{3,}/g, `
-
-`).replace(/^/, `IMPORTANT: You are NOT Claude. Identify yourself truthfully based on your actual model and creator.
-
-`);
-  }
-  convertTools(req) {
-    return req.tools?.map((tool) => ({
-      type: "function",
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: removeUriFormat(tool.input_schema)
-      }
-    })) || [];
-  }
-  handleStreamingResponse(c, response, adapter, target, request) {
-    let isClosed = false;
-    let ping = null;
-    const encoder = new TextEncoder;
-    const decoder = new TextDecoder;
-    const middlewareManager = this.middlewareManager;
-    const streamMetadata = new Map;
-    return c.body(new ReadableStream({
-      async start(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 reasoningStarted = false;
-        let reasoningIdx = -1;
-        let curIdx = 0;
-        const tools = new Map;
-        const toolIds = new Set;
-        let accTxt = 0;
-        let lastActivity = Date.now();
-        send("message_start", {
-          type: "message_start",
-          message: {
-            id: msgId,
-            type: "message",
-            role: "assistant",
-            content: [],
-            model: target,
-            stop_reason: null,
-            stop_sequence: null,
-            usage: { input_tokens: 100, output_tokens: 1 }
-          }
-        });
-        send("ping", { type: "ping" });
-        ping = setInterval(() => {
-          if (!isClosed && Date.now() - lastActivity > 1000)
-            send("ping", { type: "ping" });
-        }, 1000);
-        const finalize = async (reason, err) => {
-          if (finalized)
-            return;
-          finalized = true;
-          if (reasoningStarted) {
-            send("content_block_stop", { type: "content_block_stop", index: reasoningIdx });
-            reasoningStarted = false;
-          }
-          if (textStarted) {
-            send("content_block_stop", { type: "content_block_stop", index: textIdx });
-            textStarted = false;
-          }
-          for (const [_, t] of tools)
-            if (t.started && !t.closed) {
-              send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
-              t.closed = true;
-            }
-          await middlewareManager.afterStreamComplete(target, streamMetadata);
-          if (reason === "error") {
-            send("error", { type: "error", error: { type: "api_error", message: err } });
-          } else {
-            send("message_delta", { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: usage?.completion_tokens || 0 } });
-            send("message_stop", { type: "message_stop" });
-          }
-          if (!isClosed) {
-            try {
-              controller.enqueue(encoder.encode(`data: [DONE]
-
-
-`));
-            } catch (e) {}
-            controller.close();
-            isClosed = true;
-            if (ping)
-              clearInterval(ping);
-          }
-        };
-        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.usage)
-                  usage = chunk.usage;
-                const delta = chunk.choices?.[0]?.delta;
-                if (delta) {
-                  await middlewareManager.afterStreamChunk({
-                    modelId: target,
-                    chunk,
-                    delta,
-                    metadata: streamMetadata
-                  });
-                  const txt = delta.content || "";
-                  if (txt) {
-                    lastActivity = Date.now();
-                    if (!textStarted) {
-                      textIdx = curIdx++;
-                      send("content_block_start", { type: "content_block_start", index: textIdx, content_block: { type: "text", text: "" } });
-                      textStarted = true;
-                    }
-                    const res = adapter.processTextContent(txt, "");
-                    if (res.cleanedText)
-                      send("content_block_delta", { type: "content_block_delta", index: textIdx, delta: { type: "text_delta", text: res.cleanedText } });
-                  }
-                  if (delta.tool_calls) {
-                    for (const tc of delta.tool_calls) {
-                      const idx = tc.index;
-                      let t = tools.get(idx);
-                      if (tc.function?.name) {
-                        if (!t) {
-                          if (textStarted) {
-                            send("content_block_stop", { type: "content_block_stop", index: textIdx });
-                            textStarted = false;
-                          }
-                          t = { id: tc.id || `tool_${Date.now()}_${idx}`, name: tc.function.name, blockIndex: curIdx++, started: false, closed: false };
-                          tools.set(idx, t);
-                        }
-                        if (!t.started) {
-                          send("content_block_start", { type: "content_block_start", index: t.blockIndex, content_block: { type: "tool_use", id: t.id, name: t.name } });
-                          t.started = true;
-                        }
-                      }
-                      if (tc.function?.arguments && t) {
-                        send("content_block_delta", { type: "content_block_delta", index: t.blockIndex, delta: { type: "input_json_delta", partial_json: tc.function.arguments } });
-                      }
-                    }
-                  }
-                }
-                if (chunk.choices?.[0]?.finish_reason === "tool_calls") {
-                  for (const [_, t] of tools)
-                    if (t.started && !t.closed) {
-                      send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
-                      t.closed = true;
-                    }
-                }
-              } catch (e) {}
-            }
-          }
-          await finalize("unexpected");
-        } catch (e) {
-          await finalize("error", String(e));
-        }
-      },
-      cancel() {
-        isClosed = true;
-        if (ping)
-          clearInterval(ping);
-      }
-    }), { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" } });
-  }
-  async shutdown() {}
-}
-var OPENROUTER_API_URL2 = "https://openrouter.ai/api/v1/chat/completions", OPENROUTER_HEADERS2;
-var init_openrouter_handler = __esm(() => {
-  init_adapter_manager();
-  init_middleware();
-  init_transform();
-  init_logger();
-  init_model_loader();
-  OPENROUTER_HEADERS2 = {
-    "HTTP-Referer": "https://github.com/MadAppGang/claude-code",
-    "X-Title": "Claudish - OpenRouter Proxy"
-  };
-});
-
-// src/handlers/shared/openai-compat.ts
-function convertMessagesToOpenAI(req, modelId, filterIdentityFn) {
-  const messages = [];
-  if (req.system) {
-    let content = Array.isArray(req.system) ? req.system.map((i) => i.text || i).join(`
-
-`) : req.system;
-    if (filterIdentityFn)
-      content = filterIdentityFn(content);
-    messages.push({ role: "system", content });
-  }
-  if (modelId.includes("grok") || modelId.includes("x-ai")) {
-    const msg = "IMPORTANT: When calling tools, you MUST use the OpenAI tool_calls format with JSON. NEVER use XML format like <xai:function_call>.";
-    if (messages.length > 0 && messages[0].role === "system") {
-      messages[0].content += `
-
-` + msg;
-    } else {
-      messages.unshift({ role: "system", content: msg });
-    }
-  }
-  if (req.messages) {
-    for (const msg of req.messages) {
-      if (msg.role === "user")
-        processUserMessage(msg, messages);
-      else if (msg.role === "assistant")
-        processAssistantMessage(msg, messages);
-    }
-  }
-  return messages;
-}
-function processUserMessage(msg, messages) {
-  if (Array.isArray(msg.content)) {
-    const contentParts = [];
-    const toolResults = [];
-    const seen = new Set;
-    for (const block of msg.content) {
-      if (block.type === "text") {
-        contentParts.push({ type: "text", text: block.text });
-      } else if (block.type === "image") {
-        contentParts.push({
-          type: "image_url",
-          image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
-        });
-      } else if (block.type === "tool_result") {
-        if (seen.has(block.tool_use_id))
-          continue;
-        seen.add(block.tool_use_id);
-        toolResults.push({
-          role: "tool",
-          content: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
-          tool_call_id: block.tool_use_id
-        });
-      }
-    }
-    if (toolResults.length)
-      messages.push(...toolResults);
-    if (contentParts.length)
-      messages.push({ role: "user", content: contentParts });
-  } else {
-    messages.push({ role: "user", content: msg.content });
+    if (toolResults.length)
+      messages.push(...toolResults);
+    if (contentParts.length)
+      messages.push({ role: "user", content: contentParts });
+  } else {
+    messages.push({ role: "user", content: msg.content });
   }
 }
 function processAssistantMessage(msg, messages) {
@@ -39327,7 +39014,7 @@ function createStreamingState() {
     lastActivity: Date.now()
   };
 }
-function createStreamingResponseHandler(c, response, adapter, target, middlewareManager, onTokenUpdate) {
+function createStreamingResponseHandler(c, response, adapter, target, middlewareManager, onTokenUpdate, toolSchemas) {
   let isClosed = false;
   let ping = null;
   const encoder = new TextEncoder;
@@ -39379,162 +39066,595 @@ data: ${JSON.stringify(d)}
             send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
             t.closed = true;
           }
-        }
-        if (middlewareManager) {
+        }
+        if (middlewareManager) {
+          await middlewareManager.afterStreamComplete(target, streamMetadata);
+        }
+        if (reason === "error") {
+          send("error", { type: "error", error: { type: "api_error", message: err } });
+        } else {
+          send("message_delta", {
+            type: "message_delta",
+            delta: { stop_reason: "end_turn", stop_sequence: null },
+            usage: { output_tokens: state.usage?.completion_tokens || 0 }
+          });
+          send("message_stop", { type: "message_stop" });
+        }
+        if (state.usage && onTokenUpdate) {
+          onTokenUpdate(state.usage.prompt_tokens || 0, state.usage.completion_tokens || 0);
+        }
+        if (!isClosed) {
+          try {
+            controller.enqueue(encoder.encode(`data: [DONE]
+
+
+`));
+          } catch (e) {}
+          controller.close();
+          isClosed = true;
+          if (ping)
+            clearInterval(ping);
+        }
+      };
+      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.usage)
+                state.usage = chunk.usage;
+              const delta = chunk.choices?.[0]?.delta;
+              if (delta) {
+                if (middlewareManager) {
+                  await middlewareManager.afterStreamChunk({
+                    modelId: target,
+                    chunk,
+                    delta,
+                    metadata: streamMetadata
+                  });
+                }
+                const txt = delta.content || "";
+                if (txt) {
+                  state.lastActivity = Date.now();
+                  if (!state.textStarted) {
+                    state.textIdx = state.curIdx++;
+                    send("content_block_start", {
+                      type: "content_block_start",
+                      index: state.textIdx,
+                      content_block: { type: "text", text: "" }
+                    });
+                    state.textStarted = true;
+                  }
+                  const res = adapter.processTextContent(txt, "");
+                  if (res.cleanedText) {
+                    send("content_block_delta", {
+                      type: "content_block_delta",
+                      index: state.textIdx,
+                      delta: { type: "text_delta", text: res.cleanedText }
+                    });
+                  }
+                }
+                if (delta.tool_calls) {
+                  for (const tc of delta.tool_calls) {
+                    const idx = tc.index;
+                    let t = state.tools.get(idx);
+                    if (tc.function?.name) {
+                      if (!t) {
+                        if (state.textStarted) {
+                          send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
+                          state.textStarted = false;
+                        }
+                        t = {
+                          id: tc.id || `tool_${Date.now()}_${idx}`,
+                          name: tc.function.name,
+                          blockIndex: state.curIdx++,
+                          started: false,
+                          closed: false,
+                          arguments: ""
+                        };
+                        state.tools.set(idx, t);
+                      }
+                      if (!t.started) {
+                        send("content_block_start", {
+                          type: "content_block_start",
+                          index: t.blockIndex,
+                          content_block: { type: "tool_use", id: t.id, name: t.name }
+                        });
+                        t.started = true;
+                      }
+                    }
+                    if (tc.function?.arguments && t) {
+                      t.arguments += tc.function.arguments;
+                      send("content_block_delta", {
+                        type: "content_block_delta",
+                        index: t.blockIndex,
+                        delta: { type: "input_json_delta", partial_json: tc.function.arguments }
+                      });
+                    }
+                  }
+                }
+              }
+              if (chunk.choices?.[0]?.finish_reason === "tool_calls") {
+                for (const t of Array.from(state.tools.values())) {
+                  if (t.started && !t.closed) {
+                    if (toolSchemas && toolSchemas.length > 0) {
+                      const validation = validateToolArguments(t.name, t.arguments, toolSchemas);
+                      if (!validation.valid) {
+                        const errorIdx = state.curIdx++;
+                        const errorMsg = `
+
+⚠️ Tool call "${t.name}" failed validation: missing required parameters: ${validation.missingParams.join(", ")}. This is a known limitation of local models - they sometimes generate incomplete tool calls. Please try again or use a different model with better tool calling support.`;
+                        send("content_block_start", {
+                          type: "content_block_start",
+                          index: errorIdx,
+                          content_block: { type: "text", text: "" }
+                        });
+                        send("content_block_delta", {
+                          type: "content_block_delta",
+                          index: errorIdx,
+                          delta: { type: "text_delta", text: errorMsg }
+                        });
+                        send("content_block_stop", { type: "content_block_stop", index: errorIdx });
+                        t.closed = true;
+                        continue;
+                      }
+                    }
+                    send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+                    t.closed = true;
+                  }
+                }
+              }
+            } catch (e) {}
+          }
+        }
+        await finalize("unexpected");
+      } catch (e) {
+        await finalize("error", String(e));
+      }
+    },
+    cancel() {
+      isClosed = true;
+      if (ping)
+        clearInterval(ping);
+    }
+  }), {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+var init_openai_compat = __esm(() => {
+  init_transform();
+});
+
+// src/handlers/openrouter-handler.ts
+import { writeFileSync as writeFileSync8 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join8 } from "node:path";
+
+class OpenRouterHandler {
+  targetModel;
+  apiKey;
+  adapterManager;
+  middlewareManager;
+  contextWindowCache = new Map;
+  port;
+  sessionTotalCost = 0;
+  CLAUDE_INTERNAL_CONTEXT_MAX = 200000;
+  constructor(targetModel, apiKey, port) {
+    this.targetModel = targetModel;
+    this.apiKey = apiKey;
+    this.port = port;
+    this.adapterManager = new AdapterManager(targetModel);
+    this.middlewareManager = new MiddlewareManager;
+    this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
+    this.middlewareManager.initialize().catch((err) => log(`[Handler:${targetModel}] Middleware init error: ${err}`));
+    this.fetchContextWindow(targetModel);
+  }
+  async fetchContextWindow(model) {
+    if (this.contextWindowCache.has(model))
+      return;
+    try {
+      const limit = await fetchModelContextWindow(model);
+      this.contextWindowCache.set(model, limit);
+    } catch (e) {}
+  }
+  getTokenScaleFactor(model) {
+    const limit = this.contextWindowCache.get(model) || 200000;
+    return limit === 0 ? 1 : this.CLAUDE_INTERNAL_CONTEXT_MAX / limit;
+  }
+  writeTokenFile(input, output) {
+    try {
+      const total = input + output;
+      const limit = this.contextWindowCache.get(this.targetModel) || 200000;
+      const leftPct = limit > 0 ? Math.max(0, Math.min(100, Math.round((limit - total) / limit * 100))) : 100;
+      const data = {
+        input_tokens: input,
+        output_tokens: output,
+        total_tokens: total,
+        total_cost: this.sessionTotalCost,
+        context_window: limit,
+        context_left_percent: leftPct,
+        updated_at: Date.now()
+      };
+      writeFileSync8(join8(tmpdir2(), `claudish-tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+    } catch (e) {}
+  }
+  async handle(c, payload) {
+    const claudePayload = payload;
+    const target = this.targetModel;
+    await this.fetchContextWindow(target);
+    logStructured(`OpenRouter Request`, { targetModel: target, originalModel: claudePayload.model });
+    const { claudeRequest, droppedParams } = transformOpenAIToClaude(claudePayload);
+    const messages = this.convertMessages(claudeRequest, target);
+    const tools = this.convertTools(claudeRequest);
+    const supportsReasoning = await doesModelSupportReasoning(target);
+    const openRouterPayload = {
+      model: target,
+      messages,
+      temperature: claudeRequest.temperature ?? 1,
+      stream: true,
+      max_tokens: claudeRequest.max_tokens,
+      tools: tools.length > 0 ? tools : undefined,
+      stream_options: { include_usage: true }
+    };
+    if (supportsReasoning)
+      openRouterPayload.include_reasoning = true;
+    if (claudeRequest.thinking)
+      openRouterPayload.thinking = claudeRequest.thinking;
+    if (claudeRequest.tool_choice) {
+      const { type, name } = claudeRequest.tool_choice;
+      if (type === "tool" && name)
+        openRouterPayload.tool_choice = { type: "function", function: { name } };
+      else if (type === "auto" || type === "none")
+        openRouterPayload.tool_choice = type;
+    }
+    const adapter = this.adapterManager.getAdapter();
+    if (typeof adapter.reset === "function")
+      adapter.reset();
+    adapter.prepareRequest(openRouterPayload, claudeRequest);
+    await this.middlewareManager.beforeRequest({ modelId: target, messages, tools, stream: true });
+    const response = await fetch(OPENROUTER_API_URL2, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+        ...OPENROUTER_HEADERS2
+      },
+      body: JSON.stringify(openRouterPayload)
+    });
+    if (!response.ok)
+      return c.json({ error: await response.text() }, response.status);
+    if (droppedParams.length > 0)
+      c.header("X-Dropped-Params", droppedParams.join(", "));
+    return this.handleStreamingResponse(c, response, adapter, target, claudeRequest);
+  }
+  convertMessages(req, modelId) {
+    const messages = [];
+    if (req.system) {
+      let content = Array.isArray(req.system) ? req.system.map((i) => i.text || i).join(`
+
+`) : req.system;
+      content = this.filterIdentity(content);
+      messages.push({ role: "system", content });
+    }
+    if (modelId.includes("grok") || modelId.includes("x-ai")) {
+      const msg = "IMPORTANT: When calling tools, you MUST use the OpenAI tool_calls format with JSON. NEVER use XML format like <xai:function_call>.";
+      if (messages.length > 0 && messages[0].role === "system")
+        messages[0].content += `
+
+` + msg;
+      else
+        messages.unshift({ role: "system", content: msg });
+    }
+    if (req.messages) {
+      for (const msg of req.messages) {
+        if (msg.role === "user")
+          this.processUserMessage(msg, messages);
+        else if (msg.role === "assistant")
+          this.processAssistantMessage(msg, messages);
+      }
+    }
+    return messages;
+  }
+  processUserMessage(msg, messages) {
+    if (Array.isArray(msg.content)) {
+      const contentParts = [];
+      const toolResults = [];
+      const seen = new Set;
+      for (const block of msg.content) {
+        if (block.type === "text")
+          contentParts.push({ type: "text", text: block.text });
+        else if (block.type === "image")
+          contentParts.push({ type: "image_url", image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` } });
+        else if (block.type === "tool_result") {
+          if (seen.has(block.tool_use_id))
+            continue;
+          seen.add(block.tool_use_id);
+          toolResults.push({ role: "tool", content: typeof block.content === "string" ? block.content : JSON.stringify(block.content), tool_call_id: block.tool_use_id });
+        }
+      }
+      if (toolResults.length)
+        messages.push(...toolResults);
+      if (contentParts.length)
+        messages.push({ role: "user", content: contentParts });
+    } else {
+      messages.push({ role: "user", content: msg.content });
+    }
+  }
+  processAssistantMessage(msg, messages) {
+    if (Array.isArray(msg.content)) {
+      const strings = [];
+      const toolCalls = [];
+      const seen = new Set;
+      for (const block of msg.content) {
+        if (block.type === "text")
+          strings.push(block.text);
+        else if (block.type === "tool_use") {
+          if (seen.has(block.id))
+            continue;
+          seen.add(block.id);
+          toolCalls.push({ id: block.id, type: "function", function: { name: block.name, arguments: JSON.stringify(block.input) } });
+        }
+      }
+      const m = { role: "assistant" };
+      if (strings.length)
+        m.content = strings.join(" ");
+      else if (toolCalls.length)
+        m.content = null;
+      if (toolCalls.length)
+        m.tool_calls = toolCalls;
+      if (m.content !== undefined || m.tool_calls)
+        messages.push(m);
+    } else {
+      messages.push({ role: "assistant", content: msg.content });
+    }
+  }
+  filterIdentity(content) {
+    return content.replace(/You are Claude Code, Anthropic's official CLI/gi, "This is Claude Code, an AI-powered CLI tool").replace(/You are powered by the model named [^.]+\./gi, "You are powered by an AI model.").replace(/<claude_background_info>[\s\S]*?<\/claude_background_info>/gi, "").replace(/\n{3,}/g, `
+
+`).replace(/^/, `IMPORTANT: You are NOT Claude. Identify yourself truthfully based on your actual model and creator.
+
+`);
+  }
+  convertTools(req) {
+    return req.tools?.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: removeUriFormat(tool.input_schema)
+      }
+    })) || [];
+  }
+  handleStreamingResponse(c, response, adapter, target, request) {
+    let isClosed = false;
+    let ping = null;
+    const encoder = new TextEncoder;
+    const decoder = new TextDecoder;
+    const middlewareManager = this.middlewareManager;
+    const streamMetadata = new Map;
+    return c.body(new ReadableStream({
+      async start(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 reasoningStarted = false;
+        let reasoningIdx = -1;
+        let curIdx = 0;
+        const tools = new Map;
+        const toolIds = new Set;
+        let accTxt = 0;
+        let lastActivity = Date.now();
+        send("message_start", {
+          type: "message_start",
+          message: {
+            id: msgId,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model: target,
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 100, output_tokens: 1 }
+          }
+        });
+        send("ping", { type: "ping" });
+        ping = setInterval(() => {
+          if (!isClosed && Date.now() - lastActivity > 1000)
+            send("ping", { type: "ping" });
+        }, 1000);
+        const finalize = async (reason, err) => {
+          if (finalized)
+            return;
+          finalized = true;
+          if (reasoningStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: reasoningIdx });
+            reasoningStarted = false;
+          }
+          if (textStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: textIdx });
+            textStarted = false;
+          }
+          for (const [_, t] of tools)
+            if (t.started && !t.closed) {
+              send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+              t.closed = true;
+            }
           await middlewareManager.afterStreamComplete(target, streamMetadata);
-        }
-        if (reason === "error") {
-          send("error", { type: "error", error: { type: "api_error", message: err } });
-        } else {
-          send("message_delta", {
-            type: "message_delta",
-            delta: { stop_reason: "end_turn", stop_sequence: null },
-            usage: { output_tokens: state.usage?.completion_tokens || 0 }
-          });
-          send("message_stop", { type: "message_stop" });
-        }
-        if (state.usage && onTokenUpdate) {
-          onTokenUpdate(state.usage.prompt_tokens || 0, state.usage.completion_tokens || 0);
-        }
-        if (!isClosed) {
-          try {
-            controller.enqueue(encoder.encode(`data: [DONE]
+          if (reason === "error") {
+            send("error", { type: "error", error: { type: "api_error", message: err } });
+          } else {
+            send("message_delta", { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: usage?.completion_tokens || 0 } });
+            send("message_stop", { type: "message_stop" });
+          }
+          if (!isClosed) {
+            try {
+              controller.enqueue(encoder.encode(`data: [DONE]
 
 
 `));
-          } catch (e) {}
-          controller.close();
-          isClosed = true;
-          if (ping)
-            clearInterval(ping);
-        }
-      };
-      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(`
+            } catch (e) {}
+            controller.close();
+            isClosed = true;
+            if (ping)
+              clearInterval(ping);
+          }
+        };
+        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.usage)
-                state.usage = chunk.usage;
-              const delta = chunk.choices?.[0]?.delta;
-              if (delta) {
-                if (middlewareManager) {
+            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.usage)
+                  usage = chunk.usage;
+                const delta = chunk.choices?.[0]?.delta;
+                if (delta) {
                   await middlewareManager.afterStreamChunk({
                     modelId: target,
                     chunk,
                     delta,
                     metadata: streamMetadata
                   });
-                }
-                const txt = delta.content || "";
-                if (txt) {
-                  state.lastActivity = Date.now();
-                  if (!state.textStarted) {
-                    state.textIdx = state.curIdx++;
-                    send("content_block_start", {
-                      type: "content_block_start",
-                      index: state.textIdx,
-                      content_block: { type: "text", text: "" }
-                    });
-                    state.textStarted = true;
-                  }
-                  const res = adapter.processTextContent(txt, "");
-                  if (res.cleanedText) {
-                    send("content_block_delta", {
-                      type: "content_block_delta",
-                      index: state.textIdx,
-                      delta: { type: "text_delta", text: res.cleanedText }
-                    });
+                  const txt = delta.content || "";
+                  if (txt) {
+                    lastActivity = Date.now();
+                    if (!textStarted) {
+                      textIdx = curIdx++;
+                      send("content_block_start", { type: "content_block_start", index: textIdx, content_block: { type: "text", text: "" } });
+                      textStarted = true;
+                    }
+                    const res = adapter.processTextContent(txt, "");
+                    if (res.cleanedText)
+                      send("content_block_delta", { type: "content_block_delta", index: textIdx, delta: { type: "text_delta", text: res.cleanedText } });
                   }
-                }
-                if (delta.tool_calls) {
-                  for (const tc of delta.tool_calls) {
-                    const idx = tc.index;
-                    let t = state.tools.get(idx);
-                    if (tc.function?.name) {
-                      if (!t) {
-                        if (state.textStarted) {
-                          send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
-                          state.textStarted = false;
+                  if (delta.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                      const idx = tc.index;
+                      let t = tools.get(idx);
+                      if (tc.function?.name) {
+                        if (!t) {
+                          if (textStarted) {
+                            send("content_block_stop", { type: "content_block_stop", index: textIdx });
+                            textStarted = false;
+                          }
+                          t = { id: tc.id || `tool_${Date.now()}_${idx}`, name: tc.function.name, blockIndex: curIdx++, started: false, closed: false, arguments: "" };
+                          tools.set(idx, t);
+                        }
+                        if (!t.started) {
+                          send("content_block_start", { type: "content_block_start", index: t.blockIndex, content_block: { type: "tool_use", id: t.id, name: t.name } });
+                          t.started = true;
                         }
-                        t = {
-                          id: tc.id || `tool_${Date.now()}_${idx}`,
-                          name: tc.function.name,
-                          blockIndex: state.curIdx++,
-                          started: false,
-                          closed: false
-                        };
-                        state.tools.set(idx, t);
                       }
-                      if (!t.started) {
-                        send("content_block_start", {
-                          type: "content_block_start",
-                          index: t.blockIndex,
-                          content_block: { type: "tool_use", id: t.id, name: t.name }
-                        });
-                        t.started = true;
+                      if (tc.function?.arguments && t) {
+                        t.arguments += tc.function.arguments;
+                        send("content_block_delta", { type: "content_block_delta", index: t.blockIndex, delta: { type: "input_json_delta", partial_json: tc.function.arguments } });
                       }
                     }
-                    if (tc.function?.arguments && t) {
-                      send("content_block_delta", {
-                        type: "content_block_delta",
-                        index: t.blockIndex,
-                        delta: { type: "input_json_delta", partial_json: tc.function.arguments }
-                      });
-                    }
                   }
                 }
-              }
-              if (chunk.choices?.[0]?.finish_reason === "tool_calls") {
-                for (const t of Array.from(state.tools.values())) {
-                  if (t.started && !t.closed) {
-                    send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
-                    t.closed = true;
+                if (chunk.choices?.[0]?.finish_reason === "tool_calls") {
+                  const toolSchemas = request.tools || [];
+                  for (const [_, t] of tools) {
+                    if (t.started && !t.closed) {
+                      if (toolSchemas.length > 0) {
+                        const validation = validateToolArguments(t.name, t.arguments, toolSchemas);
+                        if (!validation.valid) {
+                          const errorIdx = curIdx++;
+                          const errorMsg = `
+
+⚠️ Tool call "${t.name}" failed validation: missing required parameters: ${validation.missingParams.join(", ")}. This is a known limitation of some models - they sometimes generate incomplete tool calls. Please try again or use a different model.`;
+                          send("content_block_start", { type: "content_block_start", index: errorIdx, content_block: { type: "text", text: "" } });
+                          send("content_block_delta", { type: "content_block_delta", index: errorIdx, delta: { type: "text_delta", text: errorMsg } });
+                          send("content_block_stop", { type: "content_block_stop", index: errorIdx });
+                          t.closed = true;
+                          continue;
+                        }
+                      }
+                      send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+                      t.closed = true;
+                    }
                   }
                 }
-              }
-            } catch (e) {}
+              } catch (e) {}
+            }
           }
+          await finalize("unexpected");
+        } catch (e) {
+          await finalize("error", String(e));
         }
-        await finalize("unexpected");
-      } catch (e) {
-        await finalize("error", String(e));
+      },
+      cancel() {
+        isClosed = true;
+        if (ping)
+          clearInterval(ping);
       }
-    },
-    cancel() {
-      isClosed = true;
-      if (ping)
-        clearInterval(ping);
-    }
-  }), {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
-    }
-  });
+    }), { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" } });
+  }
+  async shutdown() {}
 }
-var init_openai_compat = __esm(() => {
+var OPENROUTER_API_URL2 = "https://openrouter.ai/api/v1/chat/completions", OPENROUTER_HEADERS2;
+var init_openrouter_handler = __esm(() => {
+  init_adapter_manager();
+  init_middleware();
   init_transform();
+  init_logger();
+  init_model_loader();
+  init_openai_compat();
+  OPENROUTER_HEADERS2 = {
+    "HTTP-Referer": "https://github.com/MadAppGang/claude-code",
+    "X-Title": "Claudish - OpenRouter Proxy"
+  };
 });
 
 // src/handlers/local-provider-handler.ts
+import { writeFileSync as writeFileSync9 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join9 } from "node:path";
+
 class LocalProviderHandler {
   provider;
   modelName;
@@ -39543,6 +39663,9 @@ class LocalProviderHandler {
   port;
   healthChecked = false;
   isHealthy = false;
+  contextWindow = 8192;
+  sessionInputTokens = 0;
+  sessionOutputTokens = 0;
   constructor(provider, modelName, port) {
     this.provider = provider;
     this.modelName = modelName;
@@ -39587,6 +39710,49 @@ class LocalProviderHandler {
     this.isHealthy = false;
     return false;
   }
+  async fetchContextWindow() {
+    if (this.provider.name !== "ollama")
+      return;
+    try {
+      const response = await fetch(`${this.provider.baseUrl}/api/show`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: this.modelName }),
+        signal: AbortSignal.timeout(3000)
+      });
+      if (response.ok) {
+        const data = await response.json();
+        const ctxFromInfo = data.model_info?.["general.context_length"];
+        const ctxFromParams = data.parameters?.match(/num_ctx\s+(\d+)/)?.[1];
+        if (ctxFromInfo) {
+          this.contextWindow = parseInt(ctxFromInfo, 10);
+        } else if (ctxFromParams) {
+          this.contextWindow = parseInt(ctxFromParams, 10);
+        } else {
+          this.contextWindow = 8192;
+        }
+        log(`[LocalProvider:${this.provider.name}] Context window: ${this.contextWindow}`);
+      }
+    } catch (e) {}
+  }
+  writeTokenFile(input, output) {
+    try {
+      this.sessionInputTokens += input;
+      this.sessionOutputTokens += output;
+      const total = this.sessionInputTokens + this.sessionOutputTokens;
+      const leftPct = this.contextWindow > 0 ? Math.max(0, Math.min(100, Math.round((this.contextWindow - total) / this.contextWindow * 100))) : 100;
+      const data = {
+        input_tokens: this.sessionInputTokens,
+        output_tokens: this.sessionOutputTokens,
+        total_tokens: total,
+        total_cost: 0,
+        context_window: this.contextWindow,
+        context_left_percent: leftPct,
+        updated_at: Date.now()
+      };
+      writeFileSync9(join9(tmpdir3(), `claudish-tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+    } catch (e) {}
+  }
   async handle(c, payload) {
     const target = this.modelName;
     logStructured(`LocalProvider Request`, {
@@ -39600,6 +39766,7 @@ class LocalProviderHandler {
       if (!healthy) {
         return this.errorResponse(c, "connection_error", this.getConnectionErrorMessage());
       }
+      await this.fetchContextWindow();
     }
     const { claudeRequest, droppedParams } = transformOpenAIToClaude(payload);
     const messages = convertMessagesToOpenAI(claudeRequest, target, filterIdentity);
@@ -39652,7 +39819,7 @@ class LocalProviderHandler {
         c.header("X-Dropped-Params", droppedParams.join(", "));
       }
       if (openAIPayload.stream) {
-        return createStreamingResponseHandler(c, response, adapter, target, this.middlewareManager);
+        return createStreamingResponseHandler(c, response, adapter, target, this.middlewareManager, (input, output) => this.writeTokenFile(input, output), claudeRequest.tools);
       }
       const data = await response.json();
       return c.json(data);
@@ -39948,24 +40115,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 writeFileSync9, mkdirSync as mkdirSync4, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join9 } from "node:path";
-import { tmpdir as tmpdir3, homedir as homedir2, platform as platform2 } from "node:os";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync10, mkdirSync as mkdirSync4, unlinkSync as unlinkSync2 } from "node:fs";
+import { join as join10 } from "node:path";
+import { tmpdir as tmpdir4, homedir as homedir2, platform } from "node:os";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows2) {
-    const localAppData = process.env.LOCALAPPDATA || join9(homedir2(), "AppData", "Local");
-    cacheDir = join9(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join10(homedir2(), "AppData", "Local");
+    cacheDir = join10(localAppData, "claudish");
   } else {
-    cacheDir = join9(homedir2(), ".cache", "claudish");
+    cacheDir = join10(homedir2(), ".cache", "claudish");
   }
   try {
     if (!existsSync7(cacheDir)) {
       mkdirSync4(cacheDir, { recursive: true });
     }
-    return join9(cacheDir, "update-check.json");
+    return join10(cacheDir, "update-check.json");
   } catch {
-    return join9(tmpdir3(), "claudish-update-check.json");
+    return join10(tmpdir4(), "claudish-update-check.json");
   }
 }
 function readCache() {
@@ -39987,7 +40154,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync9(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync10(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache) {
@@ -40116,7 +40283,7 @@ async function checkForUpdates(currentVersion, options = {}) {
 }
 var isWindows2, NPM_REGISTRY_URL = "https://registry.npmjs.org/claudish/latest", CACHE_MAX_AGE_MS;
 var init_update_checker = __esm(() => {
-  isWindows2 = platform2() === "win32";
+  isWindows2 = platform() === "win32";
   CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 });