@koda-sl/baker-bridge 0.152.0-dev.1a19b1876 → 0.153.0-dev.ad2740332

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

@@ -69,6 +69,7 @@ function recordingRelay() {
     const compactionUpdates = [];
     const reviewDigests = [];
     const retractedEvents = [];
+    const toolOutcomeBatches = [];
     const contextUsageUpdates = [];
     return {
         assistantEvents,
@@ -78,6 +79,7 @@ function recordingRelay() {
         contextUsageUpdates,
         reviewDigests,
         retractedEvents,
+        toolOutcomeBatches,
         startPreview: () => undefined,
         previewText: () => undefined,
         previewTools: () => undefined,
@@ -99,6 +101,10 @@ function recordingRelay() {
             retractedEvents.push({ target, eventIds });
             return Promise.resolve();
         },
+        toolOutcomes: (_target, outcomes) => {
+            toolOutcomeBatches.push(outcomes);
+            return Promise.resolve();
+        },
         complete: () => Promise.resolve(),
         inputRequest: () => Promise.resolve(true),
         inputResolved: () => Promise.resolve(),
@@ -243,6 +249,7 @@ function createExecutor(options) {
         ...(options.inFlightTurns ? { inFlightTurns: options.inFlightTurns } : {}),
         ...(options.catchUpWithMain ? { catchUpWithMain: options.catchUpWithMain } : {}),
         ...(options.keepCliInStep ? { keepCliInStep: options.keepCliInStep } : {}),
+        ...(options.holdsNoWork ? { holdsNoWork: options.holdsNoWork } : {}),
     });
 }
 function memoryInFlightTurns(initial) {
@@ -262,6 +269,24 @@ function memoryInFlightTurns(initial) {
         },
     };
 }
+// The CLI's own report of a failed model request, written as an assistant
+// message — the shape production stores (`model: "<synthetic>"`, `error`).
+function apiErrorMessage(uuid, text, error) {
+    return {
+        type: "assistant",
+        uuid,
+        session_id: "session_api_error",
+        parent_tool_use_id: null,
+        error,
+        is_api_error_message: true,
+        message: {
+            role: "assistant",
+            model: "<synthetic>",
+            content: [{ type: "text", text }],
+            stop_reason: "stop_sequence",
+        },
+    };
+}
 function resultMessage(costUsd, sessionId, modelUsage) {
     return {
         type: "result",
@@ -939,6 +964,40 @@ describe("BridgeJobExecutor", () => {
             ],
         });
     });
