claudish 3.3.3 → 3.3.5

package/dist/index.js

@@ -57064,10 +57064,84 @@ class OpenAIHandler {
     }
     return payload;
   }
+  convertMessagesToResponsesAPI(messages) {
+    const result = [];
+    for (const msg of messages) {
+      if (msg.role === "system")
+        continue;
+      if (msg.role === "tool") {
+        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 = [];
+        if (msg.content) {
+          const textContent = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+          if (textContent) {
+            content.push({ type: "output_text", text: textContent });
+          }
+        }
+        for (const toolCall of msg.tool_calls) {
+          if (toolCall.type === "function") {
+            content.push({
+              type: "function_call",
+              call_id: toolCall.id,
+              name: toolCall.function.name,
+              arguments: toolCall.function.arguments
+            });
+          }
+        }
+        result.push({ role: "assistant", content });
+        continue;
+      }
+      if (typeof msg.content === "string") {
+        result.push({
+          role: msg.role,
+          content: [
+            {
+              type: msg.role === "user" ? "input_text" : "output_text",
+              text: msg.content
+            }
+          ]
+        });
+        continue;
+      }
+      if (Array.isArray(msg.content)) {
+        const convertedContent = msg.content.map((block) => {
+          if (block.type === "text") {
+            return {
+              type: msg.role === "user" ? "input_text" : "output_text",
+              text: block.text
+            };
+          }
+          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: imageUrl
+            };
+          }
+          return block;
+        });
+        result.push({
+          role: msg.role,
+          content: convertedContent
+        });
+        continue;
+      }
+      result.push(msg);
+    }
+    return result;
+  }
   buildResponsesPayload(claudeRequest, messages, tools) {
+    const convertedMessages = this.convertMessagesToResponsesAPI(messages);
     const payload = {
       model: this.modelName,
-      input: messages,
+      input: convertedMessages,
       stream: true
     };
     if (claudeRequest.system) {
@@ -57099,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 = {
@@ -57140,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.3",
+  "version": "3.3.5",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",