claudish 2.10.1 → 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",
@@ -34743,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];
@@ -34859,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;
@@ -38867,26 +38874,222 @@ function transformOpenAIToClaude(claudeRequestInput) {
 }
 var init_transform = () => {};
 
-// src/handlers/shared/openai-compat.ts
-function validateToolArguments(toolName, argsStr, toolSchemas) {
-  const schema = toolSchemas?.find((t) => t.name === toolName);
+// 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}`);
+    }
+  }
+  const xmlPattern = /<tool_call>\s*(\{[\s\S]*?\})\s*<\/tool_call>/gi;
+  while ((match2 = xmlPattern.exec(text)) !== null) {
+    try {
+      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) {}
+  }
+  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) {}
+  }
+  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 args = JSON.parse(match2[2]);
+      extracted.push({
+        name: match2[1],
+        arguments: args,
+        source: "json_text"
+      });
+    } catch (e) {}
+  }
+  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) {}
+  }
+  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 (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 (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}`);
+    }
+  }
+  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 (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, missingParams: [], parsedArgs: {} };
+    return { valid: true, args: {}, repaired: false, missingParams: [] };
   }
   let parsedArgs = {};
   try {
     parsedArgs = argsStr ? JSON.parse(argsStr) : {};
   } catch (e) {
-    return { valid: true, missingParams: [], parsedArgs: {} };
+    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 required2 = schema.input_schema.required || [];
-  const missingParams = required2.filter((param) => {
-    return parsedArgs[param] === undefined || parsedArgs[param] === null || parsedArgs[param] === "";
-  });
+  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`);
+  }
   return {
-    valid: missingParams.length === 0,
-    missingParams,
-    parsedArgs
+    valid: result.valid,
+    missingParams: result.missingParams,
+    parsedArgs: result.args,
+    repaired: result.repaired,
+    repairedArgs: result.repaired ? result.args : undefined
   };
 }
 function convertMessagesToOpenAI(req, modelId, filterIdentityFn) {
@@ -38983,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, `
 
@@ -39011,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, toolSchemas) {
+  log(`[Streaming] ===== HANDLER STARTED for ${target} =====`);
   let isClosed = false;
   let ping = null;
   const encoder = new TextEncoder;
@@ -39055,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 });
         }
@@ -39073,15 +39334,23 @@ data: ${JSON.stringify(d)}
         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: "end_turn", stop_sequence: null },
+            delta: { stop_reason: stopReason, 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 (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 {
@@ -39117,8 +39386,10 @@ data: ${JSON.stringify(d)}
             }
             try {
               const chunk = JSON.parse(dataStr);
-              if (chunk.usage)
+              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) {
@@ -39132,25 +39403,30 @@ data: ${JSON.stringify(d)}
                 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 }
-                    });
+                    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);
@@ -39166,11 +39442,12 @@ data: ${JSON.stringify(d)}
                           blockIndex: state.curIdx++,
                           started: false,
                           closed: false,
-                          arguments: ""
+                          arguments: "",
+                          buffered: !!toolSchemas && toolSchemas.length > 0
                         };
                         state.tools.set(idx, t);
                       }
-                      if (!t.started) {
+                      if (!t.started && !t.buffered) {
                         send("content_block_start", {
                           type: "content_block_start",
                           index: t.blockIndex,
@@ -39181,25 +39458,67 @@ data: ${JSON.stringify(d)}
                     }
                     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 (!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.started && !t.closed) {
+                  if (!t.closed) {
                     if (toolSchemas && toolSchemas.length > 0) {
-                      const validation = validateToolArguments(t.name, t.arguments, toolSchemas);
+                      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) {
-                        const errorIdx = state.curIdx++;
+                        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 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.`;
+⚠️ 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,
@@ -39211,12 +39530,34 @@ data: ${JSON.stringify(d)}
                           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;
                       }
                     }
-                    send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
-                    t.closed = true;
+                    if (t.started && !t.closed) {
+                      send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+                      t.closed = true;
+                    }
                   }
                 }
               }
@@ -39243,6 +39584,8 @@ data: ${JSON.stringify(d)}
 }
 var init_openai_compat = __esm(() => {
   init_transform();
+  init_logger();
+  init_tool_call_recovery();
 });
 
 // src/handlers/openrouter-handler.ts
@@ -39663,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)
@@ -39711,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",
@@ -39722,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");
@@ -39770,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,
@@ -39784,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) {
@@ -39803,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",
@@ -39811,14 +40274,19 @@ 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) {
+        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();
@@ -39986,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;
@@ -39996,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;
@@ -40010,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;
@@ -40289,6 +40760,7 @@ var init_update_checker = __esm(() => {
 
 // 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);
@@ -40367,6 +40839,8 @@ async function runCli() {
       sonnet: cliConfig.modelSonnet,
       haiku: cliConfig.modelHaiku,
       subagent: cliConfig.modelSubagent
+    }, {
+      summarizeTools: cliConfig.summarizeTools
     });
     let exitCode = 0;
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "2.10.1",
+  "version": "2.11.0",
   "description": "Run Claude Code with any OpenRouter model - CLI tool and MCP server",
   "type": "module",
   "main": "./dist/index.js",