@koda-sl/baker-bridge 0.154.0-dev.db7cf2f5d → 0.154.0

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) {
@@ -957,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 = [];
@@ -1989,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();
@@ -4641,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.