@bman654/clodex 2.18.2 → 2.18.3

package/dist/cli.js

@@ -346,7 +346,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.18.2",
+  version: "2.18.3",
   publishConfig: {
     access: "public"
   },
@@ -12573,6 +12573,99 @@ function restoreOpenAiThinking(text6, signature, npm) {
   }
 }
 
+// src/non-stream-content.ts
+var NonStreamContent = class {
+  blocks = [];
+  open;
+  add(part) {
+    switch (part.type) {
+      case "reasoning-start":
+        if (openAiReasoningItemId(part) && part.id) {
+          let open2 = this.open;
+          if (open2?.type !== "thinking" || !open2.openAi) {
+            open2 = this.openThinking(new OpenAiThinkingBlock());
+          }
+          open2.openAi.start(part);
+        } else {
+          this.openThinking();
+        }
+        break;
+      case "reasoning-delta": {
+        const open2 = this.open?.type === "thinking" ? this.open : this.openThinking();
+        open2.block.thinking += open2.openAi ? open2.openAi.append(part) : part.text ?? "";
+        break;
+      }
+      case "reasoning-end":
+        if (this.open?.type !== "thinking") break;
+        if (this.open.openAi) this.open.openAi.end(part);
+        else this.open.signature = grabRoundTripSignature(part) ?? this.open.signature;
+        break;
+      case "text-start":
+        this.openText();
+        break;
+      case "text-delta": {
+        const open2 = this.open?.type === "text" ? this.open : this.openText();
+        open2.block.text += part.text ?? "";
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  /** Append a finished block, such as a tool_use, after whatever is open. */
+  push(block) {
+    this.close();
+    this.blocks.push(block);
+  }
+  content() {
+    this.close();
+    return this.blocks;
+  }
+  openThinking(openAi) {
+    this.close();
+    const block = { type: "thinking", thinking: "", signature: "" };
+    const open2 = { type: "thinking", block, openAi };
+    this.open = open2;
+    return open2;
+  }
+  openText() {
+    this.close();
+    const open2 = { type: "text", block: { type: "text", text: "" } };
+    this.open = open2;
+    return open2;
+  }
+  close() {
+    const open2 = this.open;
+    this.open = void 0;
+    if (!open2) return;
+    if (open2.type === "thinking") {
+      open2.block.signature = open2.openAi?.signature() ?? open2.signature ?? "";
+      this.blocks.push(open2.block);
+    } else if (open2.block.text) {
+      this.blocks.push(open2.block);
+    }
+  }
+};
+function addGeneratedContent(content, parts, addToolCall) {
+  const firstText = parts.findIndex((part) => part.type === "text");
+  const late = parts.map((part, index) => firstText >= 0 && index > firstText && part.type === "reasoning" && !openAiReasoningItemId(part));
+  const ordered = [...parts.filter((_, i) => late[i]), ...parts.filter((_, i) => !late[i])];
+  ordered.forEach((part, index) => {
+    if (part.type === "reasoning") {
+      const id = `reasoning-${index}`;
+      const { text: text6, providerMetadata } = part;
+      content.add({ type: "reasoning-start", id, providerMetadata });
+      content.add({ type: "reasoning-delta", id, text: text6, providerMetadata });
+      content.add({ type: "reasoning-end", id, providerMetadata });
+    } else if (part.type === "text") {
+      content.add({ type: "text-start" });
+      content.add({ type: "text-delta", text: part.text });
+    } else if (part.type === "tool-call") {
+      addToolCall(part);
+    }
+  });
+}
+
 // src/sdk-adapter.ts
 function sdkTranslationErrorSignature(error) {
   const message = error instanceof Error ? error.message : typeof error === "string" ? error : void 0;
@@ -13287,8 +13380,14 @@ async function streamAnthropicResponse(model, params, modelId, write, log13, obs
   }
 }
 async function generateAnthropicResponse(model, params, modelId, options) {
-  let text6;
-  let toolCalls;
+  const requiredProps = toolRequiredProps(params.tools);
+  const content = new NonStreamContent();
+  const addToolCall = (tc) => content.push({
+    type: "tool_use",
+    id: encodeToolUseId(tc.toolCallId ?? "", grabRoundTripSignature(tc)),
+    name: tc.toolName,
+    input: representableToolInput(sanitizeToolInput(tc.input ?? {}, requiredProps.get(tc.toolName ?? "")))
+  });
   let finishReason;
   let usage;
   let warnings;
@@ -13310,8 +13409,6 @@ async function generateAnthropicResponse(model, params, modelId, options) {
       )),
       totalTimeoutMs
     );
-    const streamedText = [];
-    const streamedToolCalls = [];
     let streamedFinishReason = "stop";
     let streamedUsage;
     try {
@@ -13334,17 +13431,11 @@ async function generateAnthropicResponse(model, params, modelId, options) {
         if (part.type === "error") {
           throw part.error instanceof Error || part.error && typeof part.error === "object" ? part.error : new Error(typeof part.error === "string" ? part.error : "Upstream stream failed");
         }
-        if (part.type === "text-delta") streamedText.push(part.text ?? "");
-        else if (part.type === "tool-call") {
-          streamedToolCalls.push({
-            toolCallId: part.toolCallId ?? "",
-            toolName: part.toolName ?? "",
-            input: part.input
-          });
-        } else if (part.type === "finish") {
+        if (part.type === "tool-call") addToolCall(part);
+        else if (part.type === "finish") {
           streamedFinishReason = part.finishReason ?? streamedFinishReason;
           streamedUsage = part.totalUsage;
-        }
+        } else content.add(part);
       }
       if (abortSignal.aborted) throw streamAbortError(abortSignal);
     } finally {
@@ -13353,8 +13444,6 @@ async function generateAnthropicResponse(model, params, modelId, options) {
       clearTimeout(totalTimer);
       if (!forceAbort.signal.aborted) forceAbort.abort();
     }
-    text6 = streamedText.join("");
-    toolCalls = streamedToolCalls;
     finishReason = streamedFinishReason;
     usage = streamedUsage;
   } else {
@@ -13373,7 +13462,8 @@ async function generateAnthropicResponse(model, params, modelId, options) {
         maxRetries,
         abortSignal: generateAbort.signal
       });
-      ({ text: text6, toolCalls, finishReason, usage, warnings } = r);
+      ({ finishReason, usage, warnings } = r);
+      addGeneratedContent(content, r.content, addToolCall);
     } catch (error) {
       if (generateAbort.signal.aborted) throw streamAbortError(generateAbort.signal);
       throw error;
@@ -13385,21 +13475,12 @@ async function generateAnthropicResponse(model, params, modelId, options) {
   }
   reportUnsupportedServiceTier(params, warnings);
   reportPromptTokens({ onPromptTokens: options?.onPromptTokens }, usage);
-  const requiredProps = toolRequiredProps(params.tools);
   return {
     id: translatedMessageId(),
     type: "message",
     role: "assistant",
     model: modelId,
-    content: [
-      ...text6 ? [{ type: "text", text: text6 }] : [],
-      ...toolCalls.map((tc) => ({
-        type: "tool_use",
-        id: encodeToolUseId(tc.toolCallId, grabRoundTripSignature(tc)),
-        name: tc.toolName,
-        input: representableToolInput(sanitizeToolInput(tc.input ?? {}, requiredProps.get(tc.toolName)))
-      }))
-    ],
+    content: content.content(),
     stop_reason: finishReason === "tool-calls" ? "tool_use" : "end_turn",
     usage: toAnthropicUsage(usage)
   };