@koda-sl/baker-bridge 0.147.0-dev.ad499429a → 0.148.0-dev.a87640a51

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

@@ -260,6 +260,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",
@@ -2061,7 +2079,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,
@@ -2087,10 +2105,69 @@ 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("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({