claudish 3.3.2 → 3.3.4

package/dist/index.js

@@ -56975,6 +56975,9 @@ class OpenAIHandler {
     return getModelPricing("openai", this.modelName);
   }
   getApiEndpoint() {
+    if (this.isCodexModel()) {
+      return `${this.provider.baseUrl}/v1/responses`;
+    }
     return `${this.provider.baseUrl}${this.provider.apiPath}`;
   }
   writeTokenFile(input, output) {
@@ -57015,6 +57018,10 @@ class OpenAIHandler {
     const model = this.modelName.toLowerCase();
     return model.includes("o1") || model.includes("o3");
   }
+  isCodexModel() {
+    const model = this.modelName.toLowerCase();
+    return model.includes("codex");
+  }
   usesMaxCompletionTokens() {
     const model = this.modelName.toLowerCase();
     return model.includes("gpt-5") || model.includes("o1") || model.includes("o3") || model.includes("o4");
@@ -57057,6 +57064,220 @@ class OpenAIHandler {
     }
     return payload;
   }
+  convertMessagesToResponsesAPI(messages) {
+    return messages.filter((msg) => msg.role !== "system").map((msg) => {
+      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)}`
+            }
+          ]
+        };
+      }
+      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",
+              id: toolCall.id,
+              name: toolCall.function.name,
+              arguments: toolCall.function.arguments
+            });
+          }
+        }
+        return { role: "assistant", content };
+      }
+      if (typeof msg.content === "string") {
+        return {
+          role: msg.role,
+          content: [
+            {
+              type: msg.role === "user" ? "input_text" : "output_text",
+              text: msg.content
+            }
+          ]
+        };
+      }
+      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") {
+            return {
+              type: "input_image",
+              image_url: block.image_url
+            };
+          }
+          return block;
+        });
+        return {
+          role: msg.role,
+          content: convertedContent
+        };
+      }
+      return msg;
+    });
+  }
+  buildResponsesPayload(claudeRequest, messages, tools) {
+    const convertedMessages = this.convertMessagesToResponsesAPI(messages);
+    const payload = {
+      model: this.modelName,
+      input: convertedMessages,
+      stream: true
+    };
+    if (claudeRequest.system) {
+      payload.instructions = claudeRequest.system;
+    }
+    if (claudeRequest.max_tokens) {
+      payload.max_output_tokens = claudeRequest.max_tokens;
+    }
+    if (tools.length > 0) {
+      payload.tools = tools.map((tool) => {
+        if (tool.type === "function" && tool.function) {
+          return {
+            type: "function",
+            name: tool.function.name,
+            description: tool.function.description,
+            parameters: tool.function.parameters
+          };
+        }
+        return tool;
+      });
+    }
+    return payload;
+  }
+  async handleResponsesStreaming(c, response, _adapter, _claudeRequest) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+      return c.json({ error: "No response body" }, 500);
+    }
+    const encoder = new TextEncoder;
+    const decoder = new TextDecoder;
+    let buffer = "";
+    let contentIndex = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const stream = new ReadableStream({
+      start: async (controller) => {
+        const messageStart = {
+          type: "message_start",
+          message: {
+            id: `msg_${Date.now()}`,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model: this.modelName,
+            usage: { input_tokens: 0, output_tokens: 0 }
+          }
+        };
+        controller.enqueue(encoder.encode(`event: message_start
+data: ${JSON.stringify(messageStart)}
+
+`));
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (line.startsWith("event: ")) {
+                continue;
+              }
+              if (!line.startsWith("data: "))
+                continue;
+              const data = line.slice(6);
+              if (data === "[DONE]")
+                continue;
+              try {
+                const event = JSON.parse(data);
+                if (event.type === "response.output_text.delta") {
+                  if (contentIndex === 0) {
+                    const blockStart = {
+                      type: "content_block_start",
+                      index: 0,
+                      content_block: { type: "text", text: "" }
+                    };
+                    controller.enqueue(encoder.encode(`event: content_block_start
+data: ${JSON.stringify(blockStart)}
+
+`));
+                    contentIndex = 1;
+                  }
+                  const delta = {
+                    type: "content_block_delta",
+                    index: 0,
+                    delta: { type: "text_delta", text: event.delta || "" }
+                  };
+                  controller.enqueue(encoder.encode(`event: content_block_delta
+data: ${JSON.stringify(delta)}
+
+`));
+                } 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 };
+            controller.enqueue(encoder.encode(`event: content_block_stop
+data: ${JSON.stringify(blockStop)}
+
+`));
+          }
+          const messageDelta = {
+            type: "message_delta",
+            delta: { stop_reason: "end_turn", stop_sequence: null },
+            usage: { output_tokens: outputTokens }
+          };
+          controller.enqueue(encoder.encode(`event: message_delta
+data: ${JSON.stringify(messageDelta)}
+
+`));
+          const messageStop = { type: "message_stop" };
+          controller.enqueue(encoder.encode(`event: message_stop
+data: ${JSON.stringify(messageStop)}
+
+`));
+          this.updateTokenTracking(inputTokens, outputTokens);
+          controller.close();
+        } catch (error46) {
+          log(`[OpenAIHandler] Responses streaming error: ${error46}`);
+          controller.error(error46);
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
   async handle(c, payload) {
     const { claudeRequest, droppedParams } = transformOpenAIToClaude(payload);
     const messages = this.convertMessages(claudeRequest);
@@ -57081,11 +57302,12 @@ class OpenAIHandler {
         log(`[OpenAI] Tools: ${toolNames}`);
       }
     }
-    const openAIPayload = this.buildOpenAIPayload(claudeRequest, messages, tools);
+    const isCodex = this.isCodexModel();
+    const apiPayload = isCodex ? this.buildResponsesPayload(claudeRequest, messages, tools) : this.buildOpenAIPayload(claudeRequest, messages, tools);
     const adapter = this.adapterManager.getAdapter();
     if (typeof adapter.reset === "function")
       adapter.reset();
-    adapter.prepareRequest(openAIPayload, claudeRequest);
+    adapter.prepareRequest(apiPayload, claudeRequest);
     await this.middlewareManager.beforeRequest({
       modelId: `openai/${this.modelName}`,
       messages,
@@ -57104,7 +57326,7 @@ class OpenAIHandler {
           "Content-Type": "application/json",
           Authorization: `Bearer ${this.apiKey}`
         },
-        body: JSON.stringify(openAIPayload),
+        body: JSON.stringify(apiPayload),
         signal: controller.signal
       });
     } catch (fetchError) {
@@ -57146,6 +57368,10 @@ class OpenAIHandler {
     if (droppedParams.length > 0) {
       c.header("X-Dropped-Params", droppedParams.join(", "));
     }
+    if (isCodex) {
+      log(`[OpenAIHandler] Using Responses API streaming handler for Codex model`);
+      return this.handleResponsesStreaming(c, response, adapter, claudeRequest);
+    }
     return createStreamingResponseHandler(c, response, adapter, `openai/${this.modelName}`, this.middlewareManager, (input, output) => this.updateTokenTracking(input, output), claudeRequest.tools);
   }
   async shutdown() {}

package/package.json

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