claudish 3.3.4 → 3.3.5

package/dist/index.js

@@ -57065,17 +57065,17 @@ class OpenAIHandler {
     return payload;
   }
   convertMessagesToResponsesAPI(messages) {
-    return messages.filter((msg) => msg.role !== "system").map((msg) => {
+    const result = [];
+    for (const msg of messages) {
+      if (msg.role === "system")
+        continue;
       if (msg.role === "tool") {
-        return {
-          role: "user",
-          content: [
-            {
-              type: "input_text",
-              text: `[Tool Result for ${msg.tool_call_id}]: ${typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)}`
-            }
-          ]
-        };
+        result.push({
+          type: "function_call_output",
+          call_id: msg.tool_call_id,
+          output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+        });
+        continue;
       }
       if (msg.role === "assistant" && msg.tool_calls) {
         const content = [];
@@ -57089,16 +57089,17 @@ class OpenAIHandler {
           if (toolCall.type === "function") {
             content.push({
               type: "function_call",
-              id: toolCall.id,
+              call_id: toolCall.id,
               name: toolCall.function.name,
               arguments: toolCall.function.arguments
             });
           }
         }
-        return { role: "assistant", content };
+        result.push({ role: "assistant", content });
+        continue;
       }
       if (typeof msg.content === "string") {
-        return {
+        result.push({
           role: msg.role,
           content: [
             {
@@ -57106,7 +57107,8 @@ class OpenAIHandler {
               text: msg.content
             }
           ]
-        };
+        });
+        continue;
       }
       if (Array.isArray(msg.content)) {
         const convertedContent = msg.content.map((block) => {
@@ -57117,20 +57119,23 @@ class OpenAIHandler {
             };
           }
           if (block.type === "image_url") {
+            const imageUrl = typeof block.image_url === "string" ? block.image_url : block.image_url?.url || block.image_url;
             return {
               type: "input_image",
-              image_url: block.image_url
+              image_url: imageUrl
             };
           }
           return block;
         });
-        return {
+        result.push({
           role: msg.role,
           content: convertedContent
-        };
+        });
+        continue;
       }
-      return msg;
-    });
+      result.push(msg);
+    }
+    return result;
   }
   buildResponsesPayload(claudeRequest, messages, tools) {
     const convertedMessages = this.convertMessagesToResponsesAPI(messages);
@@ -57168,9 +57173,12 @@ class OpenAIHandler {
     const encoder = new TextEncoder;
     const decoder = new TextDecoder;
     let buffer = "";
-    let contentIndex = 0;
+    let blockIndex = 0;
     let inputTokens = 0;
     let outputTokens = 0;
+    let hasTextContent = false;
+    let hasToolUse = false;
+    const functionCalls = new Map;
     const stream = new ReadableStream({
       start: async (controller) => {
         const messageStart = {
@@ -57209,48 +57217,109 @@ data: ${JSON.stringify(messageStart)}
               try {
                 const event = JSON.parse(data);
                 if (event.type === "response.output_text.delta") {
-                  if (contentIndex === 0) {
+                  if (!hasTextContent) {
                     const blockStart = {
                       type: "content_block_start",
-                      index: 0,
+                      index: blockIndex,
                       content_block: { type: "text", text: "" }
                     };
                     controller.enqueue(encoder.encode(`event: content_block_start
 data: ${JSON.stringify(blockStart)}
 
 `));
-                    contentIndex = 1;
+                    hasTextContent = true;
                   }
                   const delta = {
                     type: "content_block_delta",
-                    index: 0,
+                    index: blockIndex,
                     delta: { type: "text_delta", text: event.delta || "" }
                   };
                   controller.enqueue(encoder.encode(`event: content_block_delta
 data: ${JSON.stringify(delta)}
 
 `));
+                } else if (event.type === "response.output_item.added") {
+                  if (event.item?.type === "function_call") {
+                    const callId = event.item.call_id || event.item.id;
+                    const fnIndex = blockIndex + functionCalls.size + (hasTextContent ? 1 : 0);
+                    functionCalls.set(callId, {
+                      name: event.item.name || "",
+                      arguments: "",
+                      index: fnIndex
+                    });
+                    if (hasTextContent && !hasToolUse) {
+                      const blockStop = { type: "content_block_stop", index: blockIndex };
+                      controller.enqueue(encoder.encode(`event: content_block_stop
+data: ${JSON.stringify(blockStop)}
+
+`));
+                      blockIndex++;
+                    }
+                    const toolStart = {
+                      type: "content_block_start",
+                      index: fnIndex,
+                      content_block: {
+                        type: "tool_use",
+                        id: callId,
+                        name: event.item.name || "",
+                        input: {}
+                      }
+                    };
+                    controller.enqueue(encoder.encode(`event: content_block_start
+data: ${JSON.stringify(toolStart)}
+
+`));
+                    hasToolUse = true;
+                  }
+                } else if (event.type === "response.function_call_arguments.delta") {
+                  const callId = event.call_id || event.item_id;
+                  const fnCall = functionCalls.get(callId);
+                  if (fnCall) {
+                    fnCall.arguments += event.delta || "";
+                    const delta = {
+                      type: "content_block_delta",
+                      index: fnCall.index,
+                      delta: { type: "input_json_delta", partial_json: event.delta || "" }
+                    };
+                    controller.enqueue(encoder.encode(`event: content_block_delta
+data: ${JSON.stringify(delta)}
+
+`));
+                  }
+                } else if (event.type === "response.output_item.done") {
+                  if (event.item?.type === "function_call") {
+                    const callId = event.item.call_id || event.item.id;
+                    const fnCall = functionCalls.get(callId);
+                    if (fnCall) {
+                      const blockStop = { type: "content_block_stop", index: fnCall.index };
+                      controller.enqueue(encoder.encode(`event: content_block_stop
+data: ${JSON.stringify(blockStop)}
+
+`));
+                    }
+                  }
                 } else if (event.type === "response.completed") {
                   if (event.response?.usage) {
                     inputTokens = event.response.usage.input_tokens || 0;
                     outputTokens = event.response.usage.output_tokens || 0;
                   }
-                } else if (event.type === "response.function_call_arguments.delta") {}
+                }
               } catch (parseError) {
                 log(`[OpenAIHandler] Error parsing Responses event: ${parseError}`);
               }
             }
           }
-          if (contentIndex > 0) {
-            const blockStop = { type: "content_block_stop", index: 0 };
+          if (hasTextContent && !hasToolUse) {
+            const blockStop = { type: "content_block_stop", index: blockIndex };
             controller.enqueue(encoder.encode(`event: content_block_stop
 data: ${JSON.stringify(blockStop)}
 
 `));
           }
+          const stopReason = hasToolUse ? "tool_use" : "end_turn";
           const messageDelta = {
             type: "message_delta",
-            delta: { stop_reason: "end_turn", stop_sequence: null },
+            delta: { stop_reason: stopReason, stop_sequence: null },
             usage: { output_tokens: outputTokens }
           };
           controller.enqueue(encoder.encode(`event: message_delta

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "3.3.4",
+  "version": "3.3.5",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",