@bman654/clodex 2.18.1 → 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.1",
+  version: "2.18.3",
   publishConfig: {
     access: "public"
   },
@@ -3438,7 +3438,7 @@ function savedStopsAfter(current, assignments) {
 }
 
 // src/patch-transforms.ts
-var PATCH_TRANSFORMS_VERSION = 13;
+var PATCH_TRANSFORMS_VERSION = 14;
 var NATIVE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 var BASE_EFFORT_LEVELS = ["low", "medium", "high"];
 function projectNativeEffort(effort) {
@@ -3616,15 +3616,10 @@ function applyClodexPatches(source, config) {
       );
     }
   }
+  const pickerRow = (a) => "{value:" + q(a) + ",label:" + q(a.charAt(0).toUpperCase() + a.slice(1)) + ",description:" + q(displayFor(a, ALIAS_TO_ID[a])) + "}";
   {
     const missing = ALIASES.filter((a) => !new RegExp("value:" + reEsc(q(a))).test(js));
-    const entries = missing.map(
-      // value = the alias (the name the user types and the binary sends);
-      // description = the real model label, e.g. "GPT-5.6 Sol (OpenAI (ChatGPT))".
-      // (tweakcc's writeContent round-trips utf8 faithfully — verified — so the
-      // old adhoc-patch ASCII-only constraint no longer applies.)
-      (a) => "{value:" + q(a) + ",label:" + q(a.charAt(0).toUpperCase() + a.slice(1)) + ",description:" + q(displayFor(a, ALIAS_TO_ID[a])) + "}"
-    ).join(",");
+    const entries = missing.map(pickerRow).join(",");
     const injectInto = (options) => missing.length ? "[" + entries + "].forEach(function(_o){if(!" + options + ".some(function(_i){return _i.value===_o.value}))" + options + ".push(_o)});" : "";
     const pickerSite = "PATCH 5: model picker options";
     const modelSelections = [...js.matchAll(/\(([\w$]+)==="opus"\|\|\1==="sonnet"\)/g)];
@@ -3641,6 +3636,25 @@ function applyClodexPatches(source, config) {
       );
     }
   }
+  {
+    const catalogSite = "PATCH 11: catalog picker options";
+    const catalogMarker = "/*ccpatch:picker*/";
+    const catalogAnchor = /function [\w$]+\(([\w$]+),([\w$]+)\)\{let ([\w$]+)=[\w$]+\(\1,\2\),([\w$]+)=\3\?\?[\w$]+\(\1\)(?=[,;])(?=[\s\S]{0,400}ANTHROPIC_CUSTOM_MODEL_OPTION)/;
+    const entryPoints = source.match(new RegExp(catalogAnchor.source, "g"))?.length ?? 0;
+    const rows = ALIASES.map(pickerRow).join(",");
+    if (ALIASES.length === 0) {
+      log13("SKIP", catalogSite, "no aliases configured");
+    } else if (entryPoints !== 1 && !js.includes(catalogMarker)) {
+      log13("FAIL", catalogSite, entryPoints === 0 ? "anchor not found" : "anchor matched " + entryPoints + " times (expected 1)");
+    } else {
+      applyOnce(
+        catalogSite,
+        catalogAnchor,
+        (m, _first, _second, _catalog, options) => m + ",_ccpick=" + catalogMarker + "[" + rows + "].forEach(function(_o){if(!" + options + ".some(function(_i){return _i.value===_o.value}))" + options + ".push(_o)})",
+        { marker: catalogMarker, required: false }
+      );
+    }
+  }
   {
     const safe = (s) => String(s).replace(/`/g, "'").replace(/\$\{/g, "(");
     const listing = IDENTITIES.map(function(i) {
@@ -4147,14 +4161,14 @@ function uniqueMatch(source, name, pattern) {
   }
   return match[0];
 }
-function captureNeedle(source, name, needle) {
-  if (countExactOccurrences(source, needle) !== 1) {
+function captureNeedle(source, name, needle, expected = 1) {
+  if (countExactOccurrences(source, needle) !== expected) {
     throw new Error(`clodex patch: could not capture built-in postcondition: ${name}`);
   }
   return {
     name,
     protectedText: needle,
-    occurrences: 1
+    occurrences: expected
   };
 }
 function capturePattern(source, name, pattern) {
@@ -4214,16 +4228,25 @@ function captureBuiltInPatchProofs(source, config, results) {
       ));
     }
   }
-  if (protectsResult(results, "PATCH 5: model picker options")) {
+  const pickerSites = [
+    "PATCH 5: model picker options",
+    "PATCH 11: catalog picker options"
+  ].filter((name) => protectsResult(results, name));
+  if (pickerSites.length > 0) {
     for (const { alias, id, display } of aliases) {
       const entry = "{value:" + JSON.stringify(alias) + ",label:" + JSON.stringify(alias.charAt(0).toUpperCase() + alias.slice(1)) + ",description:" + JSON.stringify(display ?? `Custom model (${id})`) + "}";
       proofs.push(captureNeedle(
         source,
-        `PATCH 5: model picker options (${alias})`,
-        entry
+        `model picker options (${alias})`,
+        entry,
+        pickerSites.length
       ));
     }
   }
+  addPattern(
+    "PATCH 11: catalog picker options",
+    /,_ccpick=\/\*ccpatch:picker\*\/\[[\s\S]*?\]\.forEach\(function\(_o\)\{if\(![\w$]+\.some\(function\(_i\)\{return _i\.value===_o\.value\}\)\)[\w$]+\.push\(_o\)\}\)/
+  );
   addPattern(
     "PATCH 7: per-model context window",
     /\/\*ccpatch:ctx\*\/var _ccw=\(\{[^{}]*\}\)\[[^\]]*\];if\(_ccw!==void 0\)return _ccw;/
@@ -12550,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;
@@ -13264,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;
@@ -13287,8 +13409,6 @@ async function generateAnthropicResponse(model, params, modelId, options) {
       )),
       totalTimeoutMs
     );
-    const streamedText = [];
-    const streamedToolCalls = [];
     let streamedFinishReason = "stop";
     let streamedUsage;
     try {
@@ -13311,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 {
@@ -13330,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 {
@@ -13350,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;
@@ -13362,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)
   };