@askalf/dario 5.5.51 → 5.5.53

package/dist/cc-template.js

@@ -1584,6 +1584,61 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
     const messages = clientBody.messages || [];
     const clientTools = clientBody.tools;
     const stream = clientBody.stream ?? false;
+    // ── Drop empty text blocks from history (ALL paths) ──
+    // Upstream rejects empty text blocks OUTRIGHT — stamped or not — and treats
+    // whitespace-only text the same way ("messages: text content blocks must be
+    // non-empty"; with a breakpoint on it, "cache_control cannot be set for
+    // empty text blocks"). One such block entering the transcript mid-run
+    // therefore killed every subsequent request of the session (dario#1066).
+    // Filtering here fixes the REQUEST, which no breakpoint guard can: skipping
+    // the stamp still leaves the illegal block on the wire.
+    //
+    // Sits ABOVE the genuine-CC early return on purpose. #1067 placed this
+    // below it, where real Claude Code — the one client whose messages are
+    // forwarded verbatim — never reached it, and the #1066 session-killer
+    // survived on exactly the client it hurts most (dario#1077). An empty text
+    // block is not a wire shape the client is authority over; it is a
+    // guaranteed upstream 400. `messages` aliases clientBody.messages, so
+    // these mutations reach the genuine-CC body, which spreads clientBody.
+    for (const msg of messages) {
+        if (!Array.isArray(msg.content))
+            continue;
+        msg.content = msg.content.filter((b) => !(b.type === 'text' && (typeof b.text !== 'string' || b.text.trim() === '')));
+    }
+    // A USER turn left with no blocks is dropped — but only MID-conversation,
+    // where the API combines the now-adjacent same-role turns and where the
+    // #1066 session-killer lives (the empty turn sits in history, so every
+    // later request carries it). The FINAL turn is deliberately left in place
+    // per the dario#1033 decision below: popping it would expose the assistant
+    // turn behind it and convert an honest "content must contain at least one
+    // block" into a misleading prefill rejection. Hoisted with the filter
+    // (dario#1077): removing a block can empty a turn on any path.
+    for (let i = messages.length - 2; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role === 'user' && Array.isArray(m.content) && m.content.length === 0) {
+            messages.splice(i, 1);
+        }
+    }
+    // A TRAILING assistant turn the filter emptied is dropped too — content: []
+    // at the end reads as a prefill upstream, which Opus under adaptive thinking
+    // + the claude-code beta refuses outright. This is a copy of the trailing
+    // drop further down (which must ALSO stay there, running after the general
+    // path's thinking strip — the shape it was written for); the copy exists so
+    // the genuine-CC early return inherits it (dario#1077 follow-up: stage 3 of
+    // 3, the "failure moves rather than disappears" case). Same constraints as
+    // the original: assistant turns ONLY — popping an empty final user turn
+    // would convert an honest "content must contain at least one block" into a
+    // misleading prefill rejection (dario#1033), and popping a NON-empty
+    // trailing assistant is the OpenClaw runaway loop (#37). Idempotent, so
+    // running it twice on the general path changes nothing.
+    while (messages.length > 0) {
+        const last = messages[messages.length - 1];
+        if (last.role === 'assistant' && Array.isArray(last.content) && last.content.length === 0) {
+            messages.pop();
+            continue;
+        }
+        break;
+    }
     // ── Genuine Claude Code client → byte-faithful passthrough ──
     // A real CC request already IS the CC wire shape. Replacing its system
     // prompt with the template (prepending ~25KB per request shape) and
@@ -1600,9 +1655,11 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
     //     here, conversation in applyCcPromptCaching) so the 4-breakpoint
     //     budget stays deterministic.
     // Messages, thinking, effort, max_tokens, top-level key order: untouched —
-    // the client is the authority on its own wire shape. Outranks the
-    // tool-mode flags: those configure how NON-CC clients are dressed up as
-    // CC, which a genuine CC client doesn't need.
+    // the client is the authority on its own wire shape. One exception, the
+    // empty-text filter above (dario#1077): a guaranteed upstream 400 is a
+    // defect, not a wire-shape preference. Outranks the tool-mode flags: those
+    // configure how NON-CC clients are dressed up as CC, which a genuine CC
+    // client doesn't need.
     if (isGenuineCCClient(clientBody)) {
         const clientSystem = clientBody.system;
         const system = clientSystem.map((b, i) => {
@@ -1677,32 +1734,9 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
             }
         }
     }
-    // ── Drop empty text blocks from history ──
-    // Upstream rejects empty text blocks OUTRIGHT — stamped or not — and treats
-    // whitespace-only text the same way ("messages: text content blocks must be
-    // non-empty"; with a breakpoint on it, "cache_control cannot be set for
-    // empty text blocks"). One such block entering the transcript mid-run
-    // therefore killed every subsequent request of the session (dario#1066).
-    // Filtering here fixes the REQUEST, which no breakpoint guard can: skipping
-    // the stamp still leaves the illegal block on the wire.
-    for (const msg of messages) {
-        if (!Array.isArray(msg.content))
-            continue;
-        msg.content = msg.content.filter((b) => !(b.type === 'text' && (typeof b.text !== 'string' || b.text.trim() === '')));
-    }
-    // A USER turn left with no blocks is dropped — but only MID-conversation,
-    // where the API combines the now-adjacent same-role turns and where the
-    // #1066 session-killer lives (the empty turn sits in history, so every
-    // later request carries it). The FINAL turn is deliberately left in place
-    // per the dario#1033 decision below: popping it would expose the assistant
-    // turn behind it and convert an honest "content must contain at least one
-    // block" into a misleading prefill rejection.
-    for (let i = messages.length - 2; i >= 0; i--) {
-        const m = messages[i];
-        if (m.role === 'user' && Array.isArray(m.content) && m.content.length === 0) {
-            messages.splice(i, 1);
-        }
-    }
+    // (Empty text blocks and the mid-conversation empty-user-turn drop moved
+    // above the genuine-CC branch — dario#1077. Only the thinking strip stays
+    // path-local: genuine CC forwards its signed thinking verbatim.)
     // ── Drop trailing empty turns ──
     // An assistant turn that was thinking-only before the strip above becomes
     // content: []. Forwarding that shape makes Anthropic interpret the request

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "5.5.51",
+  "version": "5.5.53",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {