@koda-sl/baker-bridge 0.149.0-dev.3d350da58 → 0.149.0-dev.7e6763861

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

@@ -23,6 +23,7 @@ import { CONNECTION_INPUT_TOOL_NAME } from "./connection-input.js";
 import { CREDENTIAL_INPUT_TOOL_NAME } from "./credential-input.js";
 import { FLOW_INPUT_TOOL_NAME } from "./flow-input.js";
 import { bridgeRuntimeFiles } from "./runtime-files.js";
+import { alignServedModels } from "./served-model.js";
 import { INTERRUPTED_RESUME_PROMPT } from "./session-continuity.js";
 import { TAG_INPUT_TOOL_NAME } from "./tag-input.js";
 function history(entries) {
@@ -238,11 +239,14 @@ function createExecutor(options) {
             : {}),
         now: options.now,
         readUsageBaseline: async (sessionId) => options.usageBaselines?.[sessionId],
+        alignServedModels: async (sessionId) => {
+            if (options.claudeConfigDir) {
+                await alignServedModels(sessionId, options.claudeConfigDir);
+            }
+        },
         stalledCliExitMs: 0,
         prepareAttachments: options.prepareAttachments,
         ...(options.inFlightTurns ? { inFlightTurns: options.inFlightTurns } : {}),
-        ...(options.catchUpWithMain ? { catchUpWithMain: options.catchUpWithMain } : {}),
-        ...(options.keepCliInStep ? { keepCliInStep: options.keepCliInStep } : {}),
     });
 }
 function memoryInFlightTurns(initial) {
@@ -262,6 +266,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 +961,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`);
+            const resumedFrom = [];
+            const executor = createExecutor({
+                loadedBoundary: cleanBoundary("session_resume"),
+                claudeConfigDir: configDir,
+                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 = [];
@@ -1652,78 +1708,6 @@ describe("BridgeJobExecutor", () => {
         expect(queryInputs[0]?.prompt).toBe("/publish");
         expect(queryInputs[0]?.reminder).toBeUndefined();
     });
-    it("tells the agent which files another chat's publish just brought into its workspace", async () => {
-        const queryInputs = [];
-        const executor = createExecutor({
-            queryInputs,
-            catchUpWithMain: async () => ({ inWorkspace: true, changed: ["src/pages/home/hero.md"] }),
-        });
-        await executor.execute({
-            threadId: "thread_caught_up",
-            turnId: "turn_caught_up",
-            prompt: "Cambia el subtítulo del hero a «Sin entrada, paga en 24 meses».",
-            history: history([
-                { role: "user", text: "¿Qué pone ahora el hero de la home?", createdAt: 1 },
-                {
-                    role: "assistant",
-                    text: "El titular dice «Paneles solares para tu casa» y el subtítulo «Instala hoy y paga en 12 meses».",
-                    createdAt: 2,
-                },
-            ]),
-        }, activeControls());
-        expect(queryInputs[0]?.prompt).toContain("Sin entrada, paga en 24 meses");
-        expect(queryInputs[0]?.reminder).toContain("Read again any of them you work on");
-        expect(queryInputs[0]?.reminder).toContain("- src/pages/home/hero.md");
-    });
-    it("leaves the workspace of a finished Session alone while it is reviewed", async () => {
-        let caughtUp = false;
-        const executor = createExecutor({
-            catchUpWithMain: () => {
-                caughtUp = true;
-                return Promise.resolve(undefined);
-            },
-        });
-        await executor.execute({
-            threadId: "thread_review_sync",
-            turnId: "turn_review_sync",
-            prompt: "review",
-            history: history([]),
-            review: { threadIds: [], chatFacts: { chatId: "chat_1" }, outputRepair: true },
-        }, activeControls());
-        expect(caughtUp).toBe(false);
-    });
-    it("brings the CLI to the release Convex sent before the turn starts", async () => {
-        const queryInputs = [];
-        const requested = [];
-        const executor = createExecutor({
-            queryInputs,
-            keepCliInStep: (wanted) => {
-                requested.push({ wanted, turnStarted: queryInputs.length > 0 });
-                return Promise.resolve();
-            },
-        });
-        await executor.execute({ threadId: "thread_cli", turnId: "turn_cli", prompt: "Hola", cliVersion: "0.412.0", history: history([]) }, activeControls());
-        expect(requested).toEqual([{ wanted: "0.412.0", turnStarted: false }]);
-        expect(queryInputs).toHaveLength(1);
-    });
-    it("keeps the Session's CLI while it is reviewed", async () => {
-        const wanted = [];
-        const executor = createExecutor({
-            keepCliInStep: (version) => {
-                wanted.push(version);
-                return Promise.resolve();
-            },
-        });
-        await executor.execute({
-            threadId: "thread_review_cli",
-            turnId: "turn_review_cli",
-            prompt: "review",
-            cliVersion: "0.412.0",
-            history: history([]),
-            review: { threadIds: [], chatFacts: { chatId: "chat_1" }, outputRepair: true },
-        }, activeControls());
-        expect(wanted).toEqual([]);
-    });
     it("keeps the viewing-reference context beside the message when a stale session falls back to rehydration", async () => {
         const queryInputs = [];
         const executor = createExecutor({
@@ -1855,6 +1839,23 @@ 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("keeps the running turn's session on record until the turn ends", async () => {
         const recorded = [];
         const inFlightTurns = memoryInFlightTurns();
@@ -2135,7 +2136,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,
@@ -2161,10 +2162,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({