@koda-sl/baker-bridge 0.71.0 → 0.71.2-dev.5e66c2900

package/dist/hono/bridge-job.test.js

@@ -216,6 +216,13 @@ function resultMessage(costUsd, sessionId, modelUsage) {
         ...(modelUsage ? { modelUsage } : {}),
     };
 }
+function streamEvent(event, parentToolUseId) {
+    return {
+        type: "stream_event",
+        event,
+        parent_tool_use_id: parentToolUseId ?? null,
+    };
+}
 function assistantMessage(uuid, text, sessionId, extras) {
     return {
         type: "assistant",
@@ -573,6 +580,75 @@ describe("BridgeJobExecutor", () => {
             { target: { threadId: "thread_zero", turnId: "turn_zero" }, tokens: 96000, window: 200000 },
         ]);
     });
+    // The shape production actually sends: OpenRouter zeroes `message_start` and
+    // the assembled assistant message with it, and reports the real occupancy only
+    // on `message_delta`. Read from the message alone, the meter never had a single
+    // reading to show.
+    it("reads the meter off the stream when the assistant message reports no usage", async () => {
+        const relay = recordingRelay();
+        const executor = createExecutor({
+            relay,
+            queryResults: [
+                scriptedMessages(streamEvent({
+                    type: "message_start",
+                    message: { usage: { input_tokens: 0, cache_read_input_tokens: null, cache_creation_input_tokens: null } },
+                }), streamEvent({
+                    type: "message_delta",
+                    delta: { stop_reason: "end_turn" },
+                    usage: { input_tokens: 5000, output_tokens: 300, cache_read_input_tokens: 90000 },
+                }), assistantMessage("assistant_zeroed", "Done.", "session_next", {
+                    usage: { input_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 },
+                }), resultMessage(0.02, "session_next", {
+                    "claude-main": {
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        cacheReadInputTokens: 0,
+                        cacheCreationInputTokens: 0,
+                        webSearchRequests: 0,
+                        costUSD: 0.02,
+                        contextWindow: 200000,
+                        maxOutputTokens: 32000,
+                    },
+                })),
+            ],
+        });
+        await executor.execute({ threadId: "thread_stream_usage", turnId: "turn_stream_usage", prompt: "hi", history: history([]) }, activeControls());
+        expect(relay.contextUsageUpdates).toEqual([
+            { target: { threadId: "thread_stream_usage", turnId: "turn_stream_usage" }, tokens: 95000, window: 200000 },
+        ]);
+    });
+    it("ignores subagent stream usage — only the main conversation drives the meter", async () => {
+        const relay = recordingRelay();
+        const executor = createExecutor({
+            relay,
+            queryResults: [
+                scriptedMessages(streamEvent({
+                    type: "message_delta",
+                    delta: { stop_reason: "end_turn" },
+                    usage: { input_tokens: 5000, cache_read_input_tokens: 90000 },
+                }), streamEvent({
+                    type: "message_delta",
+                    delta: { stop_reason: "end_turn" },
+                    usage: { input_tokens: 400000, cache_read_input_tokens: 0 },
+                }, "toolu_subagent"), resultMessage(0.02, "session_next", {
+                    "claude-main": {
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        cacheReadInputTokens: 0,
+                        cacheCreationInputTokens: 0,
+                        webSearchRequests: 0,
+                        costUSD: 0.02,
+                        contextWindow: 200000,
+                        maxOutputTokens: 32000,
+                    },
+                })),
+            ],
+        });
+        await executor.execute({ threadId: "thread_sub_stream", turnId: "turn_sub_stream", prompt: "hi", history: history([]) }, activeControls());
+        expect(relay.contextUsageUpdates).toEqual([
+            { target: { threadId: "thread_sub_stream", turnId: "turn_sub_stream" }, tokens: 95000, window: 200000 },
+        ]);
+    });
     it("ignores subagent request usage — only the main conversation drives the meter", async () => {
         const relay = recordingRelay();
         const executor = createExecutor({
@@ -747,11 +823,13 @@ describe("BridgeJobExecutor", () => {
         await executor.execute({ threadId: "thread_ordinary", turnId: "turn_ordinary", prompt: "Make the hero blue", history: history([]) }, activeControls());
         expect(queryInputs[0]?.options.settings ?? {}).not.toHaveProperty("autoCompactEnabled");
     });
-    it("compacts and retries once when publish genuinely no longer fits the window", async () => {
+    it("restarts publish on a fresh session when the conversation no longer fits", async () => {
         const queryInputs = [];
+        const clearCalls = [];
         const executor = createExecutor({
             loadedBoundary: cleanBoundary("session_overflow"),
             queryInputs,
+            clearCalls,
             queryResults: [
                 // The CLI announces its session id before the first model request, so the
                 // refusal arrives with an id but no work done — the retry still owes the
@@ -761,15 +839,43 @@ describe("BridgeJobExecutor", () => {
                     subtype: "init",
                     session_id: "session_overflow_live",
                 }),
-                scriptedMessages(resultMessage(0.4, "session_after_compaction")),
+                scriptedMessages(resultMessage(0.4, "session_restarted")),
             ],
         });
         const outcome = await executor.execute({ threadId: "thread_overflow", turnId: "turn_overflow", prompt: "/publish", history: history([]) }, activeControls());
         expect(outcome.kind).toBe("completed");
         expect(queryInputs[0]?.options.settings).toMatchObject({ autoCompactEnabled: false });
-        expect(queryInputs[1]?.options.settings ?? {}).not.toHaveProperty("autoCompactEnabled");
+        // The oversized session is abandoned, not summarized: the retry resumes
+        // nothing and delivers the `/publish` the turn still owes.
+        expect(queryInputs[1]?.options.resume).toBeUndefined();
         expect(queryInputs[1]?.prompt).toBe("/publish");
-        expect(queryInputs[1]?.options.resume).toBe("session_overflow");
+        expect(clearCalls).toEqual([{ threadId: "thread_overflow", reason: "sdk_error" }]);
+    });
+    it("does not silently restart an ordinary message that overflows", async () => {
+        const queryInputs = [];
+        const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_ordinary_overflow"),
+            queryInputs,
+            queryResults: [
+                contextOverflowQuery({
+                    type: "system",
+                    subtype: "init",
+                    session_id: "session_ordinary_overflow_live",
+                }),
+            ],
+        });
+        const outcome = await executor.execute({
+            threadId: "thread_ordinary_overflow",
+            turnId: "turn_ordinary_overflow",
+            prompt: "Make the hero blue",
+            history: history([{ role: "user", text: "The brand colour is teal", createdAt: 1 }]),
+        }, activeControls());
+        // A restart would answer from rehydrated history instead of the live session,
+        // and an ordinary message — unlike `/publish` — is answered *from* that
+        // context. Silently trading it for a shorter one degrades the reply with no
+        // explanation, so this turn says so instead.
+        expect(queryInputs).toHaveLength(1);
+        expect(outcome.kind).toBe("errored");
     });
     it("resumes the in-flight publish session when the overflow lands mid-turn", async () => {
         const queryInputs = [];
@@ -808,6 +914,52 @@ describe("BridgeJobExecutor", () => {
         // progress — the retry still owes the turn its `/publish`.
         expect(queryInputs[1]?.prompt).toBe("/publish");
     });
+    // How the failure actually reached production: the CLI does not throw, it ends
+    // the turn on an error *result* carrying the provider's refusal.
+    it("restarts publish when the overflow arrives as an error result", async () => {
+        const relay = recordingRelay();
+        const queryInputs = [];
+        const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_result_overflow"),
+            relay,
+            queryInputs,
+            queryResults: [
+                scriptedMessages({ type: "system", subtype: "init", session_id: "session_result_overflow_live" }, assistantMessage("assistant_result_refusal", "Prompt is too long", "session_result_overflow_live"), {
+                    type: "result",
+                    subtype: "error_during_execution",
+                    is_error: true,
+                    errors: ["Prompt is too long"],
+                    total_cost_usd: 0.2,
+                    session_id: "session_result_overflow_live",
+                }),
+                scriptedMessages(assistantMessage("assistant_result_published", "Your changes are live.", "session_result_restarted"), resultMessage(0.4, "session_result_restarted")),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_result_overflow", turnId: "turn_result_overflow", prompt: "/publish", history: history([]) }, activeControls());
+        expect(outcome.kind).toBe("completed");
+        expect(queryInputs[1]?.options.resume).toBeUndefined();
+        expect(queryInputs[1]?.prompt).toBe("/publish");
+        expect(JSON.stringify(relay.assistantEvents)).not.toContain("Prompt is too long");
+    });
+    it("reports a turn the restart could not save in product language", async () => {
+        const relay = recordingRelay();
+        const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_doomed"),
+            relay,
+            queryResults: [
+                contextOverflowQuery({ type: "system", subtype: "init", session_id: "session_doomed_live" }, assistantMessage("assistant_doomed", "Prompt is too long", "session_doomed_live")),
+                // Even the restarted session is refused: the turn is out of moves.
+                contextOverflowQuery(assistantMessage("assistant_doomed_again", "Prompt is too long", "session_doomed_restarted")),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_doomed", turnId: "turn_doomed", prompt: "/publish", history: history([]) }, activeControls());
+        expect(outcome.kind).toBe("errored");
+        const errors = outcome.kind === "errored" ? outcome.errors.join(" ") : "";
+        expect(errors).not.toContain("Prompt is too long");
+        expect(errors).toContain("Send your message again");
+        // Said once, by the product — the provider's own words never reach the chat.
+        expect(JSON.stringify(relay.assistantEvents)).not.toContain("Prompt is too long");
+    });
     it("does not resurrect a dropped refusal as end-of-turn text", async () => {
         const relay = recordingRelay();
         const executor = createExecutor({