claudish 2.10.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();
@@ -34382,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 {
@@ -34471,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) => {
@@ -34485,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) {
@@ -34518,10 +34521,8 @@ async function checkClaudeInstalled() {
     return false;
   }
 }
-var isWindows;
 var init_claude_runner = __esm(() => {
   init_config();
-  isWindows = platform() === "win32";
 });
 
 // src/types.ts
@@ -38866,724 +38867,787 @@ 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 });
+    } 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);
-      }
+  }
+  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;
   }
-  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 });
-        }
+  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 });
   }
-  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) } });
-        }
+}
+function 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 });
     }
+    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, `
+}
+function convertToolsToOpenAI(req) {
+  return req.tools?.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: removeUriFormat(tool.input_schema)
+    }
+  })) || [];
+}
+function 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}
+}
+function createStreamingState() {
+  return {
+    usage: null,
+    finalized: false,
+    textStarted: false,
+    textIdx: -1,
+    reasoningStarted: false,
+    reasoningIdx: -1,
+    curIdx: 0,
+    tools: new Map,
+    toolIds: new Set,
+    lastActivity: Date.now()
+  };
+}
+function createStreamingResponseHandler(c, response, adapter, target, middlewareManager, onTokenUpdate, toolSchemas) {
+  let isClosed = false;
+  let ping = null;
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  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;
+        }
+      };
+      const msgId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      const state = createStreamingState();
+      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() - state.lastActivity > 1000) {
+          send("ping", { type: "ping" });
+        }
+      }, 1000);
+      const finalize = async (reason, err) => {
+        if (state.finalized)
+          return;
+        state.finalized = true;
+        if (state.reasoningStarted) {
+          send("content_block_stop", { type: "content_block_stop", index: state.reasoningIdx });
+        }
+        if (state.textStarted) {
+          send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
+        }
+        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;
           }
-          for (const [_, t] of tools)
-            if (t.started && !t.closed) {
-              send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
-              t.closed = true;
-            }
+        }
+        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: usage?.completion_tokens || 0 } });
-            send("message_stop", { type: "message_stop" });
-          }
-          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: 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(`
+          } 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) {
+          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) {
-                    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;
+                }
+                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 (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 (!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 tools)
-                    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") {
+                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) {}
-            }
+              }
+            } catch (e) {}
           }
-          await finalize("unexpected");
-        } catch (e) {
-          await finalize("error", String(e));
         }
-      },
-      cancel() {
-        isClosed = true;
-        if (ping)
-          clearInterval(ping);
+        await finalize("unexpected");
+      } catch (e) {
+        await finalize("error", String(e));
       }
-    }), { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" } });
-  }
-  async shutdown() {}
+    },
+    cancel() {
+      isClosed = true;
+      if (ping)
+        clearInterval(ping);
+    }
+  }), {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
 }
-var OPENROUTER_API_URL2 = "https://openrouter.ai/api/v1/chat/completions", OPENROUTER_HEADERS2;
-var init_openrouter_handler = __esm(() => {
-  init_adapter_manager();
-  init_middleware();
+var init_openai_compat = __esm(() => {
   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(`
+// 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";
 
-`) : req.system;
-    if (filterIdentityFn)
-      content = filterIdentityFn(content);
-    messages.push({ role: "system", content });
+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);
   }
-  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 += `
+  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 });
+      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);
+    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;
   }
-  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
-        });
+  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) {
-  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) }
-        });
+  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 });
     }
-    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 });
   }
-}
-function convertToolsToOpenAI(req) {
-  return req.tools?.map((tool) => ({
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: removeUriFormat(tool.input_schema)
-    }
-  })) || [];
-}
-function 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, `
+  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.
 
 `);
-}
-function createStreamingState() {
-  return {
-    usage: null,
-    finalized: false,
-    textStarted: false,
-    textIdx: -1,
-    reasoningStarted: false,
-    reasoningIdx: -1,
-    curIdx: 0,
-    tools: new Map,
-    toolIds: new Set,
-    lastActivity: Date.now()
-  };
-}
-function createStreamingResponseHandler(c, response, adapter, target, middlewareManager, onTokenUpdate) {
-  let isClosed = false;
-  let ping = null;
-  const encoder = new TextEncoder;
-  const decoder = new TextDecoder;
-  const streamMetadata = new Map;
-  return c.body(new ReadableStream({
-    async start(controller) {
-      const send = (e, d) => {
-        if (!isClosed) {
-          controller.enqueue(encoder.encode(`event: ${e}
+  }
+  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)}`;
-      const state = createStreamingState();
-      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() - state.lastActivity > 1000) {
-          send("ping", { type: "ping" });
-        }
-      }, 1000);
-      const finalize = async (reason, err) => {
-        if (state.finalized)
-          return;
-        state.finalized = true;
-        if (state.reasoningStarted) {
-          send("content_block_stop", { type: "content_block_stop", index: state.reasoningIdx });
-        }
-        if (state.textStarted) {
-          send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
-        }
-        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;
+        };
+        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 }
           }
-        }
-        if (middlewareManager) {
+        });
+        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
@@ -39755,7 +39819,7 @@ class LocalProviderHandler {
         c.header("X-Dropped-Params", droppedParams.join(", "));
       }
       if (openAIPayload.stream) {
-        return createStreamingResponseHandler(c, response, adapter, target, this.middlewareManager, (input, output) => this.writeTokenFile(input, output));
+        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);
@@ -40053,7 +40117,7 @@ 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 mkdirSync4, unlinkSync as unlinkSync2 } from "node:fs";
 import { join as join10 } from "node:path";
-import { tmpdir as tmpdir4, homedir as homedir2, platform as platform2 } from "node:os";
+import { tmpdir as tmpdir4, homedir as homedir2, platform } from "node:os";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows2) {
@@ -40219,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;
 });