@agent-native/core 0.204.0 → 0.204.1-nightly-20261008034100

package/dist/agent/production-agent.js

@@ -28,25 +28,29 @@ import { parseServiceIdentityEmail } from "../org/service-identity.js";
 import { ServicePrincipalRefusedError } from "../org/service-principal-guard.js";
 import { completeRun as completeProgressRun, startRun as startProgressRun, updateRunProgress, } from "../progress/registry.js";
 import { readOptionalKeyCache, writeOptionalKeyCache, } from "../secrets/optional-key-cache.js";
-import { COMPACT_PROMPT_RESOURCES_TOTAL_MAX_CHARS, preloadJevContextForPrompt, } from "../server/agent-chat/prompt-resources.js";
+import { COMPACT_PROMPT_RESOURCES_TOTAL_MAX_CHARS, preloadJevContextWithStatus, } from "../server/agent-chat/prompt-resources.js";
 import { isRuntimeVisibleScope, parseSkillFrontmatter, } from "../server/agent-chat/skill-frontmatter.js";
+import { captureError } from "../server/capture-error.js";
 import { canUseDeployCredentialFallbackForRequest, getProviderCredentialAuthFailure, isBuilderGatewayDeployConfigured, readDeployCredentialEnv, resolveBuilderGatewayAuth, } from "../server/credential-provider.js";
 import { orderCredentialScopes } from "../server/credential-read-order.js";
 import { readBody } from "../server/h3-helpers.js";
 import { resolveHostedHarnessPolicy } from "../server/hosted-harness-policy.js";
 import { isPersonalProviderKeyUseRestricted, isPersonalProviderPolicyKey, PERSONAL_PROVIDER_KEYS_RESTRICTED_ERROR_CODE, PERSONAL_PROVIDER_KEYS_RESTRICTED_MESSAGE, } from "../server/personal-provider-key-policy.js";
-import { assertRequestActionSurfaceIsolation, getRequestRunContext, ensureRequestRunContext, getRequestContext, getRequestOrgId, getRequestUserEmail, runWithRequestContext, } from "../server/request-context.js";
+import { assertRequestActionSurfaceIsolation, getRequestRunContext, ensureRequestRunContext, getRequestContext, getRequestAuthCapability, getRequestOrgId, getRequestUserEmail, runWithRequestContext, } from "../server/request-context.js";
 import { secretKeyNames } from "../server/secret-key-aliases.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { retryContextFromRequest, } from "../shared/agent-chat-run-not-started.js";
 import { ANALYTICS_CLIENT_PLATFORM_BODY_FIELD } from "../shared/analytics-platform.js";
+import { isContextDegraded, preloadedContextUnavailableNote, readReportedContextStatus, screenContextUnavailableNote, SELECTION_CONTEXT_UNAVAILABLE_NOTE, worstContextStatus, } from "../shared/context-status.js";
 import { parseBase64DataUrl } from "../shared/data-url.js";
 import { stripDiagnosticSnippets } from "../shared/diagnostic-snippet.js";
 import { isReasoningEffort, normalizeReasoningEffortForRequest, stepDownReasoningEffort, } from "../shared/reasoning-effort.js";
 import { SYNTHETIC_TRAFFIC_BETA_E2E, SYNTHETIC_TRAFFIC_HEADER, } from "../shared/test-traffic.js";
 import { actionPreparationContinuationNote } from "./action-continuation-guidance.js";
 import { drainAgentWarnings, formatAgentWarningsForToolResult, } from "./action-warnings.js";
+import { CONTINUE_UNAVAILABLE_CODE, } from "./auto-continue.js";
 import { clipHead } from "./clip-text.js";
+import { connectionRequiredMessage, priorConnectionContextNote, resolvePriorConnectionNote, } from "./connection-required-note.js";
 import { buildSystemManifestSections, readContextXraySystemSections, } from "./context-xray/manifest.js";
 import { AGENT_CHAT_BACKGROUND_RUN_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, backgroundRuntimeDiagnosticDetail, dispatchPathTargetsNetlifyBackgroundFunction, isAgentChatDurableBackgroundEnabled, isAgentChatForegroundSelfChainEnabled, isInBackgroundFunctionRuntime, resolveAgentChatProcessRunDispatchPath, shouldUseBackgroundFunctionTimeoutForWorker, } from "./durable-background.js";
 import { applyContextXrayTransformForIteration } from "./engine/context-directives-transform.js";
