@koda-sl/baker-bridge 0.161.0 → 0.163.0

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

@@ -18,7 +18,7 @@ vi.mock("./runtime-files.ts", async (importOriginal) => {
 });
 import { AVATAR_CASTING_TOOL_NAME } from "./avatar-casting.js";
 import { FACE_PICK_QUESTION } from "./avatar-face-question.js";
-import { BridgeJobExecutor, createStallDetector, isContextOverflowRefusal, isControlChannelDeny, parsePlanDecision, remapAnswersToQuestionText, } from "./bridge-job.js";
+import { agentFeature, BridgeJobExecutor, createStallDetector, isContextOverflowRefusal, isControlChannelDeny, parsePlanDecision, remapAnswersToQuestionText, } from "./bridge-job.js";
 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";
@@ -1244,6 +1244,9 @@ describe("BridgeJobExecutor", () => {
     });
     it("propagates the inherited process env (OpenRouter routing) to the agent subprocess", async () => {
         vi.stubEnv("ANTHROPIC_AUTH_TOKEN", "sk-or-test-key");
+        vi.stubEnv("BAKER_ENVIRONMENT", "production");
+        vi.stubEnv("BAKER_RUNTIME_COMPANY_ID", "company_env");
+        vi.stubEnv("BAKER_CHAT_ID", "chat_env");
         const queryInputs = [];
         const executor = createExecutor({
             queryInputs,
@@ -1265,8 +1268,25 @@ describe("BridgeJobExecutor", () => {
                 allow_fallbacks: true,
             },
             session_id: "thread_env",
+            user: "agent.turn | company:company_env | chat:chat_env",
+            trace: {
+                trace_name: "agent.turn",
+                generation_name: "agent.turn",
+                feature: "agent.turn",
+                service: "agent",
+                environment: "production",
+                company_id: "company_env",
+                chat_id: "chat_env",
+            },
             plugins: [{ id: "web", enabled: false }],
         });
+        // The same tag as headers, which is what names the app in OpenRouter.
+        expect(env?.ANTHROPIC_CUSTOM_HEADERS).toBe([
+            "HTTP-Referer: https://agent.production.withbaker.com",
+            "X-OpenRouter-Title: Baker agent (production)",
+            "X-Title: Baker agent (production)",
+            "x-session-id: thread_env",
+        ].join("\n"));
     });
     // OpenRouter has no Bedrock endpoint for a per-message effort, so while the CLI
     // sends one every Opus 5.5 request skips Bedrock and bills OpenRouter credits.
@@ -2532,9 +2552,9 @@ describe("BridgeJobExecutor", () => {
     });
     // 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.
+    // the card stays up and a later answer resumes the chat as a new turn anyway. A question
+    // card is the exception since it picks for the user (BAKER-3550): see the test below.
     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",
@@ -2592,10 +2612,15 @@ describe("BridgeJobExecutor", () => {
             return Promise.resolve();
         };
         let guardResult;
+        let reachedTool = () => undefined;
+        const toolReached = new Promise((resolve) => {
+            reachedTool = resolve;
+        });
         const executor = new BridgeJobExecutor({
             sdk: {
                 query: (input) => ({
                     async *[Symbol.asyncIterator]() {
+                        reachedTool();
                         guardResult = await input.options.canUseTool?.("AskUserQuestion", { questions: [{ label: "Confirm?" }] }, {
                             toolUseID: "tool_1",
                             requestId: "req_1",
@@ -2612,10 +2637,20 @@ describe("BridgeJobExecutor", () => {
                 clear: async () => undefined,
             },
             relay,
-            askUserQuestionTimeoutMs: 1,
         });
         const controls = activeControls();
-        const outcome = await executor.execute({ threadId: "thread_question_timeout", turnId: "turn_question_timeout", prompt: "Ask first" }, controls);
+        vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "setInterval", "clearInterval"] });
+        let outcome;
+        try {
+            const running = executor.execute({ threadId: "thread_question_timeout", turnId: "turn_question_timeout", prompt: "Ask first" }, controls);
+            await toolReached;
+            await vi.advanceTimersByTimeAsync(120_000);
+            await vi.runOnlyPendingTimersAsync();
+            outcome = await running;
+        }
+        finally {
+            vi.useRealTimers();
+        }
         // The unanswered prompt denies the tool with guidance — the turn completes
         // cleanly so the user can answer with a normal message later.
         expect(guardResult).toMatchObject({ behavior: "deny" });
@@ -2630,6 +2665,93 @@ describe("BridgeJobExecutor", () => {
         // recovery turn. Posting input-resolved here would clear it.
         expect(inputResolvedCalls).toBe(0);
     });
+    // BAKER-3550: a question card answers itself with the recommended option after a
+    // countdown, so the turn must still be waiting when that pick arrives.
+    it("holds a question card's turn past the countdown that picks for the user, then lets it go", async () => {
+        vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "setInterval", "clearInterval"] });
+        try {
+            let guardResult;
+            let reachedTool = () => undefined;
+            const toolReached = new Promise((resolve) => {
+                reachedTool = resolve;
+            });
+            const controls = activeControls();
+            const executor = new BridgeJobExecutor({
+                sdk: {
+                    query: (queryInput) => ({
+                        async *[Symbol.asyncIterator]() {
+                            reachedTool();
+                            guardResult = await queryInput.options.canUseTool?.("AskUserQuestion", { questions: [{ question: "Which budget?", options: [{ label: "Low" }, { label: "High" }] }] }, {
+                                toolUseID: "tool_countdown",
+                                requestId: "req_countdown",
+                                signal: queryInput.options.abortController?.signal ?? new AbortController().signal,
+                            });
+                            yield resultMessage(0, "session_countdown");
+                        },
+                    }),
+                },
+                model: "claude-test",
+                sessionStore: { load: async () => undefined, save: async () => undefined, clear: async () => undefined },
+                relay: recordingRelay(),
+            });
+            const outcome = executor.execute({ threadId: "thread_countdown", turnId: "turn_countdown", prompt: "Ask first" }, controls);
+            await toolReached;
+            await vi.advanceTimersByTimeAsync(65_000);
+            expect(guardResult).toBeUndefined();
+            expect(controls.pendingQuestions.has("tool_countdown")).toBe(true);
+            await vi.advanceTimersByTimeAsync(60_000);
+            expect(guardResult).toMatchObject({ behavior: "deny", message: expect.stringContaining("has not answered") });
+            await vi.runOnlyPendingTimersAsync();
+            await outcome;
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it("carries on the same turn with the recommended option Baker picked, and tells the agent nobody answered", async () => {
+        const relay = recordingRelay();
+        let guardResult;
+        const controls = activeControls();
+        const question = "Which colour should the ad use?";
+        const executor = new BridgeJobExecutor({
+            sdk: {
+                query: (input) => ({
+                    async *[Symbol.asyncIterator]() {
+                        const decision = input.options.canUseTool?.("AskUserQuestion", {
+                            questions: [
+                                { question, header: "Colour", options: [{ label: "Blue" }, { label: "Teal (Recommended)" }] },
+                            ],
+                        }, {
+                            toolUseID: "tool_auto",
+                            requestId: "req_auto",
+                            signal: input.options.abortController?.signal ?? new AbortController().signal,
+                        });
+                        while (!controls.pendingQuestions.has("tool_auto")) {
+                            await Promise.resolve();
+                        }
+                        controls.pendingQuestions
+                            .get("tool_auto")
+                            ?.resolve({ answers: { q0: "Teal (Recommended)" }, chosenBy: "auto" });
+                        guardResult = await decision;
+                        yield resultMessage(0, "session_auto");
+                    },
+                }),
+            },
+            model: "claude-test",
+            sessionStore: { load: async () => undefined, save: async () => undefined, clear: async () => undefined },
+            relay,
+        });
+        await executor.execute({ threadId: "thread_auto", turnId: "turn_auto", prompt: "Make an ad" }, controls);
+        expect(guardResult).toMatchObject({
+            behavior: "allow",
+            updatedInput: {
+                answers: { [question]: "Teal (Recommended)" },
+                annotations: {
+                    [question]: { notes: expect.stringMatching(/nobody answered.*picked the recommended option automatically/i) },
+                },
+            },
+        });
+    });
     // Without this the run deadlocks: the wait expires, the deny tells the agent to
     // end its turn, and the pending card it leaves behind parks the thread on a
     // question nobody will ever answer — stranding the Session and its Task.
@@ -4864,4 +4986,11 @@ describe("BridgeJobExecutor model refusals", () => {
         expect(outcome).toMatchObject({ kind: "completed" });
     });
 });
+describe("agentFeature", () => {
+    it("tells OpenRouter a Session review, a plan and a chat turn apart", () => {
+        expect(agentFeature({ review: {} })).toBe("chatReview.session");
+        expect(agentFeature({ planMode: true })).toBe("agent.plan");
+        expect(agentFeature({})).toBe("agent.turn");
+    });
+});
 //# sourceMappingURL=bridge-job.test.js.map