claudish 7.12.3 → 7.12.5

package/dist/index.js

@@ -581,7 +581,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.12.3";
+var VERSION = "7.12.5";
 
 // src/logger.ts
 var exports_logger = {};
@@ -30918,11 +30918,18 @@ ${msg}`;
   }
   return messages;
 }
+function imageBlockToUrlPart(block) {
+  return {
+    type: "image_url",
+    image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
+  };
+}
 function processUserMessage(msg, messages, simpleFormat = false) {
   if (Array.isArray(msg.content)) {
     const textParts = [];
     const contentParts = [];
     const toolResults = [];
+    const toolResultImages = [];
     const seen = new Set;
     for (const block of msg.content) {
       if (block.type === "text") {
@@ -30932,22 +30939,45 @@ function processUserMessage(msg, messages, simpleFormat = false) {
         }
       } else if (block.type === "image") {
         if (!simpleFormat) {
-          contentParts.push({
-            type: "image_url",
-            image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
-          });
+          contentParts.push(imageBlockToUrlPart(block));
         }
       } else if (block.type === "tool_result") {
         if (seen.has(block.tool_use_id))
           continue;
         seen.add(block.tool_use_id);
-        const resultContent = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+        let resultText;
+        if (typeof block.content === "string") {
+          resultText = block.content;
+        } else if (Array.isArray(block.content)) {
+          const texts = [];
+          const others = [];
+          for (const inner of block.content) {
+            if (inner.type === "text") {
+              texts.push(inner.text);
+            } else if (inner.type === "image" && inner.source) {
+              if (!simpleFormat)
+                toolResultImages.push(imageBlockToUrlPart(inner));
+            } else {
+              others.push(inner);
+            }
+          }
+          resultText = texts.join(`
+`);
+          if (others.length)
+            resultText += (resultText ? `
+` : "") + JSON.stringify(others);
+          if (!resultText) {
+            resultText = toolResultImages.length ? "[image returned; see following message]" : "";
+          }
+        } else {
+          resultText = JSON.stringify(block.content);
+        }
         if (simpleFormat) {
-          textParts.push(`[Tool Result]: ${resultContent}`);
+          textParts.push(`[Tool Result]: ${resultText}`);
         } else {
           toolResults.push({
             role: "tool",
-            content: resultContent,
+            content: resultText,
             tool_call_id: block.tool_use_id
           });
         }
@@ -30962,6 +30992,8 @@ function processUserMessage(msg, messages, simpleFormat = false) {
     } else {
       if (toolResults.length)
         messages.push(...toolResults);
+      if (toolResultImages.length)
+        messages.push({ role: "user", content: toolResultImages });
       if (contentParts.length)
         messages.push({ role: "user", content: contentParts });
     }
@@ -38113,15 +38145,18 @@ function createResponsesStreamHandler(c, response, opts) {
   const encoder = new TextEncoder;
   const decoder = new TextDecoder;
   let buffer = "";
-  let blockIndex = 0;
+  let curIdx = 0;
+  let textIdx = -1;
+  let reasoningIdx = -1;
+  let lastSummaryIndex = -1;
   let inputTokens = 0;
   let outputTokens = 0;
-  let hasTextContent = false;
   let hasToolUse = false;
   let lastActivity = Date.now();
   let pingInterval = null;
   let isClosed = false;
   const functionCalls = new Map;
+  const openToolBlocks = new Set;
   const stream = new ReadableStream({
     start: async (controller) => {
       const send = (event, data) => {
@@ -38132,6 +38167,24 @@ data: ${JSON.stringify(data)}
 `));
         }
       };
