@koda-sl/baker-bridge 0.144.0 → 0.145.0

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

@@ -2121,6 +2121,60 @@ describe("BridgeJobExecutor", () => {
         await inactiveExecutor.execute({ threadId: "thread_inactive_close", turnId: "turn_inactive_close", prompt: "Stop", history: history([]) }, inactiveControls);
         expect(inactiveCloseCalls).toEqual(["close"]);
     });
+    // BAKER-1025 (AskUserQuestion), the request_tag_input sighting, and the ExitPlanMode and
+    // request_connection sightings: each held the turn ~900 s before the same deny, although
+    // the card stays up and a later answer resumes the chat as a new turn anyway.
+    it.each([
+        { toolName: "AskUserQuestion", input: { questions: [{ question: "Which budget?" }] }, planMode: false },
+        { toolName: "ExitPlanMode", input: { plan: "Draft flow" }, planMode: true },
+        {
+            toolName: "mcp__baker_ui__request_tag_input",
+            input: { changes: [{ mode: "create", tagType: "clarity" }] },
+            planMode: false,
+        },
+        {
+            toolName: CONNECTION_INPUT_TOOL_NAME,
+            input: { connections: [{ platform: "hubspot", reason: "Send leads to HubSpot" }] },
+            planMode: false,
+        },
+    ])("releases the turn within a minute when $toolName goes unanswered", async ({ toolName, input, planMode }) => {
+        vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "setInterval", "clearInterval"] });
+        try {
+            let guardResult;
+            let reachedTool = () => undefined;
+            const toolReached = new Promise((resolve) => {
+                reachedTool = resolve;
+            });
+            const executor = new BridgeJobExecutor({
+                sdk: {
+                    query: (queryInput) => ({
+                        async *[Symbol.asyncIterator]() {
+                            reachedTool();
+                            guardResult = await queryInput.options.canUseTool?.(toolName, input, {
+                                toolUseID: "tool_unanswered",
+                                requestId: "req_unanswered",
+                                signal: queryInput.options.abortController?.signal ?? new AbortController().signal,
+                            });
+                            yield resultMessage(0, "session_unanswered");
+                        },
+                    }),
+                },
+                model: "claude-test",
+                sessionStore: { load: async () => undefined, save: async () => undefined, clear: async () => undefined },
+                relay: recordingRelay(),
+            });
+            const controls = activeControls();
+            const outcome = executor.execute({ threadId: "thread_unanswered", turnId: "turn_unanswered", prompt: "Ask first", planMode }, controls);
+            await toolReached;
+            await vi.advanceTimersByTimeAsync(59_000);
+            expect(guardResult).toMatchObject({ behavior: "deny", message: expect.stringContaining("has not answered") });
+            await vi.runOnlyPendingTimersAsync();
+            await outcome;
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
     it("denies an unanswered AskUserQuestion gracefully instead of erroring the turn", async () => {
         const relay = recordingRelay();
         let inputResolvedCalls = 0;
@@ -2245,6 +2299,57 @@ describe("BridgeJobExecutor", () => {
         expect(castingRequests).toHaveLength(1);
         expect(castingRequests[0]).toMatchObject({ avatarHandle: "elena" });
     });
+    it("keeps the ad behind an unpicked casting until its portraits render and the auto-pick lands", async () => {
+        // The portraits take about 40 s to render and the auto-pick waits 30 s more, so a
+        // casting resolves itself around 70 s. The question cards' short wait must not let the
+        // next tool run before the face is chosen.
+        vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "setInterval", "clearInterval"] });
+        try {
+            const controls = activeControls();
+            let nextToolResult;
+            let castingOpened = () => undefined;
+            const opened = new Promise((resolve) => {
+                castingOpened = resolve;
+            });
+            const relay = recordingRelay();
+            relay.avatarCastingRequest = () => {
+                castingOpened();
+                return Promise.resolve(true);
+            };
+            const executor = new BridgeJobExecutor({
+                sdk: {
+                    query: (input) => ({
+                        async *[Symbol.asyncIterator]() {
+                            const call = (name, toolInput, id) => input.options.canUseTool?.(name, toolInput, {
+                                toolUseID: id,
+                                requestId: `req_${id}`,
+                                signal: input.options.abortController?.signal ?? new AbortController().signal,
+                            });
+                            await call("Bash", { command: 'baker avatars create --name "Elena" --subject "a woman"' }, "t1");
+                            nextToolResult = await call("Bash", { command: "baker studio animate 'Elena talks' --avatar elena" }, "t2");
+                            yield resultMessage(0, "session_slow_cast");
+                        },
+                    }),
+                },
+                model: "claude-test",
+                sessionStore: { load: async () => undefined, save: async () => undefined, clear: async () => undefined },
+                relay,
+            });
+            const outcome = executor.execute({ threadId: "thread_sc", turnId: "turn_sc", prompt: "Crea un avatar" }, controls);
+            await opened;
+            await vi.advanceTimersByTimeAsync(90_000);
+            expect(nextToolResult).toBeUndefined();
+            for (const pending of controls.pendingAvatarCastings.values()) {
+                pending.resolve({ status: "cast", avatarHandle: "elena", imageId: "img_auto" });
+            }
+            await vi.runOnlyPendingTimersAsync();
+            await outcome;
+            expect(nextToolResult).toMatchObject({ behavior: "allow" });
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
     it("hands the agent's own casting call the face the user picked, instead of a second picker", async () => {
         // An agent may still call it right after `baker avatars create` (the tool now says the
         // picker opens by itself, but the call is tolerated). The auto-cast owed for that create used