@bman654/clodex 2.11.2 → 2.11.4

package/dist/cli.js

@@ -382,7 +382,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.11.2",
+  version: "2.11.4",
   publishConfig: {
     access: "public"
   },
@@ -8663,6 +8663,7 @@ function normalizeToolCallJson(value) {
     }
   }
   if (record.type === "reasoning") {
+    delete out.id;
     if (Array.isArray(record.content) && record.content.length === 0) delete out.content;
     if (typeof record.encrypted_content === "string" && record.encrypted_content) delete out.summary;
   }
@@ -11672,6 +11673,71 @@ var CLAUDE_CODE_COMPACT_PROMPT_MARKERS = Object.freeze({
   end: "REMINDER: Do NOT call any tools. Respond with plain text only"
 });
 
+// src/openai-thinking.ts
+var SIGNATURE_PREFIX = "clodex:openai-thinking:";
+var SIGNATURE_V1 = `${SIGNATURE_PREFIX}v1:`;
+function openAiReasoningItemId(part) {
+  const id = part.providerMetadata?.openai?.itemId;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+var OpenAiThinkingBlock = class {
+  parts = /* @__PURE__ */ new Map();
+  hasText = false;
+  start(part) {
+    const itemId = openAiReasoningItemId(part);
+    if (!itemId || !part.id) throw new Error("OpenAI reasoning part has no identity");
+    if (!this.parts.has(part.id)) this.parts.set(part.id, { itemId, text: "" });
+    this.end(part);
+  }
+  append(part) {
+    const entry = this.parts.get(part.id ?? "");
+    if (!entry) throw new Error("OpenAI reasoning delta has no matching start");
+    const text5 = part.text ?? "";
+    if (!text5) return "";
+    const separator = entry.text.length === 0 && this.hasText ? "\n\n" : "";
+    entry.text += text5;
+    this.hasText = true;
+    return separator + text5;
+  }
+  end(part) {
+    const entry = this.parts.get(part.id ?? "");
+    const encrypted = part.providerMetadata?.openai?.reasoningEncryptedContent;
+    if (entry && typeof encrypted === "string" && encrypted) entry.encryptedContent = encrypted;
+  }
+  signature() {
+    return SIGNATURE_V1 + JSON.stringify({ parts: [...this.parts.values()] });
+  }
+};
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function restoreOpenAiThinking(text5, signature, npm) {
+  if (!signature?.startsWith(SIGNATURE_PREFIX)) return void 0;
+  if (!signature.startsWith(SIGNATURE_V1)) return [];
+  try {
+    const envelope = JSON.parse(signature.slice(SIGNATURE_V1.length));
+    if (!isRecord(envelope) || !Array.isArray(envelope.parts) || envelope.parts.length === 0) return [];
+    const parts = [];
+    for (const part of envelope.parts) {
+      if (!isRecord(part) || typeof part.itemId !== "string" || !part.itemId || typeof part.text !== "string" || part.encryptedContent !== void 0 && typeof part.encryptedContent !== "string") return [];
+      parts.push(part);
+    }
+    if (npm !== "@ai-sdk/openai") return text5 ? [{ type: "reasoning", text: text5 }] : [];
+    return parts.map((part) => ({
+      type: "reasoning",
+      text: part.text,
+      providerOptions: {
+        openai: {
+          itemId: part.itemId,
+          ...part.encryptedContent ? { reasoningEncryptedContent: part.encryptedContent } : {}
+        }
+      }
+    }));
+  } catch {
+    return [];
+  }
+}
+
 // src/sdk-adapter.ts
 function sdkTranslationErrorSignature(error) {
   const message = error instanceof Error ? error.message : typeof error === "string" ? error : void 0;
@@ -11876,8 +11942,12 @@ function translateMessages(messages, npm, openAiPromptCacheBreakpoints = false)
         if (b.type === "text") {
           parts.push({ type: "text", text: b.text ?? "" });
         } else if (b.type === "thinking") {
-          const part = thinkingToSdkPart(b, npm);
-          if (part) parts.push(part);
+          const restored = restoreOpenAiThinking(b.thinking ?? "", b.signature, npm);
+          if (restored) parts.push(...restored);
+          else {
+            const part = thinkingToSdkPart(b, npm);
+            if (part) parts.push(part);
+          }
         } else if (b.type === "tool_use" && b.id) {
           const { rawId, thoughtSignature } = splitToolUseId(b.id);
           const part = {
@@ -12119,6 +12189,7 @@ async function writeAnthropicStream(stream, modelId, write, log12, observer, too
   let started = false;
   let openType = null;
   let pendingThinkingSig;
+  let openAiThinking;
   const idToBlock = /* @__PURE__ */ new Map();
   const toolJsonBuffer = /* @__PURE__ */ new Map();
   const flushedTools = /* @__PURE__ */ new Set();
@@ -12158,9 +12229,10 @@ async function writeAnthropicStream(stream, modelId, write, log12, observer, too
       emit("content_block_delta", {
         type: "content_block_delta",
         index: blockIndex,
-        delta: { type: "signature_delta", signature: pendingThinkingSig ?? "" }
+        delta: { type: "signature_delta", signature: openAiThinking?.signature() ?? pendingThinkingSig ?? "" }
       });
       pendingThinkingSig = void 0;
+      openAiThinking = void 0;
     }
     if (openType === "tool" && openToolId !== null && !flushedTools.has(openToolId)) {
       const buffered = toolJsonBuffer.get(openToolId);
@@ -12200,19 +12272,30 @@ async function writeAnthropicStream(stream, modelId, write, log12, observer, too
       case "abort":
         throw streamAbortError(observer?.abortSignal);
       case "reasoning-start":
-        openBlock("thinking", { type: "thinking", thinking: "", signature: "" });
+        if (openAiReasoningItemId(part) && part.id) {
+          if (!openAiThinking) {
+            openBlock("thinking", { type: "thinking", thinking: "", signature: "" });
+            openAiThinking = new OpenAiThinkingBlock();
+          }
+          openAiThinking.start(part);
+        } else {
+          openBlock("thinking", { type: "thinking", thinking: "", signature: "" });
+        }
         break;
       case "reasoning-delta":
         if (openType !== "thinking") openBlock("thinking", { type: "thinking", thinking: "", signature: "" });
         emit("content_block_delta", {
           type: "content_block_delta",
           index: blockIndex,
-          delta: { type: "thinking_delta", thinking: part.text ?? "" }
+          delta: { type: "thinking_delta", thinking: openAiThinking ? openAiThinking.append(part) : part.text ?? "" }
         });
         break;
       case "reasoning-end": {
-        const sig = grabRoundTripSignature(part);
-        if (sig) pendingThinkingSig = sig;
+        if (openAiThinking) openAiThinking.end(part);
+        else {
+          const sig = grabRoundTripSignature(part);
+          if (sig) pendingThinkingSig = sig;
+        }
         break;
       }
       case "text-start":
@@ -18389,6 +18472,7 @@ import * as p9 from "@clack/prompts";
 import * as http2 from "http";
 import * as https from "https";
 import * as net from "net";
+import { PassThrough } from "stream";
 import { randomUUID as randomUUID6 } from "crypto";
 import { URL as URL2 } from "url";
 import { createBrotliDecompress, createGunzip, createInflate } from "zlib";
@@ -19076,6 +19160,97 @@ function forwardToAdapter(req, res, rawBody, adapter, adapterRequest = http2.req
     upstream.end(rawBody);
   });
 }
+function forwardAnthropicUpgrade(req, clientSocket, head, origin, rejectUnauthorized, agent, sockets) {
+  if (clientSocket._httpMessage) {
+    clientSocket.destroy();
+    return;
+  }
+  const clientData = new PassThrough();
+  clientSocket.pipe(clientData);
+  let responseStarted = false;
+  let upgradedSocket;
+  const upstream = https.request({
+    protocol: "https:",
+    hostname: origin.hostname,
+    port: origin.port || 443,
+    method: req.method,
+    path: req.url,
+    headers: requestHeadersWithoutProxyHeaders(req),
+    servername: net.isIP(origin.hostname) ? void 0 : origin.hostname,
+    rejectUnauthorized,
+    agent
+  });
+  const fail = () => {
+    if (clientSocket.destroyed) return;
+    if (responseStarted) {
+      clientSocket.destroy();
+      return;
+    }
+    responseStarted = true;
+    clientSocket.end(
+      "HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\nContent-Length: 0\r\n\r\n",
+      () => clientSocket.destroy()
+    );
+  };
+  clientSocket.once("error", () => clientSocket.destroy());
+  clientSocket.once("end", () => {
+    if (!responseStarted) clientSocket.destroy();
+  });
+  clientSocket.once("close", () => {
+    clientData.destroy();
+    upstream.destroy();
+    upgradedSocket?.destroy();
+  });
+  upstream.once("socket", (socket) => {
+    if (clientSocket.destroyed) socket.destroy();
+  });
+  upstream.once("error", fail);
+  upstream.once("close", () => {
+    if (!responseStarted) fail();
+  });
+  upstream.once("response", (upstreamRes) => {
+    if (clientSocket.destroyed) {
+      upstreamRes.destroy();
+      return;
+    }
+    responseStarted = true;
+    const response = new http2.ServerResponse(req);
+    response.shouldKeepAlive = false;
+    response.assignSocket(clientSocket);
+    clientSocket.on("drain", () => response.emit("drain"));
+    response.once("error", () => clientSocket.destroy());
+    response.once("finish", () => clientSocket.end(() => clientSocket.destroy()));
+    copyResponse(upstreamRes, response);
+  });
+  upstream.once("upgrade", (upstreamRes, socket, upstreamHead) => {
+    if (clientSocket.destroyed) {
+      socket.destroy();
+      return;
+    }
+    responseStarted = true;
+    upgradedSocket = socket;
+    sockets.add(socket);
+    socket.once("error", () => clientSocket.destroy());
+    socket.once("close", () => {
+      sockets.delete(socket);
+      clientSocket.destroy();
+    });
+    const headers = [
+      `HTTP/${upstreamRes.httpVersion} ${upstreamRes.statusCode} ${upstreamRes.statusMessage}`
+    ];
+    for (let i = 0; i < upstreamRes.rawHeaders.length; i += 2) {
+      headers.push(`${upstreamRes.rawHeaders[i]}: ${upstreamRes.rawHeaders[i + 1]}`);
+    }
+    clientSocket.write(Buffer.from(`${headers.join("\r\n")}\r
+\r
+`, "latin1"));
+    if (upstreamHead.length > 0) clientSocket.write(upstreamHead);
+    if (head.length > 0) socket.write(head);
+    clientData.pipe(socket);
+    socket.pipe(clientSocket);
+  });
+  upstream.end();
+}
 function forwardPlainHttp(req, res) {
   let target;
   try {
@@ -19292,6 +19467,17 @@ async function startHttpProxy(options) {
     );
   });
   const sockets = /* @__PURE__ */ new Set();
+  mitmServer.on("upgrade", (req, socket, head) => {
+    forwardAnthropicUpgrade(
+      req,
+      socket,
+      head,
+      anthropicOrigin,
+      options.anthropicRejectUnauthorized ?? true,
+      anthropicAgent,
+      sockets
+    );
+  });
   const proxyServer = http2.createServer(forwardPlainHttp);
   proxyServer.on("connection", (socket) => {
     sockets.add(socket);