claudish 2.10.0 → 2.11.0

package/dist/index.js

@@ -34308,7 +34308,8 @@ var init_config = __esm(() => {
     OLLAMA_BASE_URL: "OLLAMA_BASE_URL",
     OLLAMA_HOST: "OLLAMA_HOST",
     LMSTUDIO_BASE_URL: "LMSTUDIO_BASE_URL",
-    VLLM_BASE_URL: "VLLM_BASE_URL"
+    VLLM_BASE_URL: "VLLM_BASE_URL",
+    CLAUDISH_SUMMARIZE_TOOLS: "CLAUDISH_SUMMARIZE_TOOLS"
   };
   OPENROUTER_HEADERS = {
     "HTTP-Referer": "https://github.com/MadAppGang/claude-code",
@@ -34324,8 +34325,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 +34386,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 +34475,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 +34489,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 +34522,8 @@ async function checkClaudeInstalled() {
     return false;
   }
 }
-var isWindows;
 var init_claude_runner = __esm(() => {
   init_config();
-  isWindows = platform() === "win32";
 });
 
 // src/types.ts
@@ -34742,6 +34744,10 @@ async function parseArgs(args) {
       config3.port = port;
     }
   }
+  const envSummarizeTools = process.env[ENV.CLAUDISH_SUMMARIZE_TOOLS];
+  if (envSummarizeTools === "true" || envSummarizeTools === "1") {
+    config3.summarizeTools = true;
+  }
   let i = 0;
   while (i < args.length) {
     const arg = args[i];
@@ -34858,6 +34864,8 @@ async function parseArgs(args) {
         await printAllModels(hasJsonFlag, forceUpdate);
       }
       process.exit(0);
+    } else if (arg === "--summarize-tools") {
+      config3.summarizeTools = true;
     } else {
       config3.claudeArgs = args.slice(i);
       break;
@@ -38866,408 +38874,238 @@ 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);
+// src/handlers/shared/tool-call-recovery.ts
+function extractToolCallsFromText(text) {
+  const extracted = [];
+  const qwenPattern = /<function=([^>]+)>([\s\S]*?)(?=<function=|$)/gi;
+  let match2;
+  while ((match2 = qwenPattern.exec(text)) !== null) {
+    const funcName = match2[1];
+    const paramsText = match2[2];
+    const args = {};
+    const paramPattern = /<parameter=([^>]+)>\s*([\s\S]*?)(?=<parameter=|<function=|$)/gi;
+    let paramMatch;
+    while ((paramMatch = paramPattern.exec(paramsText)) !== null) {
+      const paramName = paramMatch[1];
+      const paramValue = paramMatch[2].trim();
+      args[paramName] = paramValue;
+    }
+    if (funcName) {
+      extracted.push({
+        name: funcName,
+        arguments: args,
+        source: "xml_text"
+      });
+      log(`[ToolRecovery] Extracted Qwen-style tool call: ${funcName}`);
+    }
   }
-  async fetchContextWindow(model) {
-    if (this.contextWindowCache.has(model))
-      return;
+  const xmlPattern = /<tool_call>\s*(\{[\s\S]*?\})\s*<\/tool_call>/gi;
+  while ((match2 = xmlPattern.exec(text)) !== null) {
     try {
-      const limit = await fetchModelContextWindow(model);
-      this.contextWindowCache.set(model, limit);
+      const parsed = JSON.parse(match2[1]);
+      if (parsed.name) {
+        extracted.push({
+          name: parsed.name,
+          arguments: parsed.arguments || parsed.input || parsed.parameters || {},
+          source: "xml_text"
+        });
+      }
     } catch (e) {}
   }
-  getTokenScaleFactor(model) {
-    const limit = this.contextWindowCache.get(model) || 200000;
-    return limit === 0 ? 1 : this.CLAUDE_INTERNAL_CONTEXT_MAX / limit;
+  const funcCallPattern = /\{\s*"name"\s*:\s*"([^"]+)"\s*,\s*"(?:arguments|input|parameters)"\s*:\s*(\{[\s\S]*?\})\s*\}/gi;
+  while ((match2 = funcCallPattern.exec(text)) !== null) {
+    try {
+      const args = JSON.parse(match2[2]);
+      extracted.push({
+        name: match2[1],
+        arguments: args,
+        source: "json_text"
+      });
+    } catch (e) {}
   }
-  writeTokenFile(input, output) {
+  const anthropicPattern = /\{\s*"type"\s*:\s*"tool_use"\s*,\s*"id"\s*:\s*"[^"]*"\s*,\s*"name"\s*:\s*"([^"]+)"\s*,\s*"input"\s*:\s*(\{[\s\S]*?\})\s*\}/gi;
+  while ((match2 = anthropicPattern.exec(text)) !== null) {
     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");
+      const args = JSON.parse(match2[2]);
+      extracted.push({
+        name: match2[1],
+        arguments: args,
+        source: "json_text"
+      });
     } 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);
+  const jsonBlockPattern = /```(?:json)?\s*(\{[\s\S]*?\})\s*```/gi;
+  while ((match2 = jsonBlockPattern.exec(text)) !== null) {
+    try {
+      const parsed = JSON.parse(match2[1]);
+      if (parsed.name && (parsed.arguments || parsed.input || parsed.parameters)) {
+        extracted.push({
+          name: parsed.name,
+          arguments: parsed.arguments || parsed.input || parsed.parameters,
+          source: "json_text"
+        });
+      }
+    } catch (e) {}
   }
-  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 });
+  return extracted;
+}
+function inferMissingParameters(toolName, args, missingParams, context) {
+  const inferred = { ...args };
+  if (toolName === "Task") {
+    if (missingParams.includes("subagent_type") && !inferred.subagent_type) {
+      inferred.subagent_type = "general-purpose";
+      log(`[ToolRecovery] Inferred subagent_type: general-purpose`);
+    }
+    let extractedTask = "";
+    if (context) {
+      const patterns = [
+        /(?:I(?:'ll| will| need to| want to| am going to)|Let me|Going to)\s+([^.!?\n]+)/i,
+        /(?:help you|assist with)\s+([^.!?\n]+)/i,
+        /(?:explore|search|find|look for|investigate)\s+([^.!?\n]+)/i,
+        /(?:implement|create|build|add|fix|update)\s+([^.!?\n]+)/i
+      ];
+      for (const pattern of patterns) {
+        const match2 = context.match(pattern);
+        if (match2 && match2[1] && match2[1].length > 10) {
+          extractedTask = match2[1].trim();
+          log(`[ToolRecovery] Extracted task from context: "${extractedTask.substring(0, 50)}..."`);
+          break;
+        }
+      }
+      if (!extractedTask && context.length > 20) {
+        const sentences = context.split(/[.!?\n]+/).filter((s) => s.trim().length > 15);
+        if (sentences.length > 0) {
+          extractedTask = sentences[sentences.length - 1].trim();
+        }
+      }
     }
-    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 (missingParams.includes("prompt") && !inferred.prompt) {
+      if (inferred.description && inferred.description !== "Execute task") {
+        inferred.prompt = inferred.description;
+      } else if (inferred.task) {
+        inferred.prompt = inferred.task;
+      } else if (extractedTask) {
+        inferred.prompt = extractedTask;
+      } else if (context && context.length > 20) {
+        inferred.prompt = context.substring(0, 500).trim();
+      }
+      if (inferred.prompt) {
+        log(`[ToolRecovery] Inferred prompt: "${inferred.prompt.substring(0, 50)}..."`);
+      }
     }
-    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 (missingParams.includes("description") && !inferred.description) {
+      if (inferred.prompt) {
+        inferred.description = inferred.prompt.substring(0, 50).replace(/\s+/g, " ").trim();
+        if (inferred.description.length < inferred.prompt.length) {
+          inferred.description += "...";
+        }
+      } else if (extractedTask) {
+        inferred.description = extractedTask.substring(0, 50).trim();
+      } else {
+        inferred.description = "Execute task";
       }
+      log(`[ToolRecovery] Inferred description: ${inferred.description}`);
     }
-    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 (toolName === "Bash") {
+    if (missingParams.includes("command") && !inferred.command) {
+      inferred.command = inferred.cmd || inferred.shell || inferred.script || "";
+    }
+    if (missingParams.includes("description") && !inferred.description) {
+      if (inferred.command) {
+        const cmd = inferred.command.split(" ")[0];
+        inferred.description = `Run ${cmd} command`;
       }
-      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) } });
-        }
+  if (toolName === "Read") {
+    if (missingParams.includes("file_path") && !inferred.file_path) {
+      inferred.file_path = inferred.path || inferred.file || inferred.filename || "";
+    }
+  }
+  if (toolName === "Write") {
+    if (missingParams.includes("file_path") && !inferred.file_path) {
+      inferred.file_path = inferred.path || inferred.file || inferred.filename || "";
+    }
+    if (missingParams.includes("content") && !inferred.content) {
+      inferred.content = inferred.text || inferred.data || inferred.body || "";
+    }
+  }
+  if (toolName === "Grep") {
+    if (missingParams.includes("pattern") && !inferred.pattern) {
+      inferred.pattern = inferred.query || inferred.search || inferred.regex || "";
+    }
+  }
+  if (toolName === "Glob") {
+    if (missingParams.includes("pattern") && !inferred.pattern) {
+      inferred.pattern = inferred.glob || inferred.path || inferred.search || "**/*";
+    }
+  }
+  return inferred;
+}
+function validateAndRepairToolCall(toolName, argsStr, toolSchemas, textContent) {
+  const schema = toolSchemas.find((t) => t.name === toolName);
+  if (!schema?.input_schema) {
+    return { valid: true, args: {}, repaired: false, missingParams: [] };
+  }
+  let parsedArgs = {};
+  try {
+    parsedArgs = argsStr ? JSON.parse(argsStr) : {};
+  } catch (e) {
+    if (textContent) {
+      const extracted = extractToolCallsFromText(textContent);
+      const matching = extracted.find((tc) => tc.name === toolName);
+      if (matching) {
+        parsedArgs = matching.arguments;
+        log(`[ToolRecovery] Extracted tool args from text for ${toolName}`);
       }
-      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.
+  const required2 = schema.input_schema.required || [];
+  const missingParams = required2.filter((param) => parsedArgs[param] === undefined || parsedArgs[param] === null || parsedArgs[param] === "");
+  if (missingParams.length === 0) {
+    return { valid: true, args: parsedArgs, repaired: false, missingParams: [] };
+  }
+  const repairedArgs = inferMissingParameters(toolName, parsedArgs, missingParams, textContent);
+  const stillMissing = required2.filter((param) => repairedArgs[param] === undefined || repairedArgs[param] === null || repairedArgs[param] === "");
+  if (stillMissing.length === 0) {
+    log(`[ToolRecovery] Successfully repaired tool call ${toolName}`);
+    return { valid: true, args: repairedArgs, repaired: true, missingParams: [] };
+  }
+  return { valid: false, args: repairedArgs, repaired: false, missingParams: stillMissing };
+}
+var init_tool_call_recovery = __esm(() => {
+  init_logger();
+});
 
-`);
+// src/handlers/shared/openai-compat.ts
+function validateToolArguments(toolName, argsStr, toolSchemas, textContent) {
+  const result = validateAndRepairToolCall(toolName, argsStr, toolSchemas, textContent);
+  if (result.repaired) {
+    log(`[ToolValidation] Repaired tool call ${toolName} - inferred missing parameters`);
   }
-  convertTools(req) {
-    return req.tools?.map((tool) => ({
-      type: "function",
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: removeUriFormat(tool.input_schema)
-      }
-    })) || [];
+  return {
+    valid: result.valid,
+    missingParams: result.missingParams,
+    parsedArgs: result.args,
+    repaired: result.repaired,
+    repairedArgs: result.repaired ? result.args : undefined
+  };
+}
+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 });
   }
-  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 += `
+  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 {
@@ -39348,16 +39186,44 @@ function processAssistantMessage(msg, messages) {
     messages.push({ role: "assistant", content: msg.content });
   }
 }
-function convertToolsToOpenAI(req) {
+function convertToolsToOpenAI(req, summarize = false) {
   return req.tools?.map((tool) => ({
     type: "function",
     function: {
       name: tool.name,
-      description: tool.description,
-      parameters: removeUriFormat(tool.input_schema)
+      description: summarize ? summarizeToolDescription(tool.name, tool.description) : tool.description,
+      parameters: summarize ? summarizeToolParameters(tool.input_schema) : removeUriFormat(tool.input_schema)
     }
   })) || [];
 }
+function summarizeToolDescription(name, description) {
+  if (!description)
+    return name;
+  let clean = description.replace(/```[\s\S]*?```/g, "").replace(/<[^>]+>/g, "").replace(/\n+/g, " ").replace(/\s+/g, " ").trim();
+  const firstSentence = clean.match(/^[^.!?]+[.!?]/)?.[0] || clean;
+  if (firstSentence.length > 150) {
+    return firstSentence.slice(0, 147) + "...";
+  }
+  return firstSentence;
+}
+function summarizeToolParameters(schema) {
+  if (!schema)
+    return schema;
+  const summarized = removeUriFormat({ ...schema });
+  if (summarized.properties) {
+    for (const [key, prop] of Object.entries(summarized.properties)) {
+      const p = prop;
+      if (p.description && p.description.length > 80) {
+        const firstSentence = p.description.match(/^[^.!?]+[.!?]/)?.[0] || p.description;
+        p.description = firstSentence.length > 80 ? firstSentence.slice(0, 77) + "..." : firstSentence;
+      }
+      if (p.enum && Array.isArray(p.enum) && p.enum.length > 5) {
+        p.enum = p.enum.slice(0, 5);
+      }
+    }
+  }
+  return summarized;
+}
 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, `
 
@@ -39376,10 +39242,12 @@ function createStreamingState() {
     curIdx: 0,
     tools: new Map,
     toolIds: new Set,
-    lastActivity: Date.now()
+    lastActivity: Date.now(),
+    accumulatedText: ""
   };
 }
-function createStreamingResponseHandler(c, response, adapter, target, middlewareManager, onTokenUpdate) {
+function createStreamingResponseHandler(c, response, adapter, target, middlewareManager, onTokenUpdate, toolSchemas) {
+  log(`[Streaming] ===== HANDLER STARTED for ${target} =====`);
   let isClosed = false;
   let ping = null;
   const encoder = new TextEncoder;
@@ -39420,6 +39288,34 @@ data: ${JSON.stringify(d)}
         if (state.finalized)
           return;
         state.finalized = true;
+        if (state.accumulatedText.length > 0) {
+          const preview = state.accumulatedText.slice(0, 500).replace(/\n/g, "\\n");
+          log(`[Streaming] Accumulated text (${state.accumulatedText.length} chars): ${preview}...`);
+        }
+        const textToolCalls = extractToolCallsFromText(state.accumulatedText);
+        log(`[Streaming] Text-based tool calls found: ${textToolCalls.length}`);
+        if (textToolCalls.length > 0) {
+          log(`[Streaming] Found ${textToolCalls.length} text-based tool call(s), converting to structured format`);
+          if (state.textStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
+            state.textStarted = false;
+          }
+          for (const tc of textToolCalls) {
+            const toolIdx = state.curIdx++;
+            const toolId = `tool_${Date.now()}_${toolIdx}`;
+            send("content_block_start", {
+              type: "content_block_start",
+              index: toolIdx,
+              content_block: { type: "tool_use", id: toolId, name: tc.name }
+            });
+            send("content_block_delta", {
+              type: "content_block_delta",
+              index: toolIdx,
+              delta: { type: "input_json_delta", partial_json: JSON.stringify(tc.arguments) }
+            });
+            send("content_block_stop", { type: "content_block_stop", index: toolIdx });
+          }
+        }
         if (state.reasoningStarted) {
           send("content_block_stop", { type: "content_block_stop", index: state.reasoningIdx });
         }
@@ -39431,159 +39327,670 @@ 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 {
+          const stopReason = textToolCalls.length > 0 ? "tool_use" : "end_turn";
+          send("message_delta", {
+            type: "message_delta",
+            delta: { stop_reason: stopReason, stop_sequence: null },
+            usage: { output_tokens: state.usage?.completion_tokens || 0 }
+          });
+          send("message_stop", { type: "message_stop" });
+        }
+        if (onTokenUpdate) {
+          if (state.usage) {
+            log(`[Streaming] Final usage: prompt=${state.usage.prompt_tokens || 0}, completion=${state.usage.completion_tokens || 0}`);
+            onTokenUpdate(state.usage.prompt_tokens || 0, state.usage.completion_tokens || 0);
+          } else {
+            const estimatedOutputTokens = Math.ceil(state.accumulatedText.length / 4);
+            log(`[Streaming] No usage data from provider, estimating: ~${estimatedOutputTokens} output tokens`);
+            onTokenUpdate(100, estimatedOutputTokens);
+          }
+        }
+        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;
+                log(`[Streaming] Usage data received: prompt=${chunk.usage.prompt_tokens}, completion=${chunk.usage.completion_tokens}, total=${chunk.usage.total_tokens}`);
+              }
+              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();
+                  const res = adapter.processTextContent(txt, "");
+                  if (res.cleanedText) {
+                    state.accumulatedText += res.cleanedText;
+                    const hasToolPattern = /<function=[^>]+>/.test(state.accumulatedText);
+                    if (!hasToolPattern) {
+                      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;
+                      }
+                      send("content_block_delta", {
+                        type: "content_block_delta",
+                        index: state.textIdx,
+                        delta: { type: "text_delta", text: res.cleanedText }
+                      });
+                    }
+                  }
+                }
+                if (delta.tool_calls) {
+                  log(`[Streaming] Received ${delta.tool_calls.length} structured tool call(s) from model`);
+                  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: "",
+                          buffered: !!toolSchemas && toolSchemas.length > 0
+                        };
+                        state.tools.set(idx, t);
+                      }
+                      if (!t.started && !t.buffered) {
+                        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;
+                      if (!t.buffered) {
+                        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.closed) {
+                    if (toolSchemas && toolSchemas.length > 0) {
+                      const validation = validateToolArguments(t.name, t.arguments, toolSchemas, state.accumulatedText);
+                      if (validation.repaired && validation.repairedArgs) {
+                        log(`[Streaming] Tool call ${t.name} was repaired with inferred parameters`);
+                        const repairedJson = JSON.stringify(validation.repairedArgs);
+                        log(`[Streaming] Sending repaired tool call: ${t.name} with args: ${repairedJson}`);
+                        if (t.buffered && !t.started) {
+                          send("content_block_start", {
+                            type: "content_block_start",
+                            index: t.blockIndex,
+                            content_block: { type: "tool_use", id: t.id, name: t.name }
+                          });
+                          send("content_block_delta", {
+                            type: "content_block_delta",
+                            index: t.blockIndex,
+                            delta: { type: "input_json_delta", partial_json: repairedJson }
+                          });
+                          send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+                          t.started = true;
+                          t.closed = true;
+                          continue;
+                        }
+                        if (t.started) {
+                          send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+                          const repairedIdx = state.curIdx++;
+                          const repairedId = `tool_repaired_${Date.now()}_${repairedIdx}`;
+                          send("content_block_start", {
+                            type: "content_block_start",
+                            index: repairedIdx,
+                            content_block: { type: "tool_use", id: repairedId, name: t.name }
+                          });
+                          send("content_block_delta", {
+                            type: "content_block_delta",
+                            index: repairedIdx,
+                            delta: { type: "input_json_delta", partial_json: repairedJson }
+                          });
+                          send("content_block_stop", { type: "content_block_stop", index: repairedIdx });
+                          t.closed = true;
+                          continue;
+                        }
+                      }
+                      if (!validation.valid) {
+                        log(`[Streaming] Tool call ${t.name} validation failed: ${validation.missingParams.join(", ")}`);
+                        const errorIdx = t.buffered ? t.blockIndex : state.curIdx++;
+                        const errorMsg = `
+
+⚠️ Tool call "${t.name}" failed: missing required parameters: ${validation.missingParams.join(", ")}. Local models sometimes generate incomplete tool calls. Please try again or use a model with better tool 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 });
+                        if (t.started && !t.buffered) {
+                          send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+                        }
+                        t.closed = true;
+                        continue;
+                      }
+                      if (t.buffered && !t.started) {
+                        const argsJson = JSON.stringify(validation.parsedArgs);
+                        send("content_block_start", {
+                          type: "content_block_start",
+                          index: t.blockIndex,
+                          content_block: { type: "tool_use", id: t.id, name: t.name }
+                        });
+                        send("content_block_delta", {
+                          type: "content_block_delta",
+                          index: t.blockIndex,
+                          delta: { type: "input_json_delta", partial_json: argsJson }
+                        });
+                        send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+                        t.started = true;
+                        t.closed = true;
+                        continue;
+                      }
+                    }
+                    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"
+    }
+  });
+}
+var init_openai_compat = __esm(() => {
+  init_transform();
+  init_logger();
+  init_tool_call_recovery();
+});
+
+// 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
@@ -39599,18 +40006,24 @@ class LocalProviderHandler {
   port;
   healthChecked = false;
   isHealthy = false;
-  contextWindow = 8192;
+  contextWindow = 32768;
   sessionInputTokens = 0;
   sessionOutputTokens = 0;
-  constructor(provider, modelName, port) {
+  options;
+  constructor(provider, modelName, port, options = {}) {
     this.provider = provider;
     this.modelName = modelName;
     this.port = port;
+    this.options = options;
     this.adapterManager = new AdapterManager(modelName);
     this.middlewareManager = new MiddlewareManager;
     this.middlewareManager.initialize().catch((err) => {
       log(`[LocalProvider:${provider.name}] Middleware init error: ${err}`);
     });
+    this.writeTokenFile(0, 0);
+    if (options.summarizeTools) {
+      log(`[LocalProvider:${provider.name}] Tool summarization enabled`);
+    }
   }
   async checkHealth() {
     if (this.healthChecked)
@@ -39647,8 +40060,16 @@ class LocalProviderHandler {
     return false;
   }
   async fetchContextWindow() {
-    if (this.provider.name !== "ollama")
-      return;
+    log(`[LocalProvider:${this.provider.name}] Fetching context window...`);
+    if (this.provider.name === "ollama") {
+      await this.fetchOllamaContextWindow();
+    } else if (this.provider.name === "lmstudio") {
+      await this.fetchLMStudioContextWindow();
+    } else {
+      log(`[LocalProvider:${this.provider.name}] No context window fetch for this provider, using default: ${this.contextWindow}`);
+    }
+  }
+  async fetchOllamaContextWindow() {
     try {
       const response = await fetch(`${this.provider.baseUrl}/api/show`, {
         method: "POST",
@@ -39658,32 +40079,72 @@ class LocalProviderHandler {
       });
       if (response.ok) {
         const data = await response.json();
-        const ctxFromInfo = data.model_info?.["general.context_length"];
+        let ctxFromInfo = data.model_info?.["general.context_length"];
+        if (!ctxFromInfo && data.model_info) {
+          for (const key of Object.keys(data.model_info)) {
+            if (key.endsWith(".context_length")) {
+              ctxFromInfo = data.model_info[key];
+              break;
+            }
+          }
+        }
         const ctxFromParams = data.parameters?.match(/num_ctx\s+(\d+)/)?.[1];
         if (ctxFromInfo) {
-          this.contextWindow = parseInt(ctxFromInfo, 10);
+          this.contextWindow = parseInt(String(ctxFromInfo), 10);
         } else if (ctxFromParams) {
           this.contextWindow = parseInt(ctxFromParams, 10);
         } else {
-          this.contextWindow = 8192;
+          log(`[LocalProvider:${this.provider.name}] No context info found, using default: ${this.contextWindow}`);
+        }
+        if (ctxFromInfo || ctxFromParams) {
+          log(`[LocalProvider:${this.provider.name}] Context window: ${this.contextWindow}`);
         }
-        log(`[LocalProvider:${this.provider.name}] Context window: ${this.contextWindow}`);
       }
     } catch (e) {}
   }
+  async fetchLMStudioContextWindow() {
+    try {
+      const response = await fetch(`${this.provider.baseUrl}/v1/models`, {
+        method: "GET",
+        signal: AbortSignal.timeout(3000)
+      });
+      if (response.ok) {
+        const data = await response.json();
+        log(`[LocalProvider:lmstudio] Models response: ${JSON.stringify(data).slice(0, 500)}`);
+        const models = data.data || [];
+        const targetModel = models.find((m) => m.id === this.modelName) || models.find((m) => m.id?.endsWith(`/${this.modelName}`)) || models.find((m) => this.modelName.includes(m.id));
+        if (targetModel) {
+          const ctxLength = targetModel.context_length || targetModel.max_context_length || targetModel.context_window || targetModel.max_tokens;
+          if (ctxLength && typeof ctxLength === "number") {
+            this.contextWindow = ctxLength;
+            log(`[LocalProvider:lmstudio] Context window from model: ${this.contextWindow}`);
+            return;
+          }
+        }
+        this.contextWindow = 32768;
+        log(`[LocalProvider:lmstudio] Using default context window: ${this.contextWindow}`);
+      }
+    } catch (e) {
+      this.contextWindow = 32768;
+      log(`[LocalProvider:lmstudio] Failed to fetch model info: ${e?.message || e}. Using default: ${this.contextWindow}`);
+    }
+  }
   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 sessionTotal = this.sessionInputTokens + this.sessionOutputTokens;
+      const used = input + output;
+      const leftPct = this.contextWindow > 0 ? Math.max(0, Math.min(100, Math.round((this.contextWindow - used) / this.contextWindow * 100))) : 100;
       const data = {
         input_tokens: this.sessionInputTokens,
         output_tokens: this.sessionOutputTokens,
-        total_tokens: total,
+        total_tokens: sessionTotal,
         total_cost: 0,
         context_window: this.contextWindow,
         context_left_percent: leftPct,
+        last_request_input: input,
+        last_request_output: output,
         updated_at: Date.now()
       };
       writeFileSync9(join9(tmpdir3(), `claudish-tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
@@ -39706,11 +40167,66 @@ class LocalProviderHandler {
     }
     const { claudeRequest, droppedParams } = transformOpenAIToClaude(payload);
     const messages = convertMessagesToOpenAI(claudeRequest, target, filterIdentity);
-    const tools = convertToolsToOpenAI(claudeRequest);
+    const tools = convertToolsToOpenAI(claudeRequest, this.options.summarizeTools);
     const finalTools = this.provider.capabilities.supportsTools ? tools : [];
     if (tools.length > 0 && !this.provider.capabilities.supportsTools) {
       log(`[LocalProvider:${this.provider.name}] Tools stripped (not supported)`);
     }
+    if (tools.length > 0 && this.options.summarizeTools) {
+      log(`[LocalProvider:${this.provider.name}] Tools summarized (${tools.length} tools)`);
+    }
+    if (messages.length > 0 && messages[0].role === "system") {
+      let guidance = `
+
+IMPORTANT INSTRUCTIONS FOR THIS MODEL:
+
+1. OUTPUT BEHAVIOR:
+- NEVER output your internal reasoning, thinking process, or chain-of-thought as visible text.
+- Only output your final response, actions, or tool calls.
+- Do NOT ramble or speculate about what the user might want.
+
+2. CONVERSATION HANDLING:
+- Always look back at the ORIGINAL user request in the conversation history.
+- When you receive results from a Task/agent you called, SYNTHESIZE those results and continue fulfilling the user's original request.
+- Do NOT ask "What would you like help with?" if there's already a user request in the conversation.
+- Only ask for clarification if the FIRST user message in the conversation is unclear.
+- After calling tools or agents, continue with the next step - don't restart or ask what to do.
+
+3. CRITICAL - AFTER TOOL RESULTS:
+- When you see tool results (like file lists, search results, or command output), ALWAYS continue working.
+- Analyze the results and take the next action toward completing the user's request.
+- If the user asked for "evaluation and suggestions", you MUST provide analysis and recommendations after seeing the data.
+- NEVER stop after just calling one tool - continue until you've fully addressed the user's request.
+- If you called a Glob/Search and got files, READ important files next, then ANALYZE, then SUGGEST improvements.`;
+      if (finalTools.length > 0) {
+        const isQwen = target.toLowerCase().includes("qwen");
+        if (isQwen) {
+          guidance += `
+
+4. TOOL CALLING FORMAT (CRITICAL FOR QWEN):
+You MUST use proper OpenAI-style function calling. Do NOT output tool calls as XML text.
+When you want to call a tool, use the API's tool_calls mechanism, NOT text like <function=...>.
+The tool calls must be structured JSON in the API response, not XML in your text output.
+
+If you cannot use structured tool_calls, format as JSON:
+{"name": "tool_name", "arguments": {"param1": "value1", "param2": "value2"}}
+
+5. TOOL PARAMETER REQUIREMENTS:`;
+        } else {
+          guidance += `
+
+4. TOOL CALLING REQUIREMENTS:`;
+        }
+        guidance += `
+- When calling tools, you MUST include ALL required parameters. Incomplete tool calls will fail.
+- For Task: always include "description" (3-5 words), "prompt" (detailed instructions), and "subagent_type"
+- For Bash: always include "command" and "description"
+- For Read/Write/Edit: always include the full "file_path"
+- For Grep/Glob: always include "pattern"
+- Ensure your tool call JSON is complete with all required fields before submitting.`;
+      }
+      messages[0].content += guidance;
+    }
     const openAIPayload = {
       model: target,
       messages,
@@ -39720,6 +40236,11 @@ class LocalProviderHandler {
       tools: finalTools.length > 0 ? finalTools : undefined,
       stream_options: this.provider.capabilities.supportsStreaming ? { include_usage: true } : undefined
     };
+    if (this.provider.name === "ollama") {
+      const numCtx = Math.max(this.contextWindow, 32768);
+      openAIPayload.options = { num_ctx: numCtx };
+      log(`[LocalProvider:${this.provider.name}] Setting num_ctx: ${numCtx} (detected: ${this.contextWindow})`);
+    }
     if (claudeRequest.tool_choice && finalTools.length > 0) {
       const { type, name } = claudeRequest.tool_choice;
       if (type === "tool" && name) {
@@ -39739,6 +40260,12 @@ class LocalProviderHandler {
       stream: openAIPayload.stream
     });
     const apiUrl = `${this.provider.baseUrl}${this.provider.apiPath}`;
+    log(`[LocalProvider:${this.provider.name}] Tools: ${openAIPayload.tools?.length || 0}, Messages: ${messages.length}`);
+    if (openAIPayload.tools?.length > 0) {
+      log(`[LocalProvider:${this.provider.name}] First tool: ${openAIPayload.tools[0]?.function?.name || "unknown"}`);
+    }
+    console.log(`[LocalProvider:${this.provider.name}] ===== ABOUT TO FETCH from ${apiUrl} =====`);
+    log(`[LocalProvider:${this.provider.name}] ===== ABOUT TO FETCH from ${apiUrl} =====`);
     try {
       const response = await fetch(apiUrl, {
         method: "POST",
@@ -39747,15 +40274,20 @@ class LocalProviderHandler {
         },
         body: JSON.stringify(openAIPayload)
       });
+      log(`[LocalProvider:${this.provider.name}] ===== FETCH COMPLETED, status: ${response.status} =====`);
       if (!response.ok) {
         const errorBody = await response.text();
+        log(`[LocalProvider:${this.provider.name}] ERROR: ${errorBody.slice(0, 200)}`);
         return this.handleErrorResponse(c, response.status, errorBody);
       }
+      log(`[LocalProvider:${this.provider.name}] Response OK, proceeding to streaming...`);
       if (droppedParams.length > 0) {
         c.header("X-Dropped-Params", droppedParams.join(", "));
       }
+      log(`[LocalProvider:${this.provider.name}] Streaming: ${openAIPayload.stream}`);
       if (openAIPayload.stream) {
-        return createStreamingResponseHandler(c, response, adapter, target, this.middlewareManager, (input, output) => this.writeTokenFile(input, output));
+        log(`[LocalProvider:${this.provider.name}] ===== ENTERING STREAMING HANDLER =====`);
+        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);
@@ -39922,7 +40454,7 @@ var exports_proxy_server = {};
 __export(exports_proxy_server, {
   createProxyServer: () => createProxyServer
 });
-async function createProxyServer(port, openrouterApiKey, model, monitorMode = false, anthropicApiKey, modelMap) {
+async function createProxyServer(port, openrouterApiKey, model, monitorMode = false, anthropicApiKey, modelMap, options = {}) {
   const nativeHandler = new NativeHandler(anthropicApiKey);
   const openRouterHandlers = new Map;
   const localProviderHandlers = new Map;
@@ -39932,13 +40464,16 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     }
     return openRouterHandlers.get(targetModel);
   };
+  const localProviderOptions = {
+    summarizeTools: options.summarizeTools
+  };
   const getLocalProviderHandler = (targetModel) => {
     if (localProviderHandlers.has(targetModel)) {
       return localProviderHandlers.get(targetModel);
     }
     const resolved = resolveProvider(targetModel);
     if (resolved) {
-      const handler = new LocalProviderHandler(resolved.provider, resolved.modelName, port);
+      const handler = new LocalProviderHandler(resolved.provider, resolved.modelName, port, localProviderOptions);
       localProviderHandlers.set(targetModel, handler);
       log(`[Proxy] Created local provider handler: ${resolved.provider.name}/${resolved.modelName}`);
       return handler;
@@ -39946,7 +40481,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     const urlParsed = parseUrlModel(targetModel);
     if (urlParsed) {
       const provider = createUrlProvider(urlParsed);
-      const handler = new LocalProviderHandler(provider, urlParsed.modelName, port);
+      const handler = new LocalProviderHandler(provider, urlParsed.modelName, port, localProviderOptions);
       localProviderHandlers.set(targetModel, handler);
       log(`[Proxy] Created URL-based local provider handler: ${urlParsed.baseUrl}/${urlParsed.modelName}`);
       return handler;
@@ -40053,7 +40588,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,12 +40754,13 @@ 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;
 });
 
 // src/index.ts
 var import_dotenv2 = __toESM(require_main(), 1);
+console.log("===== CLAUDISH FRESH START - CODE UPDATED =====");
 import_dotenv2.config();
 var isMcpMode = process.argv.includes("--mcp");
 var args = process.argv.slice(2);
@@ -40303,6 +40839,8 @@ async function runCli() {
       sonnet: cliConfig.modelSonnet,
       haiku: cliConfig.modelHaiku,
       subagent: cliConfig.modelSubagent
+    }, {
+      summarizeTools: cliConfig.summarizeTools
     });
     let exitCode = 0;
     try {