+    // OpenRouter answers under its own slug. A CLI resuming a transcript that names
+    // the slug drops every earlier thinking block from its first request, which
+    // breaks the prompt cache right after the system prompt (BAKER-331).
+    it("hands the CLI a transcript that names the model the conversation asked for", async () => {
+        const configDir = await mkdtemp(join(tmpdir(), "bridge-served-model-"));
+        try {
+            const transcriptPath = join(configDir, "projects", "-home-user-repo", "session_resume.jsonl");
+            await mkdir(join(configDir, "projects", "-home-user-repo"), { recursive: true });
+            await writeFile(transcriptPath, `${JSON.stringify({
+                type: "assistant",
+                requestedModel: "claude-opus-5-5",
+                message: { id: "msg_1", model: "anthropic/claude-opus-5.5", content: [{ type: "thinking", thinking: "t" }] },
+            })}\n`);
+            vi.stubEnv("CLAUDE_CONFIG_DIR", configDir);
+            const resumedFrom = [];
+            const executor = createExecutor({
+                loadedBoundary: cleanBoundary("session_resume"),
+                queryResults: [
+                    {
+                        async *[Symbol.asyncIterator]() {
+                            await Promise.resolve();
+                            resumedFrom.push(readFileSync(transcriptPath, "utf8"));
+                            yield resultMessage(0.2, "session_next");
+                        },
+                    },
+                ],
+            });
+            await executor.execute({ threadId: "thread_resume", turnId: "turn_resume", prompt: "Continue", history: history([]) }, activeControls());
+            expect(JSON.parse(resumedFrom[0] ?? "{}").message.model).toBe("claude-opus-5-5");
+        }
+        finally {
+            await rm(configDir, { recursive: true, force: true });
+        }
+    });
     it("publishes without the conversation, and without summarizing it first", async () => {
         const queryInputs = [];
         const savedBoundaries = [];
@@ -1739,6 +1798,28 @@ describe("BridgeJobExecutor", () => {
         expect(queryInputs).toHaveLength(0);
         expect(told).toBe(0);
     });
+    it("keeps the note for the next turn when the user stops this one before its prompt goes out", async () => {
+        const queryInputs = [];
+        const controls = activeControls();
+        let told = 0;
+        const executor = createExecutor({
+            queryInputs,
+            mcpServersProvider: () => {
+                controls.deactivate();
+                return Promise.resolve(undefined);
+            },
+            catchUpWithMain: () => Promise.resolve({
+                inWorkspace: true,
+                changed: ["src/pages/home/hero.md"],
+                told: () => {
+                    told += 1;
+                    return Promise.resolve();
+                },
+            }),
+        });
+        await executor.execute({ threadId: "thread_stopped_late", turnId: "turn_stopped_late", prompt: "Cambia el hero", history: history([]) }, controls);
+        expect(told).toBe(0);
+    });
     it("leaves the workspace of a finished Session alone while it is reviewed", async () => {
         let caughtUp = false;
         const executor = createExecutor({
@@ -1891,6 +1972,36 @@ describe("BridgeJobExecutor", () => {
         expect(queryInputs[0]?.options).toMatchObject({ resume: "session_interrupted", forkSession: true });
         expect(relay.contextSources.map((entry) => entry.source)).toEqual(["interrupted_resume"]);
     });
+    it("tells a turn sent again after a restart what another chat published while it was down", async () => {
+        const queryInputs = [];
+        let told = 0;
+        const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_clean"),
+            queryInputs,
+            inFlightTurns: memoryInFlightTurns({
+                version: 1,
+                turnId: "turn_interrupted_sync",
+                sessionId: "session_interrupted",
+                updatedAtMs: 1,
+            }),
+            catchUpWithMain: () => Promise.resolve({
+                inWorkspace: false,
+                changed: ["src/pages/home/hero.md"],
+                told: () => {
+                    told += 1;
+                    return Promise.resolve();
+                },
+            }),
+        });
+        await executor.execute({
+            threadId: "thread_interrupted_sync",
+            turnId: "turn_interrupted_sync",
+            prompt: "Rebuild the five pages",
+        }, activeControls());
+        expect(queryInputs[0]?.prompt).toBe(INTERRUPTED_RESUME_PROMPT);
+        expect(queryInputs[0]?.reminder).toContain("- src/pages/home/hero.md");
+        expect(told).toBe(1);
+    });
     it("runs the turn the ordinary way when the interrupted session cannot be resumed", async () => {
         const relay = recordingRelay();
         const queryInputs = [];
@@ -1919,6 +2030,39 @@ describe("BridgeJobExecutor", () => {
         expect(clearCalls).toEqual([]);
         expect(relay.contextSources.map((entry) => entry.source)).toEqual(["interrupted_resume", "local_resume"]);
     });
+    it("keeps the chat's conversation when an interrupted publish that cannot be resumed is run again", async () => {
+        const executor = createExecutor({
+            loadedBoundary: cleanBoundary("session_clean"),
+            inFlightTurns: memoryInFlightTurns({
+                version: 1,
+                turnId: "turn_publish",
+                sessionId: "session_never_written",
+                updatedAtMs: 1,
+            }),
+            queryResults: [
+                scriptedError(new Error("No conversation found with session ID: session_never_written")),
+                scriptedMessages(assistantMessage("assistant_published", "Published", "session_publish_only"), resultMessage(0.2, "session_publish_only")),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_publish", turnId: "turn_publish", prompt: "/publish" }, activeControls());
+        expect(outcome).toMatchObject({ kind: "completed", cleanBoundary: undefined });
+    });
+    it("tells Convex a turn that left the workspace with no work of its own", async () => {
+        const executor = createExecutor({ holdsNoWork: async () => true });
+        const outcome = await executor.execute({ threadId: "thread_run", turnId: "turn_run", prompt: "Post the daily report to Slack. Change nothing." }, activeControls());
+        expect(outcome).toMatchObject({ kind: "completed", workspaceUnchanged: true });
+    });
+    it("claims nothing about the workspace after a publish turn or one that left work", async () => {
+        const publish = createExecutor({
+            holdsNoWork: async () => true,
+            queryResults: [scriptedMessages(resultMessage(0.1, "session_publish_only"))],
+        });
+        const edited = createExecutor({ holdsNoWork: async () => false });
+        const published = await publish.execute({ threadId: "thread_publish", turnId: "turn_publish", prompt: "/publish" }, activeControls());
+        const worked = await edited.execute({ threadId: "thread_run", turnId: "turn_run", prompt: "Rewrite the hero" }, activeControls());
+        expect(published).not.toHaveProperty("workspaceUnchanged");
+        expect(worked).not.toHaveProperty("workspaceUnchanged");
+    });
     it("keeps the running turn's session on record until the turn ends", async () => {
         const recorded = [];
         const inFlightTurns = memoryInFlightTurns();
@@ -2199,7 +2343,7 @@ describe("BridgeJobExecutor", () => {
         expect(savedBoundaries).toEqual([]);
         expect(clearCalls).toContainEqual({ threadId: "thread_result_error", reason: "result_error" });
     });
-    it("preserves provider status details when an SDK result error omits errors", async () => {
+    it("reports a provider's server error in product language, not its status line", async () => {
         const clearCalls = [];
         const executor = createExecutor({
             clearCalls,
@@ -2225,10 +2369,86 @@ describe("BridgeJobExecutor", () => {
             kind: "errored",
             costUsd: 0.17,
             model: "claude-test",
-            errors: ["Claude Code returned an error result: API Error: 500 Internal Server Error; apiErrorStatus 500"],
+            errors: [expect.stringContaining("on our side")],
         });
         expect(clearCalls).toContainEqual({ threadId: "thread_provider_result_error", reason: "result_error" });
     });
+    it("never shows the marketer a model provider's billing error, as a reply or as the turn's error", async () => {
+        const providerError = "API Error: 402 Insufficient credits. Add more using https://openrouter.ai/settings/credits";
+        const relay = recordingRelay();
+        const executor = createExecutor({
+            relay,
+            queryResults: [
+                scriptedMessages(apiErrorMessage("assistant_402", providerError, "unknown"), {
+                    type: "result",
+                    subtype: "success",
+                    is_error: true,
+                    result: providerError,
+                    api_error_status: 402,
+                    total_cost_usd: 0,
+                    session_id: "session_402",
+                }),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_402", turnId: "turn_402", prompt: "Build the creatives", history: history([]) }, activeControls());
+        const shown = JSON.stringify([relay.assistantEvents, outcome.kind === "errored" ? outcome.errors : []]);
+        expect(outcome.kind).toBe("errored");
+        expect(shown).not.toMatch(/API Error|openrouter|402/i);
+    });
+    it("never shows the marketer the provider refusing Baker's own model key", async () => {
+        const executor = createExecutor({
+            queryResults: [
+                scriptedMessages({
+                    type: "result",
+                    subtype: "success",
+                    is_error: true,
+                    result: 'API Error: 401 {"error":{"message":"User not found.","code":401}}',
+                    api_error_status: 401,
+                    total_cost_usd: 0,
+                    session_id: "session_revoked_key",
+                }),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_revoked_key", turnId: "turn_revoked_key", prompt: "Write headlines", history: history([]) }, activeControls());
+        expect(outcome.kind === "errored" ? outcome.errors : []).toEqual([expect.stringContaining("on our side")]);
+    });
+    it("tells the marketer how to fix an image the provider could not read, not to send the same message again", async () => {
+        const imageError = 'API Error: 400 {"type":"error","error":{"type":"invalid_request_error","message":"Could not process image"}}';
+        const executor = createExecutor({
+            queryResults: [
+                scriptedMessages({
+                    type: "result",
+                    subtype: "success",
+                    is_error: true,
+                    result: imageError,
+                    api_error_status: 400,
+                    total_cost_usd: 0,
+                    session_id: "session_bad_image",
+                }),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_bad_image", turnId: "turn_bad_image", prompt: "Use this photo", history: history([]) }, activeControls());
+        expect(outcome.kind === "errored" ? outcome.errors : []).toEqual([
+            expect.stringContaining("extension lies about its format"),
+        ]);
+    });
+    it("keeps a server error the turn recovered from out of the chat, and in the turn events", async () => {
+        const providerError = "API Error: Server error mid-response. The response above may be incomplete.";
+        const relay = recordingRelay();
+        const turnEvents = [];
+        const executor = createExecutor({
+            relay,
+            turnEvents,
+            queryResults: [
+                scriptedMessages(apiErrorMessage("assistant_server_error", providerError, "server_error"), assistantMessage("assistant_recovered", "Your three headlines are ready.", "session_recovered"), resultMessage(0.3, "session_recovered")),
+            ],
+        });
+        const outcome = await executor.execute({ threadId: "thread_recovered", turnId: "turn_recovered", prompt: "Write headlines", history: history([]) }, activeControls());
+        expect(outcome.kind).toBe("completed");
+        expect(JSON.stringify(relay.assistantEvents)).not.toContain("API Error");
+        expect(JSON.stringify(relay.assistantEvents)).toContain("Your three headlines are ready.");
+        expect(turnEvents).toContainEqual(expect.objectContaining({ event: "api_error", detail: { error: "server_error", text: providerError } }));
+    });
     it("closes SDK queries on error and inactive exits but not on natural clean completion", async () => {
         const naturalCloseCalls = [];
         const naturalExecutor = createExecutor({
@@ -4495,6 +4715,34 @@ describe("BridgeJobExecutor model refusals", () => {
             errors: ["I couldn't help with that request. Try rephrasing what you need."],
         });
     });
+    // Tool results come back in user events, which are not stored as messages, so
+    // their outcome is relayed on its own: a Session rebuilt from history needs it.
+    it("relays how each tool call came out, bounded", async () => {
+        const relay = recordingRelay();
+        const toolResult = {
+            type: "user",
+            message: {
+                role: "user",
+                content: [
+                    { type: "tool_result", tool_use_id: "toolu_1", is_error: true, content: "Meta refused the rule" },
+                    { type: "tool_result", tool_use_id: "toolu_2", content: [{ type: "text", text: "x".repeat(5000) }] },
+                ],
+            },
+            parent_tool_use_id: null,
+            session_id: "session_tools",
+        };
+        const executor = createExecutor({
+            relay,
+            queryResults: [scriptedMessages(toolResult, resultMessage(0.01, "session_tools"))],
+        });
+        await executor.execute({ threadId: "thread_tools", turnId: "turn_tools", prompt: "Hi", history: history([]) }, activeControls());
+        expect(relay.toolOutcomeBatches).toEqual([
+            [
+                { toolUseId: "toolu_1", isError: true, text: "Meta refused the rule" },
+                { toolUseId: "toolu_2", isError: false, text: "x".repeat(2000) },
+            ],
+        ]);
+    });
     // A fallback model retried the refused request. What the refused leg already
     // posted is superseded, so it leaves the chat instead of sitting above the
     // answer that replaced it.