@koda-sl/baker-bridge 0.152.0-dev.1a19b1876 → 0.153.0-dev.ded7a9497

package/dist/hono/bridge-job.js

@@ -26,7 +26,8 @@ import { BEDROCK_SERVABLE_CAPABILITIES, buildAgentExtraBody, EXTRA_BODY_ENV, MOD
 import { credentialReminder, currentReferenceReminder, kickoffBriefReminder } from "./prompt-context.js";
 import { publishLanguageReminder, publishRunReminder } from "./publish-handoff.js";
 import { bridgeRuntimeFiles } from "./runtime-files.js";
-import { applyCurrentSenderAttribution, buildCleanBoundary, buildRehydratedPrompt, compactionRetryAttempt, emptyInProgressSession, interruptedResumeAttempt, isContextOverflowError, isResumeSessionError, observeInProgressSession, prepareSessionAttempt, stallContinuationAttempt, } from "./session-continuity.js";
+import { alignServedModels } from "./served-model.js";
+import { applyCurrentSenderAttribution, buildCancelBoundary, buildCleanBoundary, buildRehydratedPrompt, compactionRetryAttempt, emptyInProgressSession, interruptedResumeAttempt, isCliResumeRefusal, isContextOverflowError, isResumeSessionError, observeInProgressSession, prepareSessionAttempt, stallContinuationAttempt, } from "./session-continuity.js";
 import { readSessionSkills } from "./session-skills.js";
 import { ownQueryUsage, readUsageBaseline } from "./session-usage-baseline.js";
 import { BridgeSlashCommands, leadingSkillCommand, verbatimSlashCommand } from "./slash-commands.js";
@@ -424,10 +425,20 @@ const CONTEXT_OVERFLOW_MESSAGE = "This chat has grown too long to continue in on
 // so the turn ends on this instead. The refused exchange is not saved to the
 // session, so a rephrased message starts from the conversation before it.
 const MODEL_REFUSAL_MESSAGE = "I couldn't help with that request. Try rephrasing what you need.";
-function userFacingTurnError(message) {
+// What the user reads when the model provider failed the request itself — out
+// of credit, rate-limited, down. The CLI's own text ("API Error: 402 Insufficient
+// credits. Add more using https://openrouter.ai/…") is the provider talking to
+// Baker: a vendor, a status code and a billing page the marketer cannot open.
+// The raw text stays in the bridge log and the turn events.
+const PROVIDER_FAILURE_MESSAGE = "Baker's AI service had a problem on our side, so this step stopped. Nothing you did caused it — send your message again to pick up where it stopped.";
+function userFacingTurnError(error) {
+    const message = errorMessage(error);
     if (isContextOverflowError(message)) {
         return CONTEXT_OVERFLOW_MESSAGE;
     }
+    if (error instanceof SdkResultError && error.providerFailure) {
+        return PROVIDER_FAILURE_MESSAGE;
+    }
     return enrichImageError(message);
 }
 function enrichImageError(message) {
@@ -468,6 +479,9 @@ function subagentModelEnv() {
     const override = agentModelOverride();
     return override ? { CLAUDE_CODE_SUBAGENT_MODEL: override, CLAUDE_CODE_SUBAGENT_MODEL_FORCE: "1" } : {};
 }
+function claudeConfigDir() {
+    return process.env.CLAUDE_CONFIG_DIR || resolve(process.env.HOME || homedir(), ".claude");
+}
 function claudePlanDir() {
     return resolve(process.env.HOME || homedir(), ".claude", "plans");
 }
@@ -565,14 +579,35 @@ function sdkResultErrorMessage(msg) {
 function turnResultError(state, msg) {
     return state.refusedWithoutFallback ? undefined : sdkResultError(msg);
 }
+class SdkResultError extends Error {
+    providerFailure;
+    name = "SdkResultError";
+    constructor(message, 
+    /** The model provider refused or failed the request, rather than the turn's own work failing. */
+    providerFailure) {
+        super(`Claude Code returned an error result: ${message}`);
+        this.providerFailure = providerFailure;
+    }
+}
+// What the request's own content caused (an unreadable image, a malformed or
+// oversized request): sending the same message again would fail the same way, so
+// it keeps its own remediation instead of the provider-failure message.
+const REQUEST_CONTENT_STATUSES = [400, 413, 422];
+function isProviderFailureResult(msg) {
+    if (msg.subtype !== "success") {
+        return false;
+    }
+    const status = msg.api_error_status ?? Number(/^API Error: (\d{3})\b/.exec(msg.result)?.[1]);
+    if (REQUEST_CONTENT_STATUSES.includes(status)) {
+        return false;
+    }
+    return typeof msg.api_error_status === "number" || msg.result.startsWith("API Error");
+}
 function sdkResultError(msg) {
     if (msg.type !== "result" || !msg.is_error) {
         return undefined;
     }
-    const message = sdkResultErrorMessage(msg);
-    const error = new Error(`Claude Code returned an error result: ${message}`);
-    error.name = "SdkResultError";
-    return error;
+    return new SdkResultError(sdkResultErrorMessage(msg), isProviderFailureResult(msg));
 }
 // When the bridge closes the sandbox CLI's stdin (its permission control
 // channel) — on abort/replace/timeout — while the CLI is still alive (a long
@@ -637,6 +672,22 @@ export function isControlChannelDeny(msg) {
     }
     return false;
 }
+// A tool result's prefix sent for the history replay, which keeps only its head.
+const TOOL_OUTCOME_TEXT_CHARS = 2000;
+/** How each tool call answered in a `user` message came out, bounded to what history replays. */
+export function toolOutcomesInMessage(msg) {
+    if (msg.type !== "user")
+        return [];
+    return messageContentBlocks(msg).flatMap((block) => block.type === "tool_result" && typeof block.tool_use_id === "string"
+        ? [
+            {
+                toolUseId: block.tool_use_id,
+                isError: block.is_error === true,
+                text: toolResultText(block.content).slice(0, TOOL_OUTCOME_TEXT_CHARS),
+            },
+        ]
+        : []);
+}
 function controlChannelClosedError() {
     const error = new Error("The sandbox tool control-channel closed mid-turn — work outlived the turn it was started in " +
         "(a backgrounded command or a subagent waking the model back up), so further tool calls were " +
@@ -686,6 +737,15 @@ export function isContextOverflowRefusal(msg) {
     }
     return OVERFLOW_REFUSAL_LEADS.some((lead) => text.startsWith(lead));
 }
+/**
+ * True when an assistant message is the CLI's own report of a failed model
+ * request ("API Error: 402 Insufficient credits…", "API Error: Server error
+ * mid-response…"), not anything the model wrote. The CLI writes it for a
+ * terminal user: a `<synthetic>` model and the request's `error` class.
+ */
+function isApiErrorMessage(msg) {
+    return msg.type === "assistant" && msg.error !== undefined && msg.message.model === "<synthetic>";
+}
 /** Content blocks of an assistant/user SDK message; [] for other shapes. */
 function messageContentBlocks(msg) {
     const content = msg.message?.content;
@@ -1084,8 +1144,7 @@ export class BridgeJobExecutor {
         this.turnEndExitGuardMs = dependencies.turnEndExitGuardMs ?? DEFAULT_TURN_END_EXIT_GUARD_MS;
         this.now = dependencies.now ?? Date.now;
         this.readUsageBaseline =
-            dependencies.readUsageBaseline ??
-                ((sessionId) => readUsageBaseline(sessionId, process.env.CLAUDE_CONFIG_DIR || resolve(process.env.HOME || homedir(), ".claude")));
+            dependencies.readUsageBaseline ?? ((sessionId) => readUsageBaseline(sessionId, claudeConfigDir()));
         this.stalledCliExitMs = dependencies.stalledCliExitMs ?? STALLED_CLI_EXIT_MS;
         this.settleWorkspace = dependencies.settleWorkspace ?? (() => settleWorkspaceAfterTasks());
         this.catchUpWithMain = dependencies.catchUpWithMain;
@@ -1122,12 +1181,14 @@ export class BridgeJobExecutor {
             replayAttempt = prepareSessionAttempt({
                 requestPrompt: request.prompt,
                 reminder: request.reminder,
+                delivered: request.mainSync?.delivered,
                 history: job.history,
                 loaded,
                 leadingCommand: request.leadingCommand,
             });
-            attempt = (await this.interruptedTurnAttempt(job, replayAttempt)) ?? replayAttempt;
+            attempt = (await this.interruptedTurnAttempt(job, replayAttempt, request.mainSync)) ?? replayAttempt;
             state.usedBoundary = attempt.usedBoundary;
+            state.requestPrompt = request.prompt;
             state.detachedSession = attempt.detachedSession === true;
             result.attemptedRehydration = attempt.attemptedRehydration;
             this.recordAttemptContextSource(job, attempt);
@@ -1138,6 +1199,7 @@ export class BridgeJobExecutor {
             const repaired = await this.fallbackAttempt(job, controls, { request, attempt, replayAttempt }, state, error);
             if (repaired && controls.isActive()) {
                 const repairState = createBridgeJobState();
+                repairState.detachedSession = repaired.detachedSession === true;
                 let repairResult = { costUsd: 0, attemptedRehydration: repaired.attemptedRehydration };
                 try {
                     repairResult = await this.runAttempt(job, controls, repairState, repaired);
@@ -1163,9 +1225,9 @@ export class BridgeJobExecutor {
         return await this.invalidResumeFallbackAttempt(job, controls, tried.request, tried.attempt, state, error);
     }
     /** The turn's own session, when Convex sent again a turn this bridge was running when it went down. */
-    async interruptedTurnAttempt(job, replay) {
+    async interruptedTurnAttempt(job, replay, mainSync) {
         const inFlight = await this.inFlightTurns.load(job.threadId).catch(() => undefined);
-        const resumed = interruptedResumeAttempt(replay, { jobTurnId: job.turnId, inFlight });
+        const resumed = interruptedResumeAttempt(replay, { jobTurnId: job.turnId, inFlight, mainSync });
         if (inFlight && !resumed) {
             await this.inFlightTurns.clear(job.threadId, inFlight.turnId).catch(() => undefined);
         }
@@ -1178,7 +1240,7 @@ export class BridgeJobExecutor {
     async interruptedResumeFallbackAttempt(job, replay, state, error) {
         if (!replay ||
             state.sawUserVisibleSdkMessage ||
-            (error instanceof Error && error.name === "SdkResultError") ||
+            (error instanceof Error && error.name === "SdkResultError" && !isCliResumeRefusal(error)) ||
             !isResumeSessionError(error)) {
             return null;
         }
@@ -1216,17 +1278,21 @@ export class BridgeJobExecutor {
             leadingSkillCommand(job.prompt, (await readSessionSkills(bridgeRuntimeFiles.projectRoot())) ?? []);
         let requestPrompt = verbatim ?? applyCurrentSenderAttribution(job.prompt, job.currentSender);
         // A command must stay the leading token, so it carries no note: the news waits for the next turn.
-        const reminder = turnReminder(job, verbatim, verbatim === null ? mainSyncReminder(mainSync) : undefined);
+        const syncNote = verbatim === null ? mainSyncReminder(mainSync) : undefined;
+        const reminder = turnReminder(job, verbatim, syncNote);
         if (job.attachments && job.attachments.length > 0) {
             requestPrompt += await this.prepareAttachments(job.attachments, "message");
         }
         if (!controls.isActive()) {
             return null;
         }
-        if (verbatim === null) {
-            await mainSync?.told();
-        }
-        return { prompt: requestPrompt, ...(reminder ? { reminder } : {}), leadingCommand: verbatim !== null };
+        return {
+            prompt: requestPrompt,
+            ...(reminder ? { reminder } : {}),
+            leadingCommand: verbatim !== null,
+            // Told only when an attempt carrying the note is sent (`runQueryOnce`).
+            ...(mainSync && syncNote ? { mainSync: { reminder: syncNote, delivered: mainSync.told } } : {}),
+        };
     }
     /**
      * The reviewer's prompt: the brief Convex wrote, with the evidence block this
@@ -1383,18 +1449,29 @@ export class BridgeJobExecutor {
         if (!controls.isActive()) {
             return { kind: "cancelled", costUsd: result.costUsd, model, modelUsage };
         }
+        const shown = userFacingTurnError(error);
+        if (shown !== errorMessage(error)) {
+            console.error(`[BridgeJob] turn failed for thread ${job.threadId}: ${errorMessage(error)}`);
+        }
         return {
             kind: "errored",
             costUsd: result.costUsd,
             model,
             modelUsage,
-            errors: [userFacingTurnError(errorMessage(error))],
+            errors: [shown],
         };
     }
     usageBaselineFor(attempt) {
         const resumed = attempt.resumeOptions.resume;
         return resumed ? this.readUsageBaseline(resumed) : Promise.resolve(undefined);
     }
+    alignResumedTranscript(attempt) {
+        const resumed = attempt.resumeOptions.resume;
+        if (!resumed) {
+            return Promise.resolve();
+        }
+        return alignServedModels(resumed, claudeConfigDir());
+    }
     async awaitReplacedCliExit(next) {
         if (next.resumeOptions.resume && this.stalledCliExitMs > 0) {
             await new Promise((resolve) => setTimeout(resolve, this.stalledCliExitMs));
@@ -1460,7 +1537,7 @@ export class BridgeJobExecutor {
     async invalidResumeFallbackAttempt(job, controls, request, attempt, state, error) {
         if (!attempt.usedBoundary ||
             state.sawUserVisibleSdkMessage ||
-            (error instanceof Error && error.name === "SdkResultError") ||
+            (error instanceof Error && error.name === "SdkResultError" && !isCliResumeRefusal(error)) ||
             !isResumeSessionError(error)) {
             return null;
         }
@@ -1480,6 +1557,7 @@ export class BridgeJobExecutor {
         return {
             prompt: buildRehydratedPrompt(rebuilt.prompt, job.history),
             ...(rebuilt.reminder ? { reminder: rebuilt.reminder } : {}),
+            ...(rebuilt.reminder && rebuilt.mainSync ? { delivered: rebuilt.mainSync.delivered } : {}),
             attemptedRehydration: true,
             resumeOptions: {},
         };
@@ -1651,6 +1729,7 @@ export class BridgeJobExecutor {
         // so a stall that lands after a clean result still contributes its snapshot.
         state.queryModelUsage = new Map();
         state.queryUsageBaseline = await this.usageBaselineFor(attempt);
+        await this.alignResumedTranscript(attempt);
         const mcpServers = await this.resolveMcpServers(job);
         const skills = await readSessionSkills(bridgeRuntimeFiles.projectRoot());
         const autoCompactWindow = autoCompactWindowForModel(model);
@@ -1772,6 +1851,7 @@ export class BridgeJobExecutor {
             },
             ...attempt.resumeOptions,
         };
+        await markDelivered(attempt, controls);
         const query = this.sdk.query({ prompt: attempt.prompt, reminder: attempt.reminder, options });
         controls.reloadMcpServers = () => this.reloadMcpServers(job, query);
         let queryClosed = false;
@@ -2077,11 +2157,17 @@ export class BridgeJobExecutor {
             state.currentTurnTools = [];
             state.postedAssistantEvent = true;
             await this.relay.assistantEvent(target, msg, state.model);
+            return;
+        }
+        const outcomes = toolOutcomesInMessage(msg);
+        if (outcomes.length > 0) {
+            await this.relay.toolOutcomes(target, outcomes);
         }
     }
     /**
      * A message consumed here and never relayed or counted as the agent's work:
-     * a provider refusal for size, or part of a model refusal.
+     * a provider refusal for size, the CLI's report of a failed model request, or
+     * part of a model refusal.
      */
     droppedBeforeRelay(job, state, msg) {
         // Drop the size refusal outright. A recovered turn must not leave a raw
@@ -2103,6 +2189,22 @@ export class BridgeJobExecutor {
             state.turnText = "";
             return true;
         }
+        if (isApiErrorMessage(msg)) {
+            // The provider's words, never the product's: a turn that recovers shows
+            // nothing, and one that fails says so once through the error outcome.
+            const text = messageContentBlocks(msg)
+                .map((block) => (typeof block.text === "string" ? block.text : ""))
+                .join(" ");
+            console.error(`[BridgeJob] model request failed for thread ${job.threadId}: ${text}`);
+            this.recordTurnEvent({
+                threadId: job.threadId,
+                turnId: job.turnId,
+                event: "api_error",
+                detail: { error: msg.error, text },
+            });
+            state.turnText = "";
+            return true;
+        }
         return this.observeModelRefusal(job, state, msg);
     }
     /**
@@ -2216,6 +2318,10 @@ export class BridgeJobExecutor {
         if (state.detachedSession) {
             return;
         }
+        if (reason === "abort") {
+            await this.keepCancelledTurn(job, controls, state);
+            return;
+        }
         if (!state.usedBoundary && !state.inProgressSession.sawSessionId) {
             return;
         }
@@ -2227,6 +2333,25 @@ export class BridgeJobExecutor {
         });
         await this.sessionStore.clear(job.threadId, { runToken: controls.runToken, reason });
     }
+    // A cancel (Stop, a replacing message, an answered card) is not a broken
+    // session: the next turn resumes what this one completed (`buildCancelBoundary`).
+    async keepCancelledTurn(job, controls, state) {
+        const boundary = buildCancelBoundary({
+            inProgress: state.inProgressSession,
+            resumed: state.usedBoundary,
+            request: state.requestPrompt,
+            nowMs: this.now(),
+        });
+        this.recordTurnEvent({
+            threadId: job.threadId,
+            turnId: job.turnId,
+            event: "cancel_resume_point",
+            detail: { resumeFrom: state.inProgressSession.cancelPoint ? "cancelled_turn" : "previous_turn" },
+        });
+        if (boundary) {
+            await this.sessionStore.save(job.threadId, boundary, { runToken: controls.runToken });
+        }
+    }
     // Parks the turn on a blocking dashboard prompt. An unanswered prompt must
     // NOT error the turn: the wait window ending resolves to `unanswered` so the
     // caller can deny the tool gracefully — the agent ends its turn cleanly and
@@ -2641,6 +2766,12 @@ function registerOrAutomateCasting(job, controls, toolName, command) {
     controls.avatarAwaitingCasting = created;
     return null;
 }
+/** The last step before the prompt goes out: a turn stopped before here never carried its note. */
+async function markDelivered(attempt, controls) {
+    if (attempt.delivered && controls.isActive()) {
+        await attempt.delivered();
+    }
+}
 /** Baker's notes for the turn, sent as their own block beside the prompt (see `SessionAttempt.reminder`). */
 function turnReminder(job, verbatim, mainSync) {
     const reminders = [