@@ -226,6 +230,10 @@ export function normalizeChatScope(value) {
 function appStateKeyForBrowserTab(key, browserTabId) {
     return browserTabId ? `${key}:${browserTabId}` : key;
 }
+/** `readAppState` throws when the request has no identity: that is no user to read for, not a failed read. */
+function hasAppStateIdentity() {
+    return Boolean(getRequestUserEmail() || getRequestAuthCapability());
+}
 async function readAppStateForBrowserTab(key, browserTabId) {
     if (!browserTabId)
         return (await readAppState(key));
@@ -5108,6 +5116,7 @@ export async function runAgentLoop(opts) {
                 let result;
                 let chatUIResult;
                 let isError = false;
+                let toolErrorCode;
                 let mcpApp;
                 let toolResultImages;
                 let toolArtifacts = [];
@@ -5334,12 +5343,15 @@ export async function runAgentLoop(opts) {
                     }
                 }
                 catch (err) {
+                    toolErrorCode = isActionContractError(err)
+                        ? err.errorCode
+                        : undefined;
                     if (signal.aborted) {
                         result = INTERRUPTED_TOOL_RESULT_MARKER;
                     }
                     else if (isAgentConnectionRequiredError(err)) {
-                        const message = sanitizeToolErrorValue(err.message) ||
-                            `Connect ${err.provider} to continue.`;
+                        const message = connectionRequiredMessage(sanitizeToolErrorValue(err.message) ||
+                            `Connect ${err.provider} to continue.`, err.reason);
                         result = sanitizeToolErrorValue(err.toolResult || message);
                         requestedConnection ??= {
                             requestId: randomUUID(),
@@ -5443,6 +5455,7 @@ export async function runAgentLoop(opts) {
                     input: toolCall.input,
                     result,
                     ...(isError ? { isError: true } : {}),
+                    ...(toolErrorCode ? { errorCode: toolErrorCode } : {}),
                     ...(isError
                         ? { completedSideEffect: false }
                         : receipt
@@ -6676,12 +6689,28 @@ export function createProductionAgentHandler(options) {
                 return { error: "Invalid request body" };
             }
         }
-        const { message, history = [], structuredHistory, references = [], threadId, attachments, displayMessage, parentId, queuedMessageId, queuedMessageClaimId, agentKitMessageId: requestedAgentKitMessageId, internalContinuation, autoContinueOfRunId: requestedAutoContinueOfRunId, turnId: requestTurnId, model: requestModel, engine: requestEngine, effort: requestEffort, browserTabId, scope, harness: requestHarness, trackInRunsTray, skipPendingSelectionContext, } = body;
-        const autoContinueOfRunId = internalContinuation === true &&
-            typeof requestedAutoContinueOfRunId === "string" &&
-            requestedAutoContinueOfRunId.trim().length <= 200
-            ? requestedAutoContinueOfRunId.trim() || undefined
+        const { message, history = [], structuredHistory, references = [], threadId, attachments, displayMessage, parentId, queuedMessageId, queuedMessageClaimId, agentKitMessageId: requestedAgentKitMessageId, internalContinuation, autoContinueOfRunId: requestedAutoContinueOfRunId, continueOfRunId: requestedContinueOfRunId, turnId: requestTurnId, model: requestModel, engine: requestEngine, effort: requestEffort, browserTabId, scope, harness: requestHarness, trackInRunsTray, skipPendingSelectionContext, } = body;
+        const continuedRunId = (requested) => internalContinuation === true &&
+            typeof requested === "string" &&
+            requested.trim().length <= 200
+            ? requested.trim() || undefined
             : undefined;
+        const autoContinueOfRunId = continuedRunId(requestedAutoContinueOfRunId);
+        // The stopped run this request resumes in its own turn, from the turn's
+        // history and journal, whether the chat or a person asked.
+        const continueOf = autoContinueOfRunId
+            ? { runId: autoContinueOfRunId, trigger: "auto" }
+            : (() => {
+                const runId = continuedRunId(requestedContinueOfRunId);
+                return runId ? { runId, trigger: "manual" } : undefined;
+            })();
+        const continueRefusal = (code) => ({
+            error: continueOf?.trigger === "manual"
+                ? "This turn can no longer be continued."
+                : "This turn will not continue automatically.",
+            code,
+            retryable: false,
+        });
         if (requestEngine !== undefined && typeof requestEngine !== "string") {
             setResponseStatus(event, 400);
             return { error: "engine must be a string" };
@@ -6834,6 +6863,7 @@ export function createProductionAgentHandler(options) {
         });
         let jevPromptCandidates = [];
         let jevFallbackCandidateIds = [];
+        const preparedReferenceStatus = readReportedContextStatus(preparedRequest);
         if (preparedRequest) {
             if (typeof preparedRequest.message === "string" &&
                 preparedRequest.message.trim().length > 0) {
@@ -7089,7 +7119,7 @@ export function createProductionAgentHandler(options) {
             configuredEffort: options.reasoningEffort,
         });
         options.onEngineResolved?.(engine, effectiveModel);
-        console.log(`[agent-chat] resolved engine=${engine.name} model=${effectiveModel} requestModel=${requestModel ?? "(none)"} requestEngine=${requestEngine ?? "(none)"} modelSource=${modelSelectionSource} turnId=${requestTurnId ?? "(none)"}`);
+        console.log(`[agent-chat] resolved engine=${engine.name} model=${effectiveModel} requestModel=${requestModel ?? "(none)"} requestEngine=${requestEngine ?? "(none)"} modelSource=${modelSelectionSource} engineDefault=${engine.defaultModel} effort=${reasoningEffort ?? "unset"} turnId=${requestTurnId ?? "(none)"}`);
         if (!(await isResolvedEngineUsableForRequest(engine, {
             apiKey: effectiveApiKey,
             credentialIdentity,
@@ -7180,6 +7210,17 @@ export function createProductionAgentHandler(options) {
                 return buildCurrentTimeUserContext();
             }
         })();
+        // `empty` (no navigation yet) stays silent; a timeout or a throw adds a
+        // note, because the model would otherwise read it as an app with no page.
+        const screenStatuses = { screen: "empty", url: "empty", selection: "empty" };
+        // Once a cap fires the model has the fallback note, so a read that
+        // resolves late must not change what the trace says it saw.
+        const noteScreenStatus = (source, status) => {
+            if (screenStatuses[source] !== "timed_out") {
+                screenStatuses[source] = status;
+            }
+        };
+        const screenUnavailableNote = screenContextUnavailableNote(Boolean(surfacedRequestActions["view-screen"]));
         const screenContextThunk = () => (async () => {
             const screenStart = Date.now();
             try {
@@ -7194,18 +7235,24 @@ export function createProductionAgentHandler(options) {
                         const screenText = typeof result === "string"
                             ? result
                             : JSON.stringify(result, null, 2);
+                        noteScreenStatus("screen", "ok");
                         return `\n\n<current-screen>\n${capScreenContext(screenText)}\n</current-screen>`;
                     }
                 }
                 else {
                     const navigation = await readAppStateForBrowserTab("navigation", requestBrowserTabId);
                     if (navigation) {
+                        noteScreenStatus("screen", "ok");
                         return `\n\n<current-screen>\n${capScreenContext(JSON.stringify(navigation, null, 2))}\n</current-screen>`;
                     }
                 }
             }
-            catch {
-                // DB not ready or no navigation state — skip silently
+            catch (error) {
+                if (!hasAppStateIdentity())
+                    return "";
+                noteScreenStatus("screen", "failed");
+                console.warn("[agent-chat] current-screen context unavailable:", error instanceof Error ? error.message : String(error));
+                return screenUnavailableNote;
             }
             finally {
                 setupMarks.screenMs = Date.now() - screenStart;
@@ -7241,11 +7288,16 @@ export function createProductionAgentHandler(options) {
                         if (settingsPage)
                             lines.push(settingsPage);
                     }
+                    noteScreenStatus("url", "ok");
                     return `\n\n<current-url>\n${lines.join("\n")}\n</current-url>`;
                 }
             }
-            catch {
-                // DB not ready — skip silently
+            catch (error) {
+                if (!hasAppStateIdentity())
+                    return "";
+                noteScreenStatus("url", "failed");
+                console.warn("[agent-chat] current-url context unavailable:", error instanceof Error ? error.message : String(error));
+                return screenUnavailableNote;
             }
             return "";
         })();
@@ -7260,12 +7312,17 @@ export function createProductionAgentHandler(options) {
                 const capturedAt = typeof sel.capturedAt === "number" ? sel.capturedAt : 0;
                 if (Date.now() - capturedAt > SELECTION_TTL_MS)
                     return "";
+                noteScreenStatus("selection", "ok");
                 return (`\n\nThe user has selected the following text and pressed Cmd I to focus the agent. ` +
                     `Treat this as the immediate context to act on:\n` +
                     `<selection>\n${capSelectionContext(sel.text)}\n</selection>`);
             }
-            catch {
-                // DB not ready — skip silently
+            catch (error) {
+                if (!hasAppStateIdentity())
+                    return "";
+                noteScreenStatus("selection", "failed");
+                console.warn("[agent-chat] selection context unavailable:", error instanceof Error ? error.message : String(error));
+                return SELECTION_CONTEXT_UNAVAILABLE_NOTE;
             }
             return "";
         })();
@@ -7376,7 +7433,7 @@ export function createProductionAgentHandler(options) {
             source: "default",
         };
         const systemPromptTimeoutError = new Error("system prompt preparation timed out before the agent could start");
-        let [systemPrompt, timeBlock, screenBlock, urlBlock, selectionBlock, filesContext, loopSettings, enrichedMessage, jevContextCredentials,] = await Promise.all([
+        let [systemPrompt, timeBlock, screenBlock, urlBlock, selectionBlock, filesContext, loopSettings, enrichedMessage, jevContextCredentials, priorConnection,] = await Promise.all([
             presendCap("systemPrompt", systemPromptThunk, "", 13000, () => {
                 // An empty configured prompt is valid, but an empty timeout fallback
                 // is not: required app instructions must either finish or fail before
@@ -7385,13 +7442,30 @@ export function createProductionAgentHandler(options) {
                 systemPromptError ??= systemPromptTimeoutError;
             }),
             presendCap("time", timeContextThunk, "", 9000),
-            presendCap("screen", screenContextThunk, "", 9000),
-            presendCap("url", urlContextThunk, "", 9000),
-            presendCap("selection", selectionContextThunk, "", 9000),
+            presendCap("screen", screenContextThunk, screenUnavailableNote, 9000, () => {
+                screenStatuses.screen = "timed_out";
+            }),
+            presendCap("url", urlContextThunk, screenUnavailableNote, 9000, () => {
+                screenStatuses.url = "timed_out";
+            }),
+            presendCap("selection", selectionContextThunk, SELECTION_CONTEXT_UNAVAILABLE_NOTE, 9000, () => {
+                screenStatuses.selection = "timed_out";
+            }),
             presendCap("files", filesContextThunk, "", 12000),
             presendCap("loopSettings", loopSettingsThunk, fallbackLoopSettings, 9000),
             presendCap("enrichedMessage", enrichedMessageThunk, requestMessage, 9000),
             presendCap("jevContextCredentials", () => getJevContextCredentials(ownerEmail ?? getRequestUserEmail()), { apiKey: undefined, personalApiKey: undefined, builderAuth: null }, 9000),
+            presendCap("priorConnection", 
+            // The foreground of a dispatched run never prompts the model; the
+            // worker re-reads, so reading here would pay for it twice.
+            () => threadId && !dispatchToBackground
+                ? resolvePriorConnectionNote({
+                    threadId,
+                    orgId: getRequestOrgId() ?? null,
+                    appId: options.appId,
+                    excludeRunId: backgroundRunMarker?.runId,
+                })
+                : Promise.resolve({ status: "none" }), { status: "unreadable", error: "timed out" }, 9000),
         ]);
         setupMark("ctxAll");
         workerStep("context_all");
@@ -7409,7 +7483,21 @@ export function createProductionAgentHandler(options) {
                 },
             });
         }
+        // Screen and URL share one note; the same failure needn't be told twice.
+        if (urlBlock === screenBlock)
+            urlBlock = "";
         const screenContext = timeBlock + screenBlock + urlBlock + selectionBlock;
+        // Referenced agents don't share this run's tools, so a note telling the
+        // model to call view-screen would send them looking for a tool they lack.
+        const withoutUnavailableNote = (block) => block === screenUnavailableNote ||
+            block === SELECTION_CONTEXT_UNAVAILABLE_NOTE
+            ? ""
+            : block;
+        const referencedAgentContext = timeBlock +
+            withoutUnavailableNote(screenBlock) +
+            withoutUnavailableNote(urlBlock) +
+            withoutUnavailableNote(selectionBlock);
+        const screenStatus = worstContextStatus(...Object.values(screenStatuses));
         const surfacedActionRegistry = requestMode === "plan"
             ? createPlanModeActionRegistry(surfacedRequestActions)
             : surfacedRequestActions;
@@ -7434,7 +7522,7 @@ export function createProductionAgentHandler(options) {
         const jevContextMaxChars = options.jevContextCompact
             ? Math.max(0, COMPACT_PROMPT_RESOURCES_TOTAL_MAX_CHARS - systemPrompt.length - 2)
             : undefined;
-        const [requestTools, jevContext] = await Promise.all([
+        const [requestTools, jevPreload] = await Promise.all([
             preloadJevTools({
                 request: jevRequestContext,
                 skip: Boolean(internalContinuation || dispatchToBackground),
@@ -7447,7 +7535,7 @@ export function createProductionAgentHandler(options) {
                 availableTools: availableRequestTools,
                 readOnlyOnly: requestMode === "plan",
             }),
-            preloadJevContextForPrompt({
+            preloadJevContextWithStatus({
                 request: jevRequestContext,
                 appId: options.appId,
                 owner: ownerEmail ?? undefined,
@@ -7464,8 +7552,23 @@ export function createProductionAgentHandler(options) {
                 fallbackCandidateIds: jevFallbackCandidateIds,
             }),
         ]);
+        const jevContext = jevPreload.context;
         if (jevContext)
             systemPrompt = `${systemPrompt}\n\n${jevContext}`;
+        const prefetchStatus = worstContextStatus(jevPreload.status, preparedReferenceStatus);
+        if (runContext) {
+            runContext.contextStatus = {
+                prefetch: prefetchStatus,
+                screen: screenStatus,
+            };
+        }
+        // Per-turn, so the stable system prompt prefix keeps caching.
+        const prefetchNote = prefetchStatus && isContextDegraded(prefetchStatus)
+            ? preloadedContextUnavailableNote(prefetchStatus, {
+                // The other source delivered, so only part of the context is missing.
+                partial: jevPreload.status === "ok" || preparedReferenceStatus === "ok",
+            })
+            : "";
         const contextXraySystemSections = [
             ...readContextXraySystemSections(event),
             ...(jevContext
@@ -7508,7 +7611,12 @@ export function createProductionAgentHandler(options) {
             ? "\n\n<plan-mode-note>Connected external agent mentions were not called because Plan mode is read-only. Mention that they can be called after the user switches to Act mode if the plan needs them.</plan-mode-note>"
             : "";
         const userContent = buildUserContentWithAttachments({
-            text: enrichedMessage + screenContext + filesContext + planModeAgentNote,
+            text: enrichedMessage +
+                screenContext +
+                prefetchNote +
+                priorConnectionContextNote(priorConnection) +
+                filesContext +
+                planModeAgentNote,
             attachments: requestAttachments,
         });
         const historyMessages = structuredHistoryToEngineMessages(structuredHistory) ??
@@ -7603,9 +7711,7 @@ export function createProductionAgentHandler(options) {
                     ...(dispatchToBackground
                         ? { dispatchPayload: JSON.stringify(body) }
                         : {}),
-                    ...(autoContinueOfRunId
-                        ? { autoContinueOf: autoContinueOfRunId }
-                        : {}),
+                    ...(continueOf ? { continueOf } : {}),
                 });
             }
             catch (error) {
@@ -7621,14 +7727,10 @@ export function createProductionAgentHandler(options) {
                 await setupResumeClaim?.release();
                 return { ok: true, stopped: true };
             }
-            if (slot.autoContinueRefused) {
+            if (slot.continueRefused) {
                 await setupResumeClaim?.release();
                 setResponseStatus(event, 409);
-                return {
-                    error: "This turn will not continue automatically.",
-                    code: slot.autoContinueRefused,
-                    retryable: false,
-                };
+                return continueRefusal(slot.continueRefused);
             }
             if (slot.completedRunId) {
                 const stream = await replayCompletedTurn(threadId, effectiveTurnId);
@@ -7696,21 +7798,31 @@ export function createProductionAgentHandler(options) {
         let turnInputTokens = Number.isFinite(priorTurnInputTokensFromBody)
             ? Math.max(0, priorTurnInputTokensFromBody)
             : 0;
-        // A server successor and an automatic continuation resume the same turn
-        // the same way: the thread's tool calls and results, plus the turn's
+        // A server successor and a continuation, automatic or chosen, resume the
+        // same turn the same way: the thread's tool calls and results, plus the turn's
         // journal of finished steps, so nothing already done is sent again.
-        if ((isChainedBackgroundContinuation || autoContinueOfRunId) &&
-            effectiveThreadId) {
+        if ((isChainedBackgroundContinuation || continueOf) && effectiveThreadId) {
             try {
                 const { getThread } = await import("../chat-threads/store.js");
-                const { resumeThreadHistoryForRequest } = await import("./thread-data-builder.js");
-                const { messages: resumed, foundTurnPrompt } = resumeThreadHistoryForRequest((await getThread(effectiveThreadId))?.threadData);
+                const { latestPromptTurnId, resumeThreadHistoryForRequest } = await import("./thread-data-builder.js");
+                const threadData = (await getThread(effectiveThreadId))?.threadData;
+                const { messages: resumed, foundTurnPrompt } = resumeThreadHistoryForRequest(threadData);
                 // A continuation always follows a stopped run, so a thread without
                 // that turn's prompt means its history was lost, not that there was
                 // none. A successor stays best-effort and resumes from what is there.
-                if (autoContinueOfRunId && !foundTurnPrompt) {
+                if (continueOf && !foundTurnPrompt) {
                     throw new Error(`thread ${effectiveThreadId} has no turn prompt`);
                 }
+                // Resuming takes the thread's newest prompt, so a newer one, even one
+                // whose run never started, would run under this turn's journal.
+                const promptTurnId = continueOf && threadData ? latestPromptTurnId(threadData) : undefined;
+                if (promptTurnId && promptTurnId !== effectiveTurnId) {
+                    if (await updateRunStatusIfRunning(runId, "errored")) {
+                        await setRunTerminalReason(runId, CONTINUE_UNAVAILABLE_CODE);
+                    }
+                    setResponseStatus(event, 409);
+                    return continueRefusal(CONTINUE_UNAVAILABLE_CODE);
+                }
                 if (resumed.length > 0) {
                     const actionPreparationTool = typeof backgroundRunMarker?.actionPreparationTool === "string" &&
                         backgroundRunMarker.actionPreparationTool.trim()
@@ -7720,7 +7832,7 @@ export function createProductionAgentHandler(options) {
                         ? backgroundRunMarker.continuationReason
                         : "run_timeout";
                     const journalRead = await loadPriorTurnToolCallJournal(effectiveThreadId, effectiveTurnId);
-                    if (autoContinueOfRunId && journalRead.status === "unreadable") {
+                    if (continueOf && journalRead.status === "unreadable") {
                         throw new Error(journalRead.error);
                     }
                     const journalNote = journalRead.status === "read" && journalRead.toolCallJournal
@@ -7735,7 +7847,7 @@ export function createProductionAgentHandler(options) {
                 }
             }
             catch (error) {
-                if (autoContinueOfRunId) {
+                if (continueOf) {
                     // The browser's history lacks the stopped run's tool results, so
                     // continuing from it could repeat a step that already finished.
                     console.warn(`[agent-chat] auto-continue history unreadable for thread ${effectiveThreadId}:`, error);
@@ -7767,6 +7879,22 @@ export function createProductionAgentHandler(options) {
                 console.warn(`[agent-chat] history recovery failed for thread ${threadId}; continuing with no prior context:`, err);
             }
         }
+        if (!internalContinuation && !isChainedBackgroundContinuation && threadId) {
+            try {
+                const { loadStoppedPreviousTurnNote } = await import("./previous-turn-note.js");
+                const note = await loadStoppedPreviousTurnNote(threadId, effectiveTurnId);
+                const prompt = messages.at(-1);
+                if (note && prompt?.role === "user") {
+                    prompt.content = [{ type: "text", text: note }, ...prompt.content];
+                }
+            }
+            catch (err) {
+                captureError(err, {
+                    tags: { source: "agent-chat", failureClass: "previous-turn-note" },
+                    extra: { threadId, turnId: effectiveTurnId },
+                });
+            }
+        }
         setupMark("depsThread");
         workerStep("owner_thread");
         if (options.onRunPrepared && !internalContinuation && !isBackgroundWorker) {
@@ -8166,7 +8294,10 @@ export function createProductionAgentHandler(options) {
                                 {
                                     role: "user",
                                     content: [
-                                        { type: "text", text: enrichedMessage + screenContext },
+                                        {
+                                            type: "text",
+                                            text: enrichedMessage + referencedAgentContext,
+                                        },
                                     ],
                                 },
                             ],
@@ -8259,7 +8390,7 @@ export function createProductionAgentHandler(options) {
                         const responseText = await callConnectedAgentReference({
                             agent: ref.name,
                             path: ref.path,
-                            message: enrichedMessage + screenContext,
+                            message: enrichedMessage + referencedAgentContext,
                             send,
                             callAgent,
                             resolveCallerAuth: resolveA2ACallerAuth,
@@ -8416,6 +8547,17 @@ export function createProductionAgentHandler(options) {
                                 : undefined,
                             metadata: {
                                 modelSelectionSource,
+                                // What the request asked for; the loop may lower it on retry.
+                                reasoningEffortRequested: reasoningEffort ?? null,
+                                ...(prefetchStatus
+                                    ? { contextPrefetchStatus: prefetchStatus }
+                                    : {}),
+                                ...(screenStatus
+                                    ? { screenContextStatus: screenStatus }
+                                    : {}),
+                                ...(priorConnection.status !== "none"
+                                    ? { priorConnectionRequest: priorConnection.status }
+                                    : {}),
                                 ...(turnUsageLabel ? { label: turnUsageLabel } : {}),
                                 ...(experimentAssignments.length > 0
                                     ? { experimentAssignments }

package/dist/agent/reaped-run-thread.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Saves the reply of a run the server ended because its worker stopped
+ * (a crash, a killed function) into the thread, the way a run that finishes
+ * saves its own. That worker held the reply only in memory, so without this
+ * the turn's finished tool calls exist only in the run ledger, which is
+ * pruned, and the thread forgets an email already went out.
+ *
+ * A run continued in its turn is saved as the first part of that turn's
+ * reply; one with nothing after it keeps its error. Nothing is saved once a
+ * later turn started or a later prompt was saved, because the reply would
+ * land under that prompt instead of its own.
+ */
+export declare function foldReapedRunIntoThread(runId: string): Promise<void>;

package/dist/agent/reaped-run-thread.js

@@ -0,0 +1,45 @@
+import { getThread, updateThreadData, withThreadDataLock, } from "../chat-threads/store.js";
+import { readStoppedRunForThreadFold } from "./run-store.js";
+import { buildAssistantMessage, extractThreadMeta, foldAssistantTurn, isRunPrompt, normalizeThreadRepository, } from "./thread-data-builder.js";
+/**
+ * Saves the reply of a run the server ended because its worker stopped
+ * (a crash, a killed function) into the thread, the way a run that finishes
+ * saves its own. That worker held the reply only in memory, so without this
+ * the turn's finished tool calls exist only in the run ledger, which is
+ * pruned, and the thread forgets an email already went out.
+ *
+ * A run continued in its turn is saved as the first part of that turn's
+ * reply; one with nothing after it keeps its error. Nothing is saved once a
+ * later turn started or a later prompt was saved, because the reply would
+ * land under that prompt instead of its own.
+ */
+export async function foldReapedRunIntoThread(runId) {
+    const run = await readStoppedRunForThreadFold(runId);
+    if (!run || run.laterTurnStarted)
+        return;
+    const assistant = buildAssistantMessage(run.events, runId, {
+        turnId: run.turnId,
+        suppressInternalContinuation: run.continuedInTurn,
+    });
+    if (!assistant)
+        return;
+    await withThreadDataLock(run.threadId, async () => {
+        const thread = await getThread(run.threadId);
+        if (!thread)
+            return;
+        const repo = normalizeThreadRepository(JSON.parse(thread.threadData || "{}"));
+        const last = repo.messages.at(-1)?.message ?? repo.messages.at(-1);
+        const ownsLast = last?.role === "user"
+            ? isRunPrompt(last, { runId, ...run })
+            : last?.role === "assistant" &&
+                last.metadata?.custom?.turnId === run.turnId;
+        if (!ownsLast)
+            return;
+        const folded = foldAssistantTurn(repo, assistant, {
+            runId,
+            turnId: run.turnId,
+        });
+        const meta = extractThreadMeta(folded);
+        await updateThreadData(run.threadId, JSON.stringify(folded), thread.title, meta.preview || thread.preview, folded.messages.length);
+    });
+}

package/dist/agent/run-store.d.ts

@@ -1,6 +1,6 @@
 import { type ArtifactReceipt } from "../artifacts/detect.js";
-import { type AutoContinueRefusalCode } from "./auto-continue.js";
-import type { AgentChatEvent } from "./types.js";
+import { type ContinueRefusalCode, type ContinueTrigger } from "./auto-continue.js";
+import type { AgentChatEvent, RunEvent } from "./types.js";
 export declare const RUN_STALE_MS = 15000;
 export declare const BACKGROUND_RUN_STALE_MS = 90000;
 export declare const BACKGROUND_PROCESSING_RUN_STALE_MS = 45000;
@@ -164,6 +164,15 @@ export declare function shouldRedispatchUnclaimedBackgroundRun(row: {
     startedAt: number;
 }, now?: number): boolean;
 export declare function countRunsForTurn(threadId: string, turnId: string): Promise<number>;
+/**
+ * The newest run of the turn before `turnId` in a thread: how the previous
+ * request ended. Null when the thread has no earlier turn.
+ */
+export declare function getPreviousTurnNewestRun(threadId: string, turnId: string): Promise<{
+    turnId: string;
+    status: string;
+    terminalReason: string | null;
+} | null>;
 export declare function getTurnInitiatorByRun(runId: string): Promise<(AgentTurnInitiator & {
     firstRunId: string;
 }) | null>;
@@ -179,14 +188,17 @@ export declare function tryClaimRunSlot(threadId: string, runId: string, maxStal
     dispatchPayload?: string;
     continuationOrder?: number;
     turnInitiator?: AgentTurnInitiator;
-    /** The time-limit stop this run automatically continues. */
-    autoContinueOf?: string;
+    /** The stopped run this run continues in the same turn, and who asked. */
+    continueOf?: {
+        runId: string;
+        trigger: ContinueTrigger;
+    };
 }): Promise<{
     claimed: boolean;
     activeRunId: string | null;
     completedRunId?: string;
     turnAborted?: boolean;
-    autoContinueRefused?: AutoContinueRefusalCode;
+    continueRefused?: ContinueRefusalCode;
 }>;
 export declare function setRunError(runId: string, errorCode: string | undefined, errorDetail: string | undefined): Promise<void>;
 export declare function setRunTerminalReason(runId: string, terminalReason: string | undefined): Promise<void>;
@@ -280,6 +292,18 @@ export declare function getRunById(runId: string): Promise<{
     errorDetail: string | null;
     terminalReason: string | null;
 } | null>;
+/**
+ * What saving a run the server ended on its behalf needs: the run's ledger,
+ * and whether anything ran after it in its turn or in a later turn.
+ */
+export declare function readStoppedRunForThreadFold(runId: string): Promise<{
+    threadId: string;
+    turnId: string;
+    startedAt: number;
+    events: RunEvent[];
+    continuedInTurn: boolean;
+    laterTurnStarted: boolean;
+} | null>;
 export declare function getLastTerminalRunEvent(runId: string): Promise<{
     seq: number;
     event: Record<string, unknown>;