+      const closeReasoning = () => {
+        if (reasoningIdx >= 0) {
+          send("content_block_stop", { type: "content_block_stop", index: reasoningIdx });
+          reasoningIdx = -1;
+        }
+      };
+      const closeText = () => {
+        if (textIdx >= 0) {
+          send("content_block_stop", { type: "content_block_stop", index: textIdx });
+          textIdx = -1;
+        }
+      };
+      const closeTools = () => {
+        for (const fnCall of openToolBlocks) {
+          send("content_block_stop", { type: "content_block_stop", index: fnCall.index });
+        }
+        openToolBlocks.clear();
+      };
       send("message_start", {
         type: "message_start",
         message: {
@@ -38169,23 +38222,27 @@ data: ${JSON.stringify(data)}
             const data = line.slice(6);
             if (data === "[DONE]")
               continue;
+            if (getLogLevel() === "debug") {
+              log(`[SSE:responses] ${data.substring(0, 300)}`);
+            }
             try {
               const event = JSON.parse(data);
               if (getLogLevel() === "debug" && event.type) {
                 log(`[ResponsesSSE] Event: ${event.type}`);
               }
               if (event.type === "response.output_text.delta") {
-                if (!hasTextContent) {
+                closeReasoning();
+                if (textIdx < 0) {
+                  textIdx = curIdx++;
                   send("content_block_start", {
                     type: "content_block_start",
-                    index: blockIndex,
+                    index: textIdx,
                     content_block: { type: "text", text: "" }
                   });
-                  hasTextContent = true;
                 }
                 send("content_block_delta", {
                   type: "content_block_delta",
-                  index: blockIndex,
+                  index: textIdx,
                   delta: { type: "text_delta", text: event.delta || "" }
                 });
               } else if (event.type === "response.output_item.added") {
@@ -38195,41 +38252,51 @@ data: ${JSON.stringify(data)}
                   const callId = openaiCallId.startsWith("toolu_") ? openaiCallId : `toolu_${openaiCallId.replace(/^fc_/, "")}`;
                   const rawFnName = event.item.name || "";
                   const fnName = opts.toolNameMap?.get(rawFnName) || rawFnName;
-                  const fnIndex = blockIndex + functionCalls.size + (hasTextContent ? 1 : 0);
+                  closeReasoning();
+                  closeText();
                   const fnCallData = {
                     name: fnName,
                     arguments: "",
-                    index: fnIndex,
+                    index: curIdx++,
                     claudeId: callId
                   };
                   functionCalls.set(openaiCallId, fnCallData);
                   if (itemId && itemId !== openaiCallId) {
                     functionCalls.set(itemId, fnCallData);
                   }
-                  if (hasTextContent && !hasToolUse) {
-                    send("content_block_stop", { type: "content_block_stop", index: blockIndex });
-                    blockIndex++;
-                  }
+                  openToolBlocks.add(fnCallData);
                   send("content_block_start", {
                     type: "content_block_start",
-                    index: fnIndex,
+                    index: fnCallData.index,
                     content_block: { type: "tool_use", id: callId, name: fnName, input: {} }
                   });
                   hasToolUse = true;
                 }
               } else if (event.type === "response.reasoning_summary_text.delta") {
-                if (!hasTextContent) {
+                const summaryIndex = typeof event.summary_index === "number" ? event.summary_index : 0;
+                if (reasoningIdx < 0) {
+                  closeText();
+                  reasoningIdx = curIdx++;
+                  lastSummaryIndex = summaryIndex;
                   send("content_block_start", {
                     type: "content_block_start",
-                    index: blockIndex,
-                    content_block: { type: "text", text: "" }
+                    index: reasoningIdx,
+                    content_block: { type: "thinking", thinking: "" }
+                  });
+                } else if (summaryIndex !== lastSummaryIndex) {
+                  lastSummaryIndex = summaryIndex;
+                  send("content_block_delta", {
+                    type: "content_block_delta",
+                    index: reasoningIdx,
+                    delta: { type: "thinking_delta", thinking: `
+
+` }
                   });
-                  hasTextContent = true;
                 }
                 send("content_block_delta", {
                   type: "content_block_delta",
-                  index: blockIndex,
-                  delta: { type: "text_delta", text: event.delta || "" }
+                  index: reasoningIdx,
+                  delta: { type: "thinking_delta", thinking: event.delta || "" }
                 });
               } else if (event.type === "response.function_call_arguments.delta") {
                 const callId = event.call_id || event.item_id;
@@ -38246,8 +38313,9 @@ data: ${JSON.stringify(data)}
                 if (event.item?.type === "function_call") {
                   const callId = event.item.call_id || event.item.id;
                   const fnCall = functionCalls.get(callId) || functionCalls.get(event.item.id);
-                  if (fnCall) {
+                  if (fnCall && openToolBlocks.has(fnCall)) {
                     send("content_block_stop", { type: "content_block_stop", index: fnCall.index });
+                    openToolBlocks.delete(fnCall);
                   }
                 }
               } else if (event.type === "response.incomplete") {
@@ -38269,14 +38337,10 @@ data: ${JSON.stringify(data)}
                 const errMsg = err.message || event.message || "Unknown API error";
                 const errCode = err.code || event.code || "";
                 log(`[ResponsesSSE] API error: ${errCode} - ${errMsg}`);
-                if (hasTextContent) {
-                  send("content_block_stop", { type: "content_block_stop", index: blockIndex });
-                  hasTextContent = false;
-                }
-                for (const [, fnCall] of functionCalls) {
-                  send("content_block_stop", { type: "content_block_stop", index: fnCall.index });
-                }
-                const errorIdx = blockIndex + functionCalls.size + (hasToolUse ? 1 : 0);
+                closeReasoning();
+                closeText();
+                closeTools();
+                const errorIdx = curIdx++;
                 send("content_block_start", {
                   type: "content_block_start",
                   index: errorIdx,
@@ -38315,9 +38379,9 @@ data: ${JSON.stringify(data)}
           clearInterval(pingInterval);
           pingInterval = null;
         }
-        if (hasTextContent) {
-          send("content_block_stop", { type: "content_block_stop", index: blockIndex });
-        }
+        closeReasoning();
+        closeText();
+        closeTools();
         const stopReason = hasToolUse ? "tool_use" : "end_turn";
         send("message_delta", {
           type: "message_delta",
@@ -38337,13 +38401,10 @@ data: ${JSON.stringify(data)}
         log(`[ResponsesSSE] Stream error: ${error46}`);
         if (!isClosed) {
           try {
-            if (hasTextContent) {
-              send("content_block_stop", { type: "content_block_stop", index: blockIndex });
-            }
-            for (const [, fnCall] of functionCalls) {
-              send("content_block_stop", { type: "content_block_stop", index: fnCall.index });
-            }
-            const errorIdx = blockIndex + functionCalls.size + (hasToolUse ? 1 : 0);
+            closeReasoning();
+            closeText();
+            closeTools();
+            const errorIdx = curIdx++;
             send("content_block_start", {
               type: "content_block_start",
               index: errorIdx,
@@ -62374,6 +62435,7 @@ async function parseArgs(args) {
       config3.quiet = true;
     } else if (arg === "--verbose" || arg === "-v") {
       config3.quiet = false;
+      config3._sawVerbose = true;
     } else if (arg === "--json") {
       config3.jsonOutput = true;
     } else if (arg === "--monitor") {
@@ -62572,6 +62634,9 @@ Usage:  claudish --models --provider <slug>`);
   if (!config3._hasPositionalPrompt && !config3.stdin && !config3._hasPrintFlag) {
     config3.interactive = true;
   }
+  if (config3._sawVerbose && !config3.interactive && !config3.claudeArgs.includes("--verbose") && !config3.claudeArgs.includes("-v")) {
+    config3.claudeArgs.push("--verbose");
+  }
   if (config3.monitor) {
     if (process.env.ANTHROPIC_API_KEY?.includes("placeholder")) {
       delete process.env.ANTHROPIC_API_KEY;
@@ -71331,7 +71396,9 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
     }
     claudeArgs.push(...config3.claudeArgs);
   } else {
-    claudeArgs.push("-p");
+    if (!config3.claudeArgs.includes("-p") && !config3.claudeArgs.includes("--print")) {
+      claudeArgs.push("-p");
+    }
     if (config3.autoApprove) {
       claudeArgs.push("--dangerously-skip-permissions");
     }
@@ -71371,7 +71438,11 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
   }
   const log2 = (message) => {
     if (!config3.quiet) {
-      console.log(message);
+      if (config3.interactive) {
+        console.log(message);
+      } else {
+        console.error(message);
+      }
     }
   };
   if (!config3.monitor && hasNativeAnthropicMapping(config3)) {
@@ -71448,7 +71519,7 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
   for (const signal of signals2) {
     process.on(signal, () => {
       if (!quiet) {
-        console.log(`
+        console.error(`
 [claudish] Received ${signal}, shutting down...`);
       }
       proc.kill();
@@ -72336,7 +72407,7 @@ Team Status`);
     }
     const rawArgs = process.argv.slice(2);
     const explicitNoAutoApprove = rawArgs.includes("--no-auto-approve");
-    if (cliConfig.autoApprove && !explicitNoAutoApprove && !cliConfig.stdin) {
+    if (cliConfig.autoApprove && !explicitNoAutoApprove && !cliConfig.stdin && cliConfig.interactive) {
       const { loadConfig: loadConfig2, saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_profile_config(), exports_profile_config));
       try {
         const cfg = loadConfig2();
@@ -72503,13 +72574,15 @@ Team Status`);
       setDiagOutput2(null);
       diag.cleanup();
       if (!cliConfig.quiet) {
-        console.log(`
+        const write = cliConfig.interactive ? console.log : console.error;
+        write(`
 [claudish] Shutting down proxy server...`);
       }
       await proxy.shutdown();
     }
     if (!cliConfig.quiet) {
-      console.log(`[claudish] Done
+      const write = cliConfig.interactive ? console.log : console.error;
+      write(`[claudish] Done
 `);
     }
     const sessionLogPath = getAlwaysOnLogPath2();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "7.12.3",
+  "version": "7.12.5",
   "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.12.3",
-    "@claudish/magmux-darwin-x64": "7.12.3",
-    "@claudish/magmux-linux-arm64": "7.12.3",
-    "@claudish/magmux-linux-x64": "7.12.3"
+    "@claudish/magmux-darwin-arm64": "7.12.5",
+    "@claudish/magmux-darwin-x64": "7.12.5",
+    "@claudish/magmux-linux-arm64": "7.12.5",
+    "@claudish/magmux-linux-x64": "7.12.5"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",