@bman654/clodex 2.18.2 → 2.18.4

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.4",
   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;
@@ -12932,8 +13025,8 @@ function translateRequest(body, npm, options) {
   }
   const upstreamModelId2 = options?.reasoningMetadata?.upstreamModelId ?? body.model;
   const supportsExplicitOpenAiCaching = !options?.openAiOAuth && supportsOpenAiPromptCacheBreakpoints(upstreamModelId2);
+  const claudeSessionId = extractClaudeSessionId(body, options?.claudeSessionId);
   if (npm === "@ai-sdk/openai") {
-    const claudeSessionId = extractClaudeSessionId(body, options?.claudeSessionId);
     const serviceTier = options?.openAiOAuth ? oauthServiceTier() : void 0;
     providerOptions = deepMergeProviderOptions(providerOptions, {
       openai: {
@@ -12954,7 +13047,17 @@ function translateRequest(body, npm, options) {
     toolChoice: compactRequest ? "none" : translateToolChoice(body.tool_choice),
     maxOutputTokens: options?.openAiOAuth ? void 0 : body.max_tokens,
     temperature: body.temperature,
-    providerOptions
+    providerOptions,
+    // OpenRouter derives its own conversation key when none is sent, and routes a
+    // session's requests to one provider when one is. The value needs to be stable
+    // and unique, not recognizable, so the session UUID goes over hashed through
+    // the same key the OpenAI route's prompt_cache_key uses; the system/tools hash
+    // stays the fallback for clients that send no session identity.
+    ...isOpenRouterRoute(npm, options?.reasoningMetadata) ? {
+      headers: {
+        "x-session-id": claudeSessionId ? claudeSessionPromptCacheKey(claudeSessionId) : openAiPromptCacheKey(baseSystem, upstreamTools)
+      }
+    } : {}
   };
 }
 function isOpenAiOAuthRoute(route) {
@@ -13287,8 +13390,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 +13419,6 @@ async function generateAnthropicResponse(model, params, modelId, options) {
       )),
       totalTimeoutMs
     );
-    const streamedText = [];
-    const streamedToolCalls = [];
     let streamedFinishReason = "stop";
     let streamedUsage;
     try {
@@ -13334,17 +13441,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 +13454,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 +13472,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 +13485,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)
   };