claudish 7.12.4 → 7.12.6

package/dist/index.js

@@ -581,7 +581,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.12.4";
+var VERSION = "7.12.6";
 
 // 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,
@@ -63799,6 +63860,7 @@ var init_cli = __esm(() => {
 // src/update-checker.ts
 var exports_update_checker = {};
 __export(exports_update_checker, {
+  fetchLatestVersionOrThrow: () => fetchLatestVersionOrThrow,
   fetchLatestVersion: () => fetchLatestVersion,
   compareVersions: () => compareVersions,
   clearCache: () => clearCache,
@@ -63871,20 +63933,39 @@ function compareVersions(v1, v2) {
   }
   return 0;
 }
-async function fetchLatestVersion() {
-  try {
+async function fetchLatestVersionOrThrow(options = {}) {
+  const { timeoutMs = 5000, retries = 0 } = options;
+  let lastError = new Error("unknown error");
+  for (let attempt = 0;attempt <= retries; attempt++) {
     const controller = new AbortController;
-    const timeout = setTimeout(() => controller.abort(), 5000);
-    const response = await fetch(NPM_REGISTRY_URL, {
-      signal: controller.signal,
-      headers: { Accept: "application/json" }
-    });
-    clearTimeout(timeout);
-    if (!response.ok) {
-      return null;
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(NPM_REGISTRY_URL, {
+        signal: controller.signal,
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        throw new Error(`npm registry returned HTTP ${response.status}`);
+      }
+      const data = await response.json();
+      if (!data.version) {
+        throw new Error("npm registry response contained no version field");
+      }
+      return data.version;
+    } catch (error46) {
+      lastError = error46 instanceof Error && error46.name === "AbortError" ? new Error(`request timed out after ${timeoutMs}ms`) : error46 instanceof Error ? error46 : new Error(String(error46));
+      if (attempt < retries) {
+        await new Promise((resolve3) => setTimeout(resolve3, 300 * (attempt + 1)));
+      }
+    } finally {
+      clearTimeout(timeout);
     }
-    const data = await response.json();
-    return data.version || null;
+  }
+  throw lastError;
+}
+async function fetchLatestVersion(options = {}) {
+  try {
+    return await fetchLatestVersionOrThrow(options);
   } catch {
     return null;
   }
@@ -64085,16 +64166,50 @@ ${BOLD2}Unable to detect installation method.${RESET2}`);
   console.log(`  ${CYAN2}brew:${RESET2} brew upgrade claudish
 `);
 }
+function fetchLatestVersionViaNpm() {
+  try {
+    const output = execSync("npm view claudish version", {
+      encoding: "utf-8",
+      timeout: 20000,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const version2 = output.trim();
+    return /^\d+\.\d+\.\d+/.test(version2) ? version2 : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveLatestVersion() {
+  let fetchError;
+  try {
+    return { version: await fetchLatestVersionOrThrow({ timeoutMs: 15000, retries: 2 }) };
+  } catch (error46) {
+    fetchError = error46 instanceof Error ? error46.message : String(error46);
+  }
+  const viaNpm = fetchLatestVersionViaNpm();
+  if (viaNpm)
+    return { version: viaNpm };
+  return { error: fetchError };
+}
 async function updateCommand() {
   const currentVersion = getVersion3();
   const installInfo = detectInstallationMethod();
-  const latestVersion = await fetchLatestVersion();
-  if (!latestVersion) {
+  const result = await resolveLatestVersion();
+  if ("error" in result) {
     console.error(`${RED2}\u2717${RESET2} Unable to fetch latest version from npm registry.`);
-    console.error(`${YELLOW}Please check your internet connection and try again.${RESET2}
+    console.error(`${DIM2}Reason: ${result.error}${RESET2}`);
+    console.error(`${YELLOW}The npm registry may be slow or unreachable from this network.${RESET2}`);
+    const manualCommand = getUpdateCommand(installInfo.method);
+    if (manualCommand) {
+      console.error(`${YELLOW}You can update manually:${RESET2}`);
+      console.error(`  ${CYAN2}${manualCommand}${RESET2}
 `);
+    } else {
+      printManualInstructions();
+    }
     process.exit(1);
   }
+  const latestVersion = result.version;
   const comparison = compareVersions(latestVersion, currentVersion);
   if (comparison <= 0) {
     console.log(`${GREEN2}\u2713${RESET2} ${BOLD2}Already up-to-date!${RESET2}`);

package/package.json

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