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

package/dist/hono/bridge-job.js

@@ -25,7 +25,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";
@@ -423,10 +424,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) {
@@ -467,6 +478,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");
 }
@@ -564,14 +578,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
@@ -685,6 +720,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;
@@ -1060,6 +1104,7 @@ export class BridgeJobExecutor {
     turnEndExitGuardMs;
     now;
     readUsageBaseline;
+    alignServedModels;
     stalledCliExitMs;
     readFlowTree;
     settleWorkspace;
@@ -1081,8 +1126,8 @@ 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.alignServedModels = dependencies.alignServedModels;
         this.stalledCliExitMs = dependencies.stalledCliExitMs ?? STALLED_CLI_EXIT_MS;
         this.settleWorkspace = dependencies.settleWorkspace ?? (() => settleWorkspaceAfterTasks());
         this.readFlowTree =
@@ -1123,6 +1168,7 @@ export class BridgeJobExecutor {
             });
             attempt = (await this.interruptedTurnAttempt(job, replayAttempt)) ?? replayAttempt;
             state.usedBoundary = attempt.usedBoundary;
+            state.requestPrompt = request.prompt;
             state.detachedSession = attempt.detachedSession === true;
             result.attemptedRehydration = attempt.attemptedRehydration;
             this.recordAttemptContextSource(job, attempt);
@@ -1133,6 +1179,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);
@@ -1173,7 +1220,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;
         }
@@ -1368,18 +1415,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 this.alignServedModels ? this.alignServedModels(resumed) : alignServedModels(resumed, claudeConfigDir());
+    }
     async awaitReplacedCliExit(next) {
         if (next.resumeOptions.resume && this.stalledCliExitMs > 0) {
             await new Promise((resolve) => setTimeout(resolve, this.stalledCliExitMs));
@@ -1445,7 +1503,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;
         }
@@ -1636,6 +1694,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);
@@ -2066,7 +2125,8 @@ export class BridgeJobExecutor {
     }
     /**
      * 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
@@ -2088,6 +2148,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);
     }
     /**
@@ -2201,6 +2277,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;
         }
@@ -2212,6 +2292,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