claudish 7.26.0 → 7.27.0

package/dist/index.js

@@ -651,7 +651,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.26.0";
+var VERSION = "7.27.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -35364,7 +35364,21 @@ function createStreamingState() {
     accumulatedText: ""
   };
 }
-function createStreamingResponseHandler(c, response, adapter, target, middlewareManager, onTokenUpdate, toolSchemas, toolNameMap, priorInputTokens) {
+function createStreamingResponseHandler(c, response, adapter, target, middlewareManager, onTokenUpdate, toolSchemas, toolNameMap, priorInputTokens, behavior) {
+  const repairArgs = (toolName, argsJson) => {
+    if (!behavior?.onToolCall)
+      return argsJson;
+    try {
+      const repaired = behavior.onToolCall(toolName, argsJson);
+      if (typeof repaired === "string" && repaired !== argsJson) {
+        log(`[Streaming] tool call repaired by behavior layer: ${toolName}`);
+        return repaired;
+      }
+    } catch (err) {
+      log(`[Streaming] behavior onToolCall threw for ${toolName}: ${err}`);
+    }
+    return argsJson;
+  };
   log(`[Streaming] ===== HANDLER STARTED for ${target} =====`);
   let isClosed = false;
   let ping = null;
@@ -35429,7 +35443,10 @@ data: ${JSON.stringify(d)}
             send("content_block_delta", {
               type: "content_block_delta",
               index: toolIdx,
-              delta: { type: "input_json_delta", partial_json: JSON.stringify(tc.arguments) }
+              delta: {
+                type: "input_json_delta",
+                partial_json: repairArgs(tc.name, JSON.stringify(tc.arguments))
+              }
             });
             send("content_block_stop", { type: "content_block_stop", index: toolIdx });
           }
@@ -35445,7 +35462,7 @@ data: ${JSON.stringify(d)}
             if (toolSchemas && toolSchemas.length > 0) {
               const validation = validateToolArguments(t.name, t.arguments, toolSchemas, state.accumulatedText);
               if (validation.valid || validation.repaired && validation.repairedArgs) {
-                const argsJson = JSON.stringify(validation.repaired ? validation.repairedArgs : validation.parsedArgs);
+                const argsJson = repairArgs(t.name, JSON.stringify(validation.repaired ? validation.repairedArgs : validation.parsedArgs));
                 log(`[Streaming] Sending buffered tool call (finish_reason!=tool_calls): ${t.name} with args: ${argsJson}`);
                 send("content_block_start", {
                   type: "content_block_start",
@@ -35468,7 +35485,7 @@ data: ${JSON.stringify(d)}
                 t.closed = true;
               }
             } else {
-              const argsJson = t.arguments || "{}";
+              const argsJson = repairArgs(t.name, t.arguments || "{}");
               log(`[Streaming] Sending buffered tool call (no validation): ${t.name} with args: ${argsJson}`);
               send("content_block_start", {
                 type: "content_block_start",
@@ -35665,7 +35682,7 @@ data: ${JSON.stringify(d)}
                           started: false,
                           closed: false,
                           arguments: "",
-                          buffered: !!toolSchemas && toolSchemas.length > 0
+                          buffered: !!toolSchemas && toolSchemas.length > 0 || behavior?.shouldBufferTool?.(restoredName) === true
                         };
                         state.tools.set(idx, t);
                         if (isWebSearchToolCall(restoredName)) {
@@ -35704,7 +35721,7 @@ data: ${JSON.stringify(d)}
                       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);
+                        const repairedJson = repairArgs(t.name, JSON.stringify(validation.repairedArgs));
                         log(`[Streaming] Sending repaired tool call: ${t.name} with args: ${repairedJson}`);
                         if (t.buffered && !t.started) {
                           send("content_block_start", {
@@ -35780,7 +35797,7 @@ data: ${JSON.stringify(d)}
                         continue;
                       }
                       if (t.buffered && !t.started) {
-                        const argsJson = JSON.stringify(validation.parsedArgs);
+                        const argsJson = repairArgs(t.name, JSON.stringify(validation.parsedArgs));
                         send("content_block_start", {
                           type: "content_block_start",
                           index: t.blockIndex,
@@ -39448,6 +39465,70 @@ var init_stream_head_sniffer = __esm(() => {
 });
 
 // src/handlers/shared/stream-parsers/anthropic-sse.ts
+function createToolRepairInterceptor(opts) {
+  const heldTools = new Map;
+  const flush = (index, stopFrame) => {
+    const held = heldTools.get(index);
+    if (!held)
+      return stopFrame;
+    heldTools.delete(index);
+    let finalArgs = held.args;
+    try {
+      const repaired = opts.repairToolArgs?.(held.name, finalArgs);
+      if (typeof repaired === "string" && repaired !== finalArgs) {
+        log(`[AnthropicSSE] tool call repaired: ${held.name}`);
+        finalArgs = repaired;
+      }
+    } catch (err) {
+      log(`[AnthropicSSE] repairToolArgs threw for ${held.name}: ${err}`);
+    }
+    const deltaFrame = `event: content_block_delta
+data: ${JSON.stringify({
+      type: "content_block_delta",
+      index,
+      delta: { type: "input_json_delta", partial_json: finalArgs }
+    })}
+
+`;
+    return `${deltaFrame}${stopFrame}`;
+  };
+  const noteToolStart = (data) => {
+    if (data.content_block?.type !== "tool_use")
+      return;
+    const name = data.content_block.name;
+    if (typeof name !== "string")
+      return;
+    if (!opts.shouldBufferTool?.(name))
+      return;
+    heldTools.set(data.index, { name, args: "" });
+  };
+  const absorbFragment = (data) => {
+    if (data.delta?.type !== "input_json_delta")
+      return false;
+    const held = heldTools.get(data.index);
+    if (!held)
+      return false;
+    held.args += data.delta.partial_json ?? "";
+    return true;
+  };
+  return (data, line) => {
+    const asIs = `${line}
+`;
+    if (!opts.repairToolArgs || !opts.shouldBufferTool)
+      return asIs;
+    switch (data?.type) {
+      case "content_block_start":
+        noteToolStart(data);
+        return asIs;
+      case "content_block_delta":
+        return absorbFragment(data) ? null : asIs;
+      case "content_block_stop":
+        return heldTools.has(data.index) ? flush(data.index, asIs) : asIs;
+      default:
+        return asIs;
+    }
+  };
+}
 function createAnthropicPassthroughStream(c, response, opts) {
   const encoder = new TextEncoder;
   const decoder = new TextDecoder;
@@ -39455,6 +39536,14 @@ function createAnthropicPassthroughStream(c, response, opts) {
   let lastActivity = Date.now();
   let pingInterval = null;
   const filterThinking = opts.adapter?.shouldFilterThinking() ?? false;
+  const interceptToolFrame = createToolRepairInterceptor(opts);
+  const enqueueData = (controller, data, line) => {
+    if (isClosed)
+      return;
+    const out = interceptToolFrame(data, line);
+    if (out !== null)
+      controller.enqueue(encoder.encode(out));
+  };
   return c.body(new ReadableStream({
     async start(controller) {
       const sendPing = () => {
@@ -39537,10 +39626,7 @@ data: ${JSON.stringify({
 `));
                   }
                 } else {
-                  if (!isClosed) {
-                    controller.enqueue(encoder.encode(`${line}
-`));
-                  }
+                  enqueueData(controller, data, line);
                 }
               } catch {
                 if (!isClosed) {
@@ -39572,10 +39658,7 @@ data: ${JSON.stringify({
                     }
                     return;
                   }
-                  if (!isClosed) {
-                    controller.enqueue(encoder.encode(`${line}
-`));
-                  }
+                  enqueueData(controller, data, line);
                   if (data.message?.usage) {
                     inputTokens = data.message.usage.input_tokens || inputTokens;
                     outputTokens = data.message.usage.output_tokens || outputTokens;
@@ -39870,7 +39953,18 @@ data: ${JSON.stringify(data)}
                     const toolIdx = toolCalls.size;
                     const toolId = `toolu_${Date.now()}_${toolIdx}`;
                     const blockIndex = curIdx++;
-                    const args = JSON.stringify(part.functionCall.args || {});
+                    let args = JSON.stringify(part.functionCall.args || {});
+                    if (opts.repairToolArgs) {
+                      try {
+                        const repaired = opts.repairToolArgs(part.functionCall.name, args);
+                        if (typeof repaired === "string" && repaired !== args) {
+                          log(`[GeminiSSE] tool call repaired: ${part.functionCall.name}`);
+                          args = repaired;
+                        }
+                      } catch (err) {
+                        log(`[GeminiSSE] repairToolArgs threw for ${part.functionCall.name}: ${err}`);
+                      }
+                    }
                     const t = {
                       id: toolId,
                       name: part.functionCall.name,
@@ -41203,7 +41297,10 @@ class ComposedHandler {
     const priorInputTokens = this.tokenTracker.getLastInputTokens();
     switch (streamFormat) {
       case "openai-sse":
-        return createStreamingResponseHandler(c, response, adapter, this.bareModelName, this.middlewareManager, onTokenUpdate, claudeRequest.tools, toolNameMap, priorInputTokens);
+        return createStreamingResponseHandler(c, response, adapter, this.bareModelName, this.middlewareManager, onTokenUpdate, claudeRequest.tools, toolNameMap, priorInputTokens, behaviorSession && {
+          shouldBufferTool: (name) => behaviorSession.interceptsTool(name),
+          onToolCall: (name, argsJson) => behaviorSession.repairToolCall(name, argsJson)
+        });
       case "openai-responses-sse":
         return createResponsesStreamHandler(c, response, {
           modelName: this.bareModelName,
@@ -41220,7 +41317,9 @@ class ComposedHandler {
         return createAnthropicPassthroughStream(c, response, {
           modelName: this.bareModelName,
           onTokenUpdate,
-          adapter
+          adapter,
+          shouldBufferTool: (name) => behaviorSession?.interceptsTool(name) ?? false,
+          repairToolArgs: (name, argsJson) => behaviorSession?.repairToolCall(name, argsJson) ?? null
         });
       case "gemini-sse": {
         const onToolCall = (toolId, name, thoughtSignature) => {
@@ -41234,6 +41333,7 @@ class ComposedHandler {
           middlewareManager: this.middlewareManager,
           onTokenUpdate,
           onToolCall,
+          repairToolArgs: (name, argsJson) => behaviorSession?.repairToolCall(name, argsJson) ?? null,
           unwrapResponse: this.options.unwrapGeminiResponse,
           priorInputTokens
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "7.26.0",
+  "version": "7.27.0",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,10 +60,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "7.26.0",
-    "@claudish/magmux-darwin-x64": "7.26.0",
-    "@claudish/magmux-linux-arm64": "7.26.0",
-    "@claudish/magmux-linux-x64": "7.26.0"
+    "@claudish/magmux-darwin-arm64": "7.27.0",
+    "@claudish/magmux-darwin-x64": "7.27.0",
+    "@claudish/magmux-linux-arm64": "7.27.0",
+    "@claudish/magmux-linux-x64": "7.27.0"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",