@koda-sl/baker-bridge 0.144.0 → 0.145.0-dev.5f3658e72

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

@@ -2121,6 +2121,61 @@ 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), BAKER-502 (the report held behind it), BAKER-2215
+    // (request_tag_input), 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;