@trigger.dev/sdk 0.0.0-prerelease-20260911094758 → 0.0.0-prerelease-windows-bundle-fix-20260928100448

package/dist/commonjs/v3/ai.js

@@ -15,8 +15,12 @@ const v3_1 = require("@trigger.dev/core/v3");
 // Runtime VALUES go through the ESM/CJS shim so the CJS build can `require`
 // ESM-only `ai@7` (see ../imports/ai-runtime.ts).
 const api_1 = require("@opentelemetry/api");
+const sessionTracing_js_1 = require("./sessionTracing.js");
 const ai_runtime_js_1 = require("../imports/ai-runtime.js");
 const transcriptStorage_js_1 = require("./transcriptStorage.js");
+const compactionResponse_js_1 = require("./compactionResponse.js");
+const managedChatResponse_js_1 = require("./managedChatResponse.js");
+const steeringContext_js_1 = require("./steeringContext.js");
 let transcriptStorageOverride;
 /**
  * Test-only override for the storage `chat.agent` persists through, so a
@@ -46,6 +50,7 @@ const externalDeploymentId_js_1 = require("./externalDeploymentId.js");
 const chatVersionSkew_js_1 = require("./chatVersionSkew.js");
 const sessions_js_1 = require("./sessions.js");
 const shared_js_1 = require("./shared.js");
+const concurrency_shared_js_1 = require("./concurrency-shared.js");
 const streams_js_1 = require("./streams.js");
 const tracer_js_1 = require("./tracer.js");
 const METADATA_KEY = "tool.execute.options";
@@ -54,17 +59,17 @@ const METADATA_KEY = "tool.execute.options";
  * `ignoreIncompleteToolCalls: true` to prevent failures from
  * stopped/aborted conversations with partial tool parts.
  */
-function toModelMessages(messages) {
+function toModelMessages(messages, context) {
     // Pass the resolved per-turn `tools` (if any) so the AI SDK can look up each
     // tool's `toModelOutput` and re-apply it to prior-turn tool results. Without
     // `tools` it falls back to JSON-stringifying the raw output (TRI-10149). The
     // conditional spread keeps the options object byte-identical to the no-tools
     // path when nothing was declared.
     const tools = locals_js_1.locals.get(chatResolvedToolsKey);
-    return (0, ai_runtime_js_1.convertToModelMessages)(messages, {
+    return (0, steeringContext_js_1.convertSteeredMessages)(messages, async (batch) => (0, ai_runtime_js_1.convertToModelMessages)(batch, {
         ignoreIncompleteToolCalls: true,
         ...(tools ? { tools } : {}),
-    });
+    }), locals_js_1.locals.get(chatSteeringInjectionsKey) ?? new Map(), context ?? locals_js_1.locals.get(chatCurrentUIMessagesKey) ?? messages, context !== undefined || locals_js_1.locals.get(chatCurrentUIMessagesKey) !== undefined);
 }
 const chatTurnContextKey = locals_js_1.locals.create("chat.turnContext");
 /**
@@ -683,31 +688,158 @@ exports.ai = {
 function createChatAccessToken(taskId) {
     return auth_js_1.auth.createTriggerPublicToken(taskId, { expirationTime: "24h" });
 }
-// ---------------------------------------------------------------------------
-// Chat transport helpers — backend side
-// ---------------------------------------------------------------------------
+function createChatOutGate() {
+    let resolveOpened;
+    const opened = new Promise((resolve) => {
+        resolveOpened = resolve;
+    });
+    const gate = {
+        pending: new Set(),
+        open: false,
+        opened,
+        failOpen() {
+            if (gate.open)
+                return;
+            gate.open = true;
+            resolveOpened();
+        },
+    };
+    return gate;
+}
+const chatOutGateKey = locals_js_1.locals.create("chat.outGate");
+/**
+ * How long a write waits on the gate before giving up. A storage that hangs
+ * degrades to an ungated write rather than stalling the conversation.
+ * @internal
+ */
+const CHAT_OUT_GATE_TIMEOUT_MS = 10_000;
+/**
+ * The ids to save non-final after a failed turn: the stream's partial answer,
+ * but only while the message under its id is still that partial by content.
+ * `onTurnComplete` may hand back a cloned history (same content, new objects),
+ * which keeps it partial, or replace it in place, which finishes it.
+ * @internal
+ */
+function partialStillUnfinished(partial, fingerprint, messages) {
+    if (!partial || fingerprint === undefined)
+        return undefined;
+    const current = messages.find((message) => message.id === partial.id);
+    if (!current || (0, transcriptStorage_js_1.fingerprintMessage)(current) !== fingerprint)
+        return undefined;
+    return new Set([partial.id]);
+}
+async function awaitChatOutGate() {
+    const gate = locals_js_1.locals.get(chatOutGateKey);
+    if (!gate || gate.open)
+        return;
+    const deadline = Date.now() + CHAT_OUT_GATE_TIMEOUT_MS;
+    while (gate.pending.size > 0) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            gate.failOpen();
+            return;
+        }
+        const waitingOn = [...gate.pending];
+        let timedOut = false;
+        let timer;
+        try {
+            await Promise.race([
+                Promise.allSettled(waitingOn),
+                gate.opened,
+                new Promise((resolve) => {
+                    timer = setTimeout(() => {
+                        timedOut = true;
+                        resolve();
+                    }, remaining);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+        if (gate.open)
+            return;
+        if (timedOut) {
+            gate.failOpen();
+            return;
+        }
+        for (const settled of waitingOn)
+            gate.pending.delete(settled);
+    }
+}
 /**
- * Typed chat output stream — `.writer()`, `.pipe()`, `.append()`, and
- * `.read()` methods pre-bound to this run's Session `.out` channel and
- * typed to `UIMessageChunk`.
+ * Register work that must land before anything from this turn reaches the
+ * frontend.
+ *
+ * Like {@link chatDefer} the work starts immediately and is never awaited by
+ * the hook that registered it, so it runs alongside the model and costs no
+ * time to first token. Unlike `chat.defer`, the output stream waits for it:
+ * no chunk of the answer is written to the session until it settles. That
+ * makes it the right home for a write the next page load has to see (a
+ * conversation row, a message insert), because a reader that can see the
+ * answer can also see what the write persisted.
+ *
+ * Reach for `chat.defer` instead when the timing does not matter for a
+ * reload: analytics, audit logs, search-index updates.
+ *
+ * This is not a consistency barrier for the turn. The work is still in flight
+ * while the model runs, so a tool, a `prepareStep`, or anything else executing
+ * during the turn can still read the state as it was before the write. It
+ * orders the write against what the frontend can see, nothing more. When the
+ * turn's own code has to read the write back, `await` it instead and accept
+ * the cost.
  *
- * Use from within a `chat.agent` run to write custom chunks:
+ * A write registered here that fails, or outlasts the internal timeout, lets
+ * the stream through rather than stalling the conversation.
+ *
+ * @example
  * ```ts
- * const { waitUntilComplete } = chat.stream.writer({
- *   execute: ({ write }) => {
- *     write({ type: "text-start", id: "status-1" });
- *     write({ type: "text-delta", id: "status-1", delta: "Processing..." });
- *     write({ type: "text-end", id: "status-1" });
- *   },
- * });
- * await waitUntilComplete();
+ * onTurnStart: async ({ chatId, uiMessages }) => {
+ *   chat.deferBeforeOutput(
+ *     db.chat.update({ where: { id: chatId }, data: { messages: uiMessages } })
+ *   );
+ * },
  * ```
- *
- * Backed by the Session primitive so a chat's output outlives any single
- * run — subscribers (browser transport, server-side `ChatStream`) read
- * the session's `.out`, not a per-run stream. Run-scoped `target`
- * options on `.pipe()` are honoured as no-ops; the session is the target.
  */
+function chatDeferBeforeOutput(promiseOrFn) {
+    const gate = locals_js_1.locals.get(chatOutGateKey);
+    const work = typeof promiseOrFn === "function" ? promiseOrFn() : promiseOrFn;
+    if (!gate || gate.open)
+        return;
+    gate.pending.add(work);
+}
+function gateWriterOptions(options) {
+    return {
+        ...options,
+        execute: async (api) => {
+            await awaitChatOutGate();
+            return await options.execute(api);
+        },
+    };
+}
+function gateOutStream(value) {
+    return (async function* () {
+        await awaitChatOutGate();
+        if (isReadableStream(value)) {
+            const reader = value.getReader();
+            try {
+                while (true) {
+                    const { done, value: chunk } = await reader.read();
+                    if (done)
+                        break;
+                    yield chunk;
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        else {
+            yield* value;
+        }
+    })();
+}
 const chatStream = {
     // Stable opaque label for the run-scoped `RealtimeDefinedStream` shape.
     // `chatStream` is backed by the Session's `.out` channel — this id is
@@ -717,7 +849,7 @@ const chatStream = {
     id: "chat",
     pipe(value, options) {
         const { target: _target, ...sessionOptions } = (options ?? {});
-        return getChatSession().out.pipe(value, sessionOptions);
+        return getChatSession().out.pipe(gateOutStream(value), sessionOptions);
     },
     async read(_runId, options) {
         // Session channels don't need a runId — the session is the address.
@@ -727,10 +859,11 @@ const chatStream = {
     },
     async append(value, options) {
         const { target: _target, ...sessionOptions } = (options ?? {});
+        await awaitChatOutGate();
         return getChatSession().out.append(value, sessionOptions);
     },
     writer(options) {
-        return getChatSession().out.writer(options);
+        return getChatSession().out.writer(gateWriterOptions(options));
     },
 };
 // ---------------------------------------------------------------------------
@@ -741,7 +874,7 @@ const chatStream = {
  * `onTurnComplete`'s `responseMessage` and `uiMessages`.
  *
  * Non-transient data chunks (`type` starts with `data-`, no `transient: true`)
- * are queued for accumulation into the assistant response message.
+ * are accumulated in emission order into the assistant response message.
  * Transient or non-data chunks are streamed only (same as `chat.stream`).
  *
  * @example
@@ -759,15 +892,7 @@ const chatResponse = {
      * response message; everything else is stream-only.
      */
     write(part) {
-        queueResponsePart(part);
-        const { waitUntilComplete } = chatStream.writer({
-            spanName: "chat.response.write",
-            collapsed: true,
-            execute: ({ write }) => {
-                write(part);
-            },
-        });
-        waitUntilComplete().catch(() => { });
+        managedResponse().writeData(part);
     },
 };
 /**
@@ -776,46 +901,13 @@ const chatResponse = {
  * @internal
  */
 function createLazyChatWriter() {
-    let writeImpl = null;
-    let mergeImpl = null;
-    let waitPromise = null;
-    let resolveExecute = null;
-    function ensureInitialized() {
-        if (writeImpl)
-            return;
-        const executePromise = new Promise((resolve) => {
-            resolveExecute = resolve;
-        });
-        const { waitUntilComplete } = chatStream.writer({
+    return (0, managedChatResponse_js_1.createOrderedChatWriter)(() => (locals_js_1.locals.get(chatManagedResponseActiveKey) ? managedResponse() : undefined), async (stream) => {
+        const { waitUntilComplete } = chatStream.pipe(stream, {
             collapsed: true,
             spanName: "callback writer",
-            execute: ({ write, merge }) => {
-                writeImpl = write;
-                mergeImpl = merge;
-                return executePromise; // Keep execute alive until flush()
-            },
         });
-        waitPromise = waitUntilComplete;
-    }
-    return {
-        writer: {
-            write(part) {
-                ensureInitialized();
-                queueResponsePart(part);
-                writeImpl(part);
-            },
-            merge(stream) {
-                ensureInitialized();
-                mergeImpl(stream);
-            },
-        },
-        async flush() {
-            if (resolveExecute) {
-                resolveExecute(); // Signal execute to complete
-                await waitPromise(); // Wait for stream to finish piping
-            }
-        },
-    };
+        await waitUntilComplete();
+    });
 }
 /**
  * Runs a callback with a lazy ChatWriter, flushing the stream after completion.
@@ -968,7 +1060,7 @@ async function waitOnChatRoute(route, options) {
     return tracer_js_1.tracer.startActiveSpan(options.spanName ?? `chat.${route}.wait()`, async (span) => {
         const idleMs = (options.idleTimeoutInSeconds ?? 0) * 1000;
         if (idleMs > 0) {
-            const warm = await router.next(route, { timeoutMs: idleMs });
+            const warm = await (0, sessionTracing_js_1.traceSessionIdle)(session.id, idleMs / 1000, () => router.next(route, { timeoutMs: idleMs }));
             if (warm) {
                 span.setAttribute("wait.resolved", "idle");
                 return { ok: true, output: warm.data, record: warm };
@@ -1022,10 +1114,6 @@ async function waitOnChatRoute(route, options) {
             session: session.id,
             io: "in",
             route,
-            ...(0, v3_1.accessoryAttributes)({
-                items: [{ text: `${session.id}.in:${route}`, variant: "normal" }],
-                style: "codepath",
-            }),
         },
     });
 }
@@ -1701,6 +1789,14 @@ const chatHandoverPartialKey = locals_js_1.locals.create("chat.handoverPartial")
  * @internal
  */
 const chatHandoverMessageIdKey = locals_js_1.locals.create("chat.handoverMessageId");
+/**
+ * The model messages a turn-0 head-start splice contributed to the model lane,
+ * keyed by the UI message id it was synthesized under. When the agent's response
+ * completes that message under the same id, this is the run to replace: the UI
+ * form alone converts to something else (its pending tool calls drop out, the
+ * approval round was never on it), so it cannot locate the run itself.
+ */
+const chatHandoverSplicedRunKey = locals_js_1.locals.create("chat.handoverSplicedRun");
 /**
  * Run-scoped slot indicating that the customer's step-1 head-start
  * response is the FINAL turn response. When true, turn 0 runs through
@@ -1784,16 +1880,19 @@ function synthesizeHandoverUIMessage(partial, messageId) {
  */
 function spliceHandoverPartial(modelMessages, uiMessages, signal) {
     if (!signal.partialAssistantMessage || signal.partialAssistantMessage.length === 0) {
-        return;
+        return undefined;
     }
     // Skip if the hydrated chain already persisted the partial under this id.
     const alreadyInChain = signal.messageId !== undefined && uiMessages.some((m) => m.id === signal.messageId);
     if (alreadyInChain)
-        return;
-    modelMessages.push(...signal.partialAssistantMessage);
+        return undefined;
+    const run = [...signal.partialAssistantMessage];
+    modelMessages.push(...run);
     const partialUI = synthesizeHandoverUIMessage(signal.partialAssistantMessage, signal.messageId);
-    if (partialUI)
-        uiMessages.push(partialUI);
+    if (!partialUI)
+        return undefined;
+    uiMessages.push(partialUI);
+    return { id: partialUI.id, run };
 }
 /**
  * Per-turn background context queue. Messages added via `chat.backgroundWork.inject()`
@@ -2399,29 +2498,19 @@ const chatTurnNewUIMessagesKey = locals_js_1.locals.create("chat.turnNewUIMessag
 const chatPendingSteerKey = locals_js_1.locals.create("chat.pendingSteer");
 /** @internal — IDs of messages that were successfully injected via prepareStep */
 const chatInjectedMessageIdsKey = locals_js_1.locals.create("chat.injectedMessageIds");
-/** @internal — non-transient data parts queued via chat.response or writer.write() for accumulation into the response message */
-const chatResponsePartsKey = locals_js_1.locals.create("chat.responseParts");
-/**
- * Check if a chunk is a non-transient data part that should persist to the response message.
- * @internal
- */
-function isNonTransientDataPart(part) {
-    if (typeof part !== "object" || part === null)
-        return false;
-    const p = part;
-    return typeof p.type === "string" && p.type.startsWith("data-") && p.transient !== true;
-}
-/**
- * Queue a chunk for accumulation into the response message (if it's a non-transient data part).
- * Called by `chat.response.write()` and `ChatWriter.write()`.
- * @internal
- */
-function queueResponsePart(part) {
-    if (!isNonTransientDataPart(part))
-        return;
-    const parts = locals_js_1.locals.get(chatResponsePartsKey) ?? [];
-    parts.push(part);
-    locals_js_1.locals.set(chatResponsePartsKey, parts);
+const chatManagedResponseKey = locals_js_1.locals.create("chat.managedResponse");
+const chatManagedResponseActiveKey = locals_js_1.locals.create("chat.managedResponseActive");
+const chatSteeringInjectionsKey = locals_js_1.locals.create("chat.steeringInjections");
+function managedResponse() {
+    let response = locals_js_1.locals.get(chatManagedResponseKey);
+    if (!response || response.isClosed) {
+        response = new managedChatResponse_js_1.ManagedChatResponse(async (stream) => {
+            const { waitUntilComplete } = chatStream.pipe(stream, { spanName: "managed chat response" });
+            await waitUntilComplete();
+        });
+        locals_js_1.locals.set(chatManagedResponseKey, response);
+    }
+    return response;
 }
 /**
  * Check that no tool calls are in-flight in a step's content.
@@ -2653,6 +2742,7 @@ async function chatCompact(messages, steps, options) {
                 locals_js_1.locals.set(chatCompactionStateKey, {
                     summary,
                     baseResponseMessageCount: currentStep.response.messages.length,
+                    baseResponseStepCount: steps.length,
                 });
                 // Set model-only override — UI messages stay intact for persistence.
                 // The summary becomes the model message history for the next turn,
@@ -2772,6 +2862,8 @@ function modelFormOf(m, batch, injected) {
  * @internal
  */
 async function drainSteeringQueue(config, messages, steps, queueOverride) {
+    if (steps.length === 0)
+        managedResponse().beginGeneration();
     const queue = queueOverride ?? locals_js_1.locals.get(chatSteeringQueueKey);
     if (!queue || queue.length === 0)
         return EMPTY_DRAIN;
@@ -2904,31 +2996,24 @@ async function drainSteeringQueue(config, messages, steps, queueOverride) {
             }
             locals_js_1.locals.set(chatPendingSteerKey, pendingSteer);
         }
-        // Write injection confirmation chunk to the stream so the frontend
-        // knows which messages were injected and where in the response.
         if (injected.length > 0) {
-            try {
-                const { waitUntilComplete } = chatStream.writer({
-                    collapsed: true,
-                    execute: ({ write }) => {
-                        write({
-                            type: ai_shared_js_1.PENDING_MESSAGE_INJECTED_TYPE,
-                            id: (0, ai_runtime_js_1.generateId)(),
-                            data: {
-                                messageIds: claimedUIMessages.map((m) => m.id),
-                                messages: claimedUIMessages.map((m) => ({
-                                    id: m.id,
-                                    text: textOfUIMessage(m),
-                                })),
-                            },
-                        });
-                    },
-                });
-                await waitUntilComplete();
-            }
-            catch {
-                /* non-fatal — stream write failed */
-            }
+            const id = (0, ai_runtime_js_1.generateId)();
+            const messageIds = claimedUIMessages.map((m) => m.id);
+            const injections = locals_js_1.locals.get(chatSteeringInjectionsKey) ?? new Map();
+            injections.set(id, { id, messageIds, messages: injected });
+            locals_js_1.locals.set(chatSteeringInjectionsKey, injections);
+            const response = managedResponse();
+            // prepareStep can run ahead of the UI consumer. Admit the marker only
+            // once the actual preceding finish-step chunk has entered this stream.
+            response.afterStep(steps.length);
+            response.writeData({
+                type: ai_shared_js_1.PENDING_MESSAGE_INJECTED_TYPE,
+                id,
+                data: {
+                    messageIds,
+                    messages: claimedUIMessages.map((m) => ({ id: m.id, text: textOfUIMessage(m) })),
+                },
+            });
         }
         // Fire onInjected callback
         if (config.onInjected && injected.length > 0) {
@@ -3229,7 +3314,7 @@ function buildManagedStreamTextOptions(options, config) {
          * regenerate needs: without it a regenerated answer can call nothing.
          */
         tools: (tools ?? agentTools),
-    });
+    }, false);
     const promptSystem = locals_js_1.locals.get(chatPromptKey)?.text;
     /**
      * Two managed sources conflict too, not only a caller against a managed one.
@@ -3256,6 +3341,9 @@ function buildManagedStreamTextOptions(options, config) {
             return { ...(first ?? {}), ...(second ?? {}) };
         };
     }
+    if (typeof managed.prepareStep === "function") {
+        managed.prepareStep = (0, steeringContext_js_1.retainStepMessages)(managed.prepareStep);
+    }
     return { ...managed, ...rest };
 }
 /** @internal Test hook for {@link buildManagedStreamTextOptions}. */
@@ -3271,7 +3359,7 @@ function createBoundStreamText(registry, agentSystem, agentCacheControl, agentSy
     }));
     return bound;
 }
-function toStreamTextOptions(options) {
+function toStreamTextOptions(options, retain = true) {
     const agentDefaults = locals_js_1.locals.get(chatAgentManagedConfigKey);
     if (agentDefaults) {
         options = {
@@ -3478,6 +3566,9 @@ function toStreamTextOptions(options) {
             return resultMessages ? { messages: resultMessages } : undefined;
         };
     }
+    if (retain && typeof result.prepareStep === "function") {
+        result.prepareStep = (0, steeringContext_js_1.retainStepMessages)(result.prepareStep);
+    }
     return result;
 }
 const actionTurnBrand = Symbol.for("trigger.dev/chat/actionTurn");
@@ -3523,9 +3614,16 @@ function isActionTurn(value) {
  * tail does not match the old message's conversion, nothing is changed and
  * `false` is returned so the caller can fall back to a full reconversion.
  */
-async function replaceModelRun(lane, oldUi, newUi, tailAfter) {
-    const oldRun = await toModelMessages([stripProviderMetadata(oldUi)]);
+async function replaceModelRun(lane, oldUi, newUi, tailAfter, knownOldRun) {
+    const oldRun = knownOldRun ?? (await toModelMessages([stripProviderMetadata(oldUi)]));
     const newRun = await toModelMessages([stripProviderMetadata(newUi)]);
+    // A message that converts to nothing (a pending tool call with no output yet,
+    // which `ignoreIncompleteToolCalls` drops) locates no run in the lane. Matching
+    // an empty slice would splice the new run in without removing what the message
+    // actually contributed, such as a spliced head-start partial, and the lane would
+    // then carry the same tool call twice.
+    if (oldRun.length === 0)
+        return false;
     const end = lane.length - tailAfter;
     const start = end - oldRun.length;
     if (start < 0 || end > lane.length)
@@ -3605,7 +3703,7 @@ function isReadableStream(value) {
  * }
  * ```
  */
-async function pipeChat(source, options) {
+async function pipeChat(source, options, capture) {
     locals_js_1.locals.set(chatPipeCountKey, (locals_js_1.locals.get(chatPipeCountKey) ?? 0) + 1);
     let stream;
     if (isUIMessageStreamable(source)) {
@@ -3634,8 +3732,18 @@ async function pipeChat(source, options) {
     // accepts opaque UIMessageStreamable / raw iterables whose element
     // type we don't know at compile time. Cast — runtime behaviour is
     // identical (bytes go to session.out either way).
-    const { waitUntilComplete } = chatStream.pipe(stream, pipeOptions);
-    await waitUntilComplete();
+    if (capture) {
+        const response = managedResponse();
+        response.seed(capture.originalMessages);
+        await response.pipe(stream, options?.signal);
+    }
+    else {
+        // Raw/manual pipes intentionally do not feed the managed capture. Never
+        // leave injection events waiting for finish-step chunks it cannot see.
+        managedResponse().useRawPipe();
+        const { waitUntilComplete } = chatStream.pipe(stream, pipeOptions);
+        await waitUntilComplete();
+    }
 }
 function chatCustomAgent(options) {
     const { clientDataSchema, onClientDataValidationError, clientDataReportErrorAt, run: userRun, ...restOptions } = options;
@@ -3888,11 +3996,13 @@ function chatAgent(options) {
                 if (!pending || pending.length === 0)
                     return [];
                 locals_js_1.locals.set(chatPendingSteerKey, []);
-                for (const entry of pending) {
+                const inlineIds = new Set((0, steeringContext_js_1.steeringMarkers)(options?.response ? [options.response] : []).flatMap((m) => m.messageIds));
+                const standalone = pending.filter((entry) => !inlineIds.has(entry.ui.id));
+                for (const entry of standalone) {
                     accumulatedMessages.push(...entry.model);
                     options?.turnNew?.push(...entry.model);
                 }
-                return pending;
+                return standalone;
             };
             // Accumulated UI messages for persistence. Mirrors the model accumulator
             // but in frontend-friendly UIMessage format (with parts, id, etc.).
@@ -3955,6 +4065,17 @@ function chatAgent(options) {
              * keeps an action's write cursor-neutral.
              */
             let lastSnapshotOutEventId;
+            /**
+             * The `lastInEventId` the most recent snapshot carried.
+             *
+             * A turn-start save happens after the incoming message has been handed to
+             * the turn loop, so the router's live resume floor has already advanced
+             * past it. Persisting that floor before the turn runs would let the next
+             * boot resume past a message this run never answered, which is exactly
+             * what a deferred or recovered message depends on. Turn-start carries
+             * this instead.
+             */
+            let lastSnapshotInEventId;
             const storageTrigger = (trigger) => trigger === "regenerate-message"
                 ? "regenerate-message"
                 : trigger === "action" || trigger === "action-turn"
@@ -3968,13 +4089,17 @@ function chatAgent(options) {
              */
             /** The runtime's opaque state as of the last save; carried on every changeset's transcript. */
             let transcriptState = null;
-            const saveTranscript = async (opts) => {
+            let transcriptSaveChain = Promise.resolve();
+            const runSaveTranscript = async (opts) => {
                 const { changes, shadow } = (0, transcriptStorage_js_1.diffTranscript)(transcriptShadow, opts.messages, {
                     nonFinalIds: opts.nonFinalIds,
                 });
                 const throughId = opts.messages.at(-1)?.id ?? "";
                 const queued = locals_js_1.locals.get(chatBackgroundQueueKey) ?? [];
-                const runtimeState = laneCompacted || laneInjections.length > 0 || queued.length > 0
+                const transcriptIds = new Set(opts.messages.map((message) => message.id));
+                const markerIds = new Set((0, steeringContext_js_1.steeringMarkers)(opts.messages).map((marker) => marker.id));
+                const steering = [...(locals_js_1.locals.get(chatSteeringInjectionsKey)?.values() ?? [])].filter((entry) => markerIds.has(entry.id) || entry.messageIds.some((id) => transcriptIds.has(id)));
+                const runtimeState = laneCompacted || laneInjections.length > 0 || queued.length > 0 || steering.length > 0
                     ? {
                         v: 1,
                         ...(laneCompacted
@@ -3987,13 +4112,21 @@ function chatAgent(options) {
                             : {}),
                         ...(laneInjections.length > 0 ? { injections: laneInjections } : {}),
                         ...(queued.length > 0 ? { queued: [...queued] } : {}),
+                        ...(steering.length > 0 ? { steering } : {}),
                     }
                     : null;
                 if (runtimeState !== null || persistedStateSet) {
                     changes.push({ op: "state", value: runtimeState });
                 }
+                if (opts.skipIfUnchanged && changes.length === 0)
+                    return;
                 transcriptState = runtimeState;
-                const inCursor = chatInputRouter().resumeFloor();
+                const liveInCursor = chatInputRouter().resumeFloor();
+                const inCursor = opts.carryInCursor
+                    ? lastSnapshotInEventId
+                    : liveInCursor !== undefined
+                        ? String(liveInCursor)
+                        : undefined;
                 await transcriptStorage.save({
                     chatId: payload.chatId,
                     clientData: opts.clientData,
@@ -4014,12 +4147,28 @@ function chatAgent(options) {
                     },
                     cursors: {
                         lastOutEventId: opts.lastOutEventId,
-                        lastInEventId: inCursor !== undefined ? String(inCursor) : undefined,
+                        lastInEventId: inCursor,
                     },
                 });
                 transcriptShadow = shadow;
+                lastSnapshotInEventId = inCursor;
                 persistedStateSet = runtimeState !== null;
             };
+            /**
+             * Serialise every save onto one chain. `runSaveTranscript` derives its
+             * changeset from `transcriptShadow` and only advances it once the write
+             * lands, so two overlapping saves would diff against stale state. The
+             * message list is copied on the way in because the accumulator keeps
+             * mutating while a queued save waits its turn. A rejection is handed to
+             * the caller but never poisons the chain.
+             */
+            const saveTranscript = (opts) => {
+                const queued = { ...opts, messages: [...opts.messages] };
+                const run = () => runSaveTranscript(queued);
+                const next = transcriptSaveChain.then(run, run);
+                transcriptSaveChain = next.then(() => undefined, () => undefined);
+                return next;
+            };
             /**
              * Persist the accumulator outside a turn.
              *
@@ -4126,6 +4275,7 @@ function chatAgent(options) {
                     // turn (chain self-bootstraps from turn 2), so this is purely an
                     // optimization to keep continuation runs bounded from the first turn.
                     lastSnapshotOutEventId = bootSnapshot?.lastOutEventId;
+                    lastSnapshotInEventId = bootSnapshot?.lastInEventId;
                     if (bootSnapshot?.lastOutEventId !== undefined) {
                         const seeded = Number.parseInt(bootSnapshot.lastOutEventId, 10);
                         if (Number.isFinite(seeded)) {
@@ -4432,6 +4582,8 @@ function chatAgent(options) {
                     }
                     try {
                         const bootRuntimeState = (0, transcriptStorage_js_1.parseTranscriptRuntimeState)(bootTranscriptState);
+                        locals_js_1.locals.set(chatSteeringInjectionsKey, new Map((bootRuntimeState?.steering ?? []).map((entry) => [entry.id, entry])));
+                        locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
                         const restored = await (0, transcriptStorage_js_1.restoreModelLane)(accumulatedUIMessages, bootRuntimeState, (messages) => toModelMessages(messages));
                         accumulatedMessages = restored.messages;
                         laneCompacted = restored.compacted;
@@ -4613,7 +4765,7 @@ function chatAgent(options) {
                     const preloadResult = await messagesInput.waitWithIdleTimeout({
                         idleTimeoutInSeconds: effectivePreloadIdleTimeout,
                         timeout: effectivePreloadTimeout,
-                        spanName: "waiting for first message",
+                        spanName: "first message",
                         skipSuspend: exitAfterPreloadIdle,
                         onSuspend: onChatSuspend
                             ? async () => {
@@ -4765,7 +4917,7 @@ function chatAgent(options) {
                         const continuationResult = await messagesInput.waitWithIdleTimeout({
                             idleTimeoutInSeconds: effectiveIdleTimeout,
                             timeout: effectiveTurnTimeout,
-                            spanName: "waiting for first message (continuation)",
+                            spanName: "first message (continuation)",
                             onSuspend: onChatSuspend
                                 ? async () => {
                                     await tracer_js_1.tracer.startActiveSpan("onChatSuspend()", async () => {
@@ -4875,10 +5027,13 @@ function chatAgent(options) {
                             // (errors are caught by the outer try/catch which writes an error chunk)
                             locals_js_1.locals.set(chatPipeCountKey, 0);
                             locals_js_1.locals.set(chatDeferKey, new Set());
+                            locals_js_1.locals.set(chatOutGateKey, createChatOutGate());
                             locals_js_1.locals.set(chatCompactionStateKey, undefined);
                             locals_js_1.locals.set(chatSteeringQueueKey, []);
                             locals_js_1.locals.set(chatPendingBackgroundKey, []);
-                            locals_js_1.locals.set(chatResponsePartsKey, []);
+                            await locals_js_1.locals.get(chatManagedResponseKey)?.close();
+                            locals_js_1.locals.set(chatManagedResponseKey, undefined);
+                            locals_js_1.locals.set(chatManagedResponseActiveKey, true);
                             // NOTE: chatBackgroundQueueKey is NOT reset here — messages injected
                             // by deferred work from the previous turn's onTurnComplete need to
                             // survive into the next turn. The queue is drained before run().
@@ -5042,7 +5197,7 @@ function chatAgent(options) {
                                     if (actionOverride) {
                                         locals_js_1.locals.set(chatOverrideMessagesKey, undefined);
                                         accumulatedUIMessages = [...actionOverride];
-                                        accumulatedMessages = await toModelMessages(actionOverride);
+                                        accumulatedMessages = await toModelMessages(actionOverride, actionOverride);
                                         laneCompacted = false;
                                         laneInjections = [];
                                         locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
@@ -5200,7 +5355,7 @@ function chatAgent(options) {
                                             accumulatedUIMessages[accumulatedUIMessages.length - 1].role !== "user") {
                                             accumulatedUIMessages.pop();
                                         }
-                                        accumulatedMessages = await toModelMessages(accumulatedUIMessages);
+                                        accumulatedMessages = await toModelMessages(accumulatedUIMessages, accumulatedUIMessages);
                                         laneCompacted = false;
                                         laneInjections = [];
                                     }
@@ -5252,7 +5407,7 @@ function chatAgent(options) {
                                             }
                                             if (!inPlace) {
                                                 v3_1.logger.warn("chat.agent: replaced message not found at the model lane tail; reconverting the lane");
-                                                accumulatedMessages = await toModelMessages(accumulatedUIMessages);
+                                                accumulatedMessages = await toModelMessages(accumulatedUIMessages, accumulatedUIMessages);
                                                 laneCompacted = false;
                                                 laneInjections = [];
                                             }
@@ -5293,10 +5448,12 @@ function chatAgent(options) {
                                     // `UIMessageStreamError: No tool invocation found`.
                                     const pendingHandoverPartial = locals_js_1.locals.get(chatHandoverPartialKey);
                                     if (pendingHandoverPartial && pendingHandoverPartial.length > 0) {
-                                        spliceHandoverPartial(accumulatedMessages, accumulatedUIMessages, {
+                                        const spliced = spliceHandoverPartial(accumulatedMessages, accumulatedUIMessages, {
                                             partialAssistantMessage: pendingHandoverPartial,
                                             messageId: locals_js_1.locals.get(chatHandoverMessageIdKey),
                                         });
+                                        if (spliced)
+                                            locals_js_1.locals.set(chatHandoverSplicedRunKey, spliced);
                                         locals_js_1.locals.set(chatHandoverPartialKey, []); // consume once
                                         splicedHandoverPartial = true;
                                     }
@@ -5363,6 +5520,23 @@ function chatAgent(options) {
                             // A no-op turn skips this block, and with it `followSessionPin`:
                             // there is nothing to answer, so nothing to hand over.
                             if ((!isAction || actionTurn) && !isNoOpTurn) {
+                                if (!hydrateMessages) {
+                                    chatDeferBeforeOutput(saveTranscript({
+                                        reason: "turn-start",
+                                        messages: accumulatedUIMessages,
+                                        turn,
+                                        trigger: storageTrigger(currentWirePayload.trigger),
+                                        clientData,
+                                        lastOutEventId: lastSnapshotOutEventId,
+                                        skipIfUnchanged: true,
+                                        carryInCursor: true,
+                                    }).catch((error) => {
+                                        v3_1.logger.warn("chat.agent: turn-start transcript write failed; a reload mid-answer may not show the message being answered", {
+                                            error: error instanceof Error ? error.message : String(error),
+                                            sessionId: sessionIdForSnapshot,
+                                        });
+                                    }));
+                                }
                                 // Mint a scoped public access token once per turn, reused for
                                 // onChatStart, onTurnStart, onTurnComplete, and the turn-complete chunk.
                                 const currentRunId = ctx.run.id;
@@ -5450,7 +5624,7 @@ function chatAgent(options) {
                                         if (turnStartOverride) {
                                             locals_js_1.locals.set(chatOverrideMessagesKey, undefined);
                                             accumulatedUIMessages = [...turnStartOverride];
-                                            accumulatedMessages = await toModelMessages(turnStartOverride);
+                                            accumulatedMessages = await toModelMessages(turnStartOverride, turnStartOverride);
                                             laneCompacted = false;
                                             laneInjections = [];
                                             locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
@@ -5530,6 +5704,7 @@ function chatAgent(options) {
                                             capturedResponseMessage = lastUI;
                                             capturedFinishReason = "stop";
                                         }
+                                        managedResponse().seed(accumulatedUIMessages);
                                         // Don't call userRun. Don't pipe. Skip directly
                                         // to the post-turn flow below.
                                     }
@@ -5589,7 +5764,7 @@ function chatAgent(options) {
                                         await pipeChat(tapUIMessageChunks(uiStream, turnBufferedChunks), {
                                             signal: combinedSignal,
                                             spanName: "stream response",
-                                        });
+                                        }, { originalMessages: isActionTurn ? undefined : accumulatedUIMessages });
                                     }
                                 }
                                 catch (error) {
@@ -5617,6 +5792,10 @@ function chatAgent(options) {
                                         new Promise((r) => setTimeout(r, 2_000)),
                                     ]);
                                 }
+                                capturedResponseMessage =
+                                    (await locals_js_1.locals.get(chatManagedResponseKey)?.snapshot()) ?? capturedResponseMessage;
+                                if (capturedResponseMessage)
+                                    capturedPartialResponse = capturedResponseMessage;
                                 // Capture token usage from the streamText result (if available).
                                 // totalUsage is a PromiseLike that resolves after the stream is consumed.
                                 // Race with a 2s timeout — on stop-abort the AI SDK's totalUsage
@@ -5624,6 +5803,7 @@ function chatAgent(options) {
                                 // never reports final usage), which would block the turn loop
                                 // from ever firing onTurnComplete / writeTurnComplete.
                                 let turnUsage;
+                                let lastStepUsage;
                                 if (runResult != null &&
                                     typeof runResult.totalUsage?.then === "function") {
                                     try {
@@ -5636,6 +5816,18 @@ function chatAgent(options) {
                                         /* non-fatal — usage capture failed */
                                     }
                                 }
+                                const lastStepUsagePromise = runResult != null ? runResult.usage : undefined;
+                                if (typeof lastStepUsagePromise?.then === "function") {
+                                    try {
+                                        lastStepUsage = (await Promise.race([
+                                            lastStepUsagePromise,
+                                            new Promise((r) => setTimeout(() => r(undefined), 2_000)),
+                                        ]));
+                                    }
+                                    catch {
+                                        /* non-fatal — usage capture failed */
+                                    }
+                                }
                                 if (turnUsage) {
                                     cumulativeUsage = addUsage(cumulativeUsage, turnUsage);
                                     previousTurnUsage = turnUsage;
@@ -5686,6 +5878,13 @@ function chatAgent(options) {
                                 // Check if compaction set a model-only override (preserves UI messages).
                                 // Apply compactUIMessages/compactModelMessages callbacks if configured.
                                 const modelOnlyOverride = locals_js_1.locals.get(chatOverrideModelMessagesKey);
+                                const responseCompaction = modelOnlyOverride
+                                    ? locals_js_1.locals.get(chatCompactionStateKey)
+                                    : undefined;
+                                // Capture the original assistant before compactUIMessages can remove it.
+                                const originalResponse = responseCompaction && capturedResponseMessage
+                                    ? accumulatedUIMessages.find((m) => m.id === capturedResponseMessage?.id)
+                                    : undefined;
                                 if (modelOnlyOverride) {
                                     const compactionSummary = locals_js_1.locals.get(chatCompactionStateKey)?.summary ?? "";
                                     const taskCompactionConfig = locals_js_1.locals.get(chatAgentCompactionKey);
@@ -5720,6 +5919,7 @@ function chatAgent(options) {
                                 // branches below, so a turn that captured no response is covered.
                                 const steerTailThisTurn = reconcilePendingSteer({
                                     turnNew: turnNewModelMessages,
+                                    response: capturedResponseMessage,
                                 }).reduce((n, e) => n + e.model.length, 0) + reconcilePendingBackground();
                                 // Append the assistant's response (partial or complete) to the accumulator.
                                 // The onFinish callback fires even on abort/stop, so partial responses
@@ -5742,15 +5942,6 @@ function chatAgent(options) {
                                             id: (0, ai_runtime_js_1.generateId)(),
                                         };
                                     }
-                                    // Append any non-transient data parts queued via chat.response or writer.write()
-                                    const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
-                                    if (queuedParts && queuedParts.length > 0) {
-                                        capturedResponseMessage = {
-                                            ...capturedResponseMessage,
-                                            parts: [...capturedResponseMessage.parts, ...queuedParts],
-                                        };
-                                        locals_js_1.locals.set(chatResponsePartsKey, []);
-                                    }
                                     const responseHasContent = capturedResponseMessage.parts.some((part) => part.type !== "step-start");
                                     if (responseHasContent) {
                                         // Tool-approval continuations: the AI SDK reuses the trailing
@@ -5777,15 +5968,42 @@ function chatAgent(options) {
                                         // rationale (TRI-9137).
                                         recordToolCallIdsFromMessage(capturedResponseMessage);
                                         try {
+                                            const responseForModel = (0, compactionResponse_js_1.responseAfterCompaction)(capturedResponseMessage, responseCompaction?.baseResponseStepCount, originalResponse);
+                                            // Preserve the complete persistence response, including same-ID
+                                            // replacements whose old tool parts can contain new results.
+                                            // Convert prefix and suffix separately so each tool output is
+                                            // converted once, while only the suffix enters model context.
+                                            const responsePrefixMessages = responseCompaction
+                                                ? await toModelMessages([
+                                                    stripProviderMetadata({
+                                                        ...capturedResponseMessage,
+                                                        parts: capturedResponseMessage.parts.slice(0, capturedResponseMessage.parts.length -
+                                                            responseForModel.parts.length),
+                                                    }),
+                                                ])
+                                                : [];
                                             const responseModelMessages = await toModelMessages([
-                                                stripProviderMetadata(capturedResponseMessage),
+                                                stripProviderMetadata(responseForModel),
                                             ]);
-                                            if (existingIdx !== -1) {
+                                            if (responseCompaction) {
+                                                // The summary already replaced the original response, including
+                                                // a same-ID approval/handover prefix. Replacing its old model run
+                                                // would miss and fall back to the full, uncompacted UI history.
+                                                accumulatedMessages.push(...responseModelMessages);
+                                                locals_js_1.locals.set(chatHandoverSplicedRunKey, undefined);
+                                            }
+                                            else if (existingIdx !== -1) {
+                                                const spliced = locals_js_1.locals.get(chatHandoverSplicedRunKey);
+                                                const splicedRun = spliced && previousAtIdx && spliced.id === previousAtIdx.id
+                                                    ? spliced.run
+                                                    : undefined;
                                                 const ok = previousAtIdx !== undefined &&
-                                                    (await replaceModelRun(accumulatedMessages, previousAtIdx, capturedResponseMessage, steerTailThisTurn));
+                                                    (await replaceModelRun(accumulatedMessages, previousAtIdx, capturedResponseMessage, steerTailThisTurn, splicedRun));
+                                                if (splicedRun)
+                                                    locals_js_1.locals.set(chatHandoverSplicedRunKey, undefined);
                                                 if (!ok) {
                                                     v3_1.logger.warn("chat.agent: replaced response not found at the model lane tail; reconverting the lane");
-                                                    accumulatedMessages = await toModelMessages(accumulatedUIMessages);
+                                                    accumulatedMessages = await toModelMessages(accumulatedUIMessages, accumulatedUIMessages);
                                                     laneCompacted = false;
                                                     laneInjections = [];
                                                 }
@@ -5793,7 +6011,7 @@ function chatAgent(options) {
                                             else {
                                                 accumulatedMessages.push(...responseModelMessages);
                                             }
-                                            turnNewModelMessages.push(...responseModelMessages);
+                                            turnNewModelMessages.push(...responsePrefixMessages, ...responseModelMessages);
                                         }
                                         catch {
                                             // Conversion failed — skip accumulation for this turn
@@ -5803,22 +6021,6 @@ function chatAgent(options) {
                                         responseWasSkipped = true;
                                     }
                                 }
-                                // If there's no captured response (manual pipe mode) but there are
-                                // queued data parts, create a minimal response message to hold them.
-                                if (!capturedResponseMessage) {
-                                    const remainingParts = locals_js_1.locals.get(chatResponsePartsKey);
-                                    if (remainingParts && remainingParts.length > 0) {
-                                        capturedResponseMessage = {
-                                            id: (0, ai_runtime_js_1.generateId)(),
-                                            role: "assistant",
-                                            parts: [...remainingParts],
-                                        };
-                                        locals_js_1.locals.set(chatResponsePartsKey, []);
-                                        accumulatedUIMessages.push(capturedResponseMessage);
-                                        turnNewUIMessages.push(capturedResponseMessage);
-                                        locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
-                                    }
-                                }
                                 if (capturedResponseMessage) {
                                     responseCommitted = true;
                                     capturedPartialResponse = capturedResponseMessage;
@@ -5842,12 +6044,14 @@ function chatAgent(options) {
                                 const outerCompaction = locals_js_1.locals.get(chatAgentCompactionKey);
                                 const innerCompactionState = locals_js_1.locals.get(chatCompactionStateKey);
                                 if (outerCompaction && !innerCompactionState && turnUsage && !wasStopped) {
+                                    const contextUsage = lastStepUsage ?? turnUsage;
                                     const shouldTrigger = await outerCompaction.shouldCompact({
                                         messages: accumulatedMessages,
-                                        totalTokens: turnUsage.totalTokens,
-                                        inputTokens: turnUsage.inputTokens,
-                                        outputTokens: turnUsage.outputTokens,
-                                        usage: turnUsage,
+                                        totalTokens: contextUsage.totalTokens,
+                                        inputTokens: contextUsage.inputTokens,
+                                        outputTokens: contextUsage.outputTokens,
+                                        usage: contextUsage,
+                                        turnUsage,
                                         totalUsage: cumulativeUsage,
                                         chatId: currentWirePayload.chatId,
                                         turn,
@@ -5978,6 +6182,8 @@ function chatAgent(options) {
                                     totalUsage: cumulativeUsage,
                                     finishReason: capturedFinishReason,
                                 };
+                                const beforeHookRevision = locals_js_1.locals.get(chatManagedResponseKey)?.revision ?? 0;
+                                let beforeHookHistoryEdited = false;
                                 // Fire onBeforeTurnComplete — stream is still open so the hook
                                 // can write custom chunks to the frontend (e.g. compaction progress).
                                 if (onBeforeTurnComplete) {
@@ -5988,9 +6194,10 @@ function chatAgent(options) {
                                         // Check if the hook replaced messages (compaction or chat.history)
                                         const override = locals_js_1.locals.get(chatOverrideMessagesKey);
                                         if (override) {
+                                            beforeHookHistoryEdited = true;
                                             locals_js_1.locals.set(chatOverrideMessagesKey, undefined);
                                             accumulatedUIMessages = [...override];
-                                            accumulatedMessages = await toModelMessages(override);
+                                            accumulatedMessages = await toModelMessages(override, override);
                                             laneCompacted = false;
                                             laneInjections = [];
                                             locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
@@ -6007,35 +6214,33 @@ function chatAgent(options) {
                                         },
                                     });
                                 }
-                                // Drain any late response parts added during onBeforeTurnComplete
-                                const lateParts = locals_js_1.locals.get(chatResponsePartsKey);
-                                if (lateParts && lateParts.length > 0 && capturedResponseMessage) {
-                                    const idx = accumulatedUIMessages.findIndex((m) => m.id === capturedResponseMessage.id);
-                                    if (idx !== -1) {
-                                        const msg = accumulatedUIMessages[idx];
-                                        accumulatedUIMessages[idx] = {
-                                            ...msg,
-                                            parts: [...(msg.parts ?? []), ...lateParts],
-                                        };
-                                        capturedResponseMessage = accumulatedUIMessages[idx];
-                                        capturedPartialResponse = capturedResponseMessage;
-                                        turnCompleteEvent.responseMessage = capturedResponseMessage;
-                                        turnCompleteEvent.uiMessages = accumulatedUIMessages;
-                                        locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
-                                    }
-                                    else if (responseWasSkipped) {
-                                        capturedResponseMessage = {
-                                            ...capturedResponseMessage,
-                                            parts: [...(capturedResponseMessage.parts ?? []), ...lateParts],
-                                        };
-                                        accumulatedUIMessages.push(capturedResponseMessage);
-                                        turnNewUIMessages.push(capturedResponseMessage);
-                                        capturedPartialResponse = capturedResponseMessage;
-                                        turnCompleteEvent.responseMessage = capturedResponseMessage;
+                                const editedResponse = beforeHookHistoryEdited && capturedResponseMessage
+                                    ? accumulatedUIMessages.find((message) => message.id === capturedResponseMessage?.id)
+                                    : undefined;
+                                const finalManagedResponse = await locals_js_1.locals
+                                    .get(chatManagedResponseKey)
+                                    ?.snapshot(editedResponse
+                                    ? { message: editedResponse, from: beforeHookRevision }
+                                    : undefined);
+                                if (finalManagedResponse?.parts.some((part) => part.type !== "step-start")) {
+                                    const idx = accumulatedUIMessages.findIndex((m) => m.id === finalManagedResponse.id);
+                                    const finalized = (wasStopped ? cleanupAbortedParts(finalManagedResponse) : finalManagedResponse);
+                                    if (idx !== -1 || responseWasSkipped || !capturedResponseMessage) {
+                                        if (idx !== -1)
+                                            accumulatedUIMessages[idx] = finalized;
+                                        else
+                                            accumulatedUIMessages.push(finalized);
+                                        const deltaIdx = turnNewUIMessages.findIndex((m) => m.id === finalized.id);
+                                        if (deltaIdx !== -1)
+                                            turnNewUIMessages[deltaIdx] = finalized;
+                                        else
+                                            turnNewUIMessages.push(finalized);
+                                        capturedResponseMessage = finalized;
+                                        capturedPartialResponse = finalized;
+                                        turnCompleteEvent.responseMessage = finalized;
                                         turnCompleteEvent.uiMessages = accumulatedUIMessages;
                                         locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
                                     }
-                                    locals_js_1.locals.set(chatResponsePartsKey, []);
                                 }
                                 settleRecoveredTurn(currentWirePayload);
                                 // Write turn-complete control chunk — closes the frontend stream.
@@ -6052,7 +6257,7 @@ function chatAgent(options) {
                                         if (turnCompleteOverride) {
                                             locals_js_1.locals.set(chatOverrideMessagesKey, undefined);
                                             accumulatedUIMessages = [...turnCompleteOverride];
-                                            accumulatedMessages = await toModelMessages(turnCompleteOverride);
+                                            accumulatedMessages = await toModelMessages(turnCompleteOverride, turnCompleteOverride);
                                             laneCompacted = false;
                                             laneInjections = [];
                                             locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
@@ -6172,7 +6377,7 @@ function chatAgent(options) {
                             const next = await messagesInput.waitWithIdleTimeout({
                                 idleTimeoutInSeconds: effectiveIdleTimeout,
                                 timeout: effectiveTurnTimeout,
-                                spanName: "waiting for next message",
+                                spanName: "next message",
                                 onSuspend: onChatSuspend
                                     ? async () => {
                                         await tracer_js_1.tracer.startActiveSpan("onChatSuspend()", async () => {
@@ -6288,7 +6493,8 @@ function chatAgent(options) {
                             !accumulatedUIMessages.some((m) => m.id === erroredWireMessage.id)
                             ? [...accumulatedUIMessages, erroredWireMessage]
                             : accumulatedUIMessages;
-                        let partialResponse = capturedPartialResponse ??
+                        let partialResponse = (await locals_js_1.locals.get(chatManagedResponseKey)?.snapshot()) ??
+                            capturedPartialResponse ??
                             (await assemblePartialFromChunks(turnBufferedChunks));
                         if (partialResponse) {
                             partialResponse = cleanupAbortedParts(partialResponse);
@@ -6296,24 +6502,21 @@ function chatAgent(options) {
                         let partialIdx = partialResponse?.id
                             ? erroredUIMessages.findIndex((m) => m.id === partialResponse.id)
                             : -1;
-                        if (partialResponse && capturedPartialResponse === undefined && partialIdx !== -1) {
+                        if (partialResponse &&
+                            capturedPartialResponse === undefined &&
+                            !locals_js_1.locals.get(chatManagedResponseKey)?.continues(partialResponse.id) &&
+                            partialIdx !== -1) {
                             partialResponse = undefined;
                             partialIdx = -1;
                         }
                         if (partialResponse && !partialResponse.id) {
                             partialResponse = { ...partialResponse, id: (0, ai_runtime_js_1.generateId)() };
                         }
-                        if (partialResponse && !responseCommitted) {
-                            const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
-                            if (queuedParts && queuedParts.length > 0) {
-                                partialResponse = {
-                                    ...partialResponse,
-                                    parts: [...partialResponse.parts, ...queuedParts],
-                                };
-                                locals_js_1.locals.set(chatResponsePartsKey, []);
-                            }
-                        }
                         const includePartial = partialResponse != null && !responseCommitted;
+                        // What the stream left behind, by content. After `onTurnComplete` the
+                        // partial is still unfinished only if the message under its id is
+                        // byte-for-byte this: a clone keeps it partial, an edit finishes it.
+                        const partialFingerprint = includePartial && partialResponse ? (0, transcriptStorage_js_1.fingerprintMessage)(partialResponse) : undefined;
                         let erroredUIMessagesWithPartial = !includePartial
                             ? erroredUIMessages
                             : partialIdx === -1
@@ -6341,7 +6544,7 @@ function chatAgent(options) {
                         };
                         let erroredNewUIMessages = buildErroredNew();
                         let erroredNewModelMessages = [];
-                        const reconciledSteer = reconcilePendingSteer();
+                        const reconciledSteer = reconcilePendingSteer({ response: partialResponse });
                         const backgroundTailThisTurn = reconcilePendingBackground();
                         if (!responseCommitted) {
                             try {
@@ -6352,14 +6555,7 @@ function chatAgent(options) {
                                      * the model received it (what `prepare` produced), matching the
                                      * lane. The wire message and partial are converted as before.
                                      */
-                                    const steerModelById = new Map(reconciledSteer.map((e) => [e.ui.id, e.model]));
-                                    for (const m of erroredNewUIMessages) {
-                                        const recorded = steerModelById.get(m.id);
-                                        if (recorded)
-                                            erroredNewModelMessages.push(...recorded);
-                                        else
-                                            erroredNewModelMessages.push(...(await toModelMessages([stripProviderMetadata(m)])));
-                                    }
+                                    erroredNewModelMessages = await toModelMessages(erroredNewUIMessages.map(stripProviderMetadata));
                                 }
                                 if (erroredUIMessagesWithPartial !== accumulatedUIMessages) {
                                     if (partialIdx === -1) {
@@ -6371,7 +6567,7 @@ function chatAgent(options) {
                                             backgroundTailThisTurn);
                                         if (!ok) {
                                             v3_1.logger.warn("chat.agent: replaced partial not found at the model lane tail; reconverting the lane");
-                                            accumulatedMessages = await toModelMessages(erroredUIMessagesWithPartial);
+                                            accumulatedMessages = await toModelMessages(erroredUIMessagesWithPartial, erroredUIMessagesWithPartial);
                                             laneCompacted = false;
                                             laneInjections = [];
                                         }
@@ -6386,6 +6582,11 @@ function chatAgent(options) {
                                 erroredNewUIMessages = buildErroredNew().filter((m) => m !== partialResponse);
                             }
                         }
+                        // An earlier hook that set the history and then threw (which is one way
+                        // to get here) left its abandoned edit pending. Discard it before the
+                        // failed turn continues, so neither the error-path `onTurnComplete`
+                        // below nor the next turn's history reads mistake it for a real edit.
+                        locals_js_1.locals.set(chatOverrideMessagesKey, undefined);
                         if (onTurnComplete) {
                             try {
                                 await tracer_js_1.tracer.startActiveSpan("onTurnComplete()", async () => {
@@ -6414,6 +6615,23 @@ function chatAgent(options) {
                                         error: turnError,
                                         lastEventId: errorTurnCompleteResult?.lastEventId,
                                     });
+                                    // The hook may edit the history here too (a failure record, a
+                                    // card the turn left open). Honour it the way the success path
+                                    // does, so the edit reaches the accumulator and the save below.
+                                    const errorTurnOverride = locals_js_1.locals.get(chatOverrideMessagesKey);
+                                    if (errorTurnOverride) {
+                                        locals_js_1.locals.set(chatOverrideMessagesKey, undefined);
+                                        // Convert first: a rejected conversion (a tool's `toModelOutput`
+                                        // can throw) must leave every lane on the history it had.
+                                        const overrideUIMessages = [...errorTurnOverride];
+                                        const overrideModelMessages = await toModelMessages(errorTurnOverride, errorTurnOverride);
+                                        erroredUIMessagesWithPartial = overrideUIMessages;
+                                        accumulatedUIMessages = overrideUIMessages;
+                                        accumulatedMessages = overrideModelMessages;
+                                        laneCompacted = false;
+                                        laneInjections = [];
+                                        locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
+                                    }
                                 }, {
                                     attributes: {
                                         [v3_1.SemanticInternalAttributes.STYLE_ICON]: "task-hook-onComplete",
@@ -6427,6 +6645,7 @@ function chatAgent(options) {
                             catch {
                                 // A throwing onTurnComplete on the error path must not crash
                                 // the run — keep the conversation alive for the next message.
+                                locals_js_1.locals.set(chatOverrideMessagesKey, undefined);
                             }
                         }
                         // Persist a snapshot so the failed turn's user message isn't
@@ -6444,7 +6663,10 @@ function chatAgent(options) {
                                     trigger: storageTrigger(currentWirePayload.trigger),
                                     clientData: turnClientData,
                                     lastOutEventId: lastSnapshotOutEventId,
-                                    nonFinalIds: includePartial && partialResponse ? new Set([partialResponse.id]) : undefined,
+                                    // The partial is non-final only while the message under its id is
+                                    // still what the stream left behind. A hook that replaced it (a
+                                    // closed card, a finished body) produced a final message.
+                                    nonFinalIds: partialStillUnfinished(partialResponse, partialFingerprint, erroredUIMessagesWithPartial),
                                 });
                             }
                             catch (error) {
@@ -6479,7 +6701,7 @@ function chatAgent(options) {
                         const next = await messagesInput.waitWithIdleTimeout({
                             idleTimeoutInSeconds: effectiveIdleTimeout,
                             timeout: effectiveTurnTimeout,
-                            spanName: "waiting for next message (after error)",
+                            spanName: "next message (after error)",
                         });
                         if (!next.ok) {
                             return; // Timed out — end run gracefully
@@ -6495,6 +6717,11 @@ function chatAgent(options) {
                     }
                     finally {
                         turnMsgSub?.off();
+                        locals_js_1.locals.set(chatManagedResponseActiveKey, false);
+                        await locals_js_1.locals
+                            .get(chatManagedResponseKey)
+                            ?.close()
+                            .catch(() => { });
                     }
                 }
             }
@@ -7464,7 +7691,7 @@ async function pipeChatAndCapture(source, options) {
         await pipeChat(tappedStream, {
             signal: options?.signal,
             spanName: options?.spanName ?? "stream response",
-        });
+        }, { originalMessages: options?.originalMessages });
         // The pipe can drain cleanly on a stop — the source stream just ends
         // early — so classify by the signal rather than relying on a throw.
         if (options?.signal?.aborted) {
@@ -7490,6 +7717,9 @@ async function pipeChatAndCapture(source, options) {
     if (!captured && bufferedChunks.length > 0) {
         captured = await assemblePartialFromChunks(bufferedChunks);
     }
+    captured = (await locals_js_1.locals.get(chatManagedResponseKey)?.snapshot()) ?? captured;
+    if (!locals_js_1.locals.get(chatTurnContextKey))
+        await locals_js_1.locals.get(chatManagedResponseKey)?.close();
     return {
         message: captured,
         status,
@@ -7519,8 +7749,11 @@ class ChatMessageAccumulator {
     modelMessages = [];
     uiMessages = [];
     _compaction;
+    /** The run a spliced head-start partial contributed, until its response replaces it. */
+    _handoverRun;
     _pendingMessages;
     _steeringQueue = [];
+    _pendingSteer = [];
     constructor(options) {
         this._compaction = options?.compaction;
         this._pendingMessages = options?.pendingMessages;
@@ -7562,7 +7795,7 @@ class ChatMessageAccumulator {
      * `consumeHandover` for the wait+seed+apply convenience.
      */
     applyHandover(signal) {
-        spliceHandoverPartial(this.modelMessages, this.uiMessages, signal);
+        this._handoverRun = spliceHandoverPartial(this.modelMessages, this.uiMessages, signal);
     }
     /**
      * One-call `chat.headStart` handover for a custom-agent loop: waits for the
@@ -7593,6 +7826,19 @@ class ChatMessageAccumulator {
         return { isFinal: signal.isFinal, skipped: false };
     }
     async addResponse(response) {
+        const inlineIds = new Set((0, steeringContext_js_1.steeringMarkers)([response]).flatMap((m) => m.messageIds));
+        for (const entry of this._pendingSteer.splice(0)) {
+            if (!inlineIds.has(entry.ui.id))
+                continue;
+            // absorbSteering is public and updates context immediately. Move just
+            // those exact appended objects into the response's chronological run;
+            // never rebuild a possibly compacted lane from the UI transcript.
+            for (const message of entry.model) {
+                const index = this.modelMessages.lastIndexOf(message);
+                if (index !== -1)
+                    this.modelMessages.splice(index, 1);
+            }
+        }
         if (!response.id) {
             response = { ...response, id: (0, ai_runtime_js_1.generateId)() };
         }
@@ -7605,8 +7851,13 @@ class ChatMessageAccumulator {
         if (existingIdx !== -1) {
             const previous = this.uiMessages[existingIdx];
             this.uiMessages[existingIdx] = response;
+            const handoverRun = this._handoverRun && this._handoverRun.id === previous.id
+                ? this._handoverRun.run
+                : undefined;
+            if (handoverRun)
+                this._handoverRun = undefined;
             try {
-                if (!(await replaceModelRun(this.modelMessages, previous, response, 0))) {
+                if (!(await replaceModelRun(this.modelMessages, previous, response, 0, handoverRun))) {
                     this.modelMessages = await toModelMessages(this.uiMessages.map((m) => stripProviderMetadata(m)));
                 }
             }
@@ -7664,7 +7915,10 @@ class ChatMessageAccumulator {
         this.uiMessages.push(...fresh);
         // Record what the model received. Only when the whole batch is new is
         // `injected` known to describe exactly these messages.
-        this.modelMessages.push(...(injected && fresh.length === claimed.length ? injected : await toModelMessages(fresh)));
+        const model = injected && fresh.length === claimed.length ? injected : await toModelMessages(fresh);
+        this.modelMessages.push(...model);
+        for (const ui of fresh)
+            this._pendingSteer.push({ ui, model: modelFormOf(ui, fresh, model) });
     }
     /**
      * Get and clear unconsumed steering messages.
@@ -7684,7 +7938,7 @@ class ChatMessageAccumulator {
         const comp = this._compaction;
         const pm = this._pendingMessages;
         const queue = this._steeringQueue;
-        return async ({ messages, steps }) => {
+        return (0, steeringContext_js_1.retainStepMessages)(async ({ messages, steps }) => {
             let resultMessages;
             // 1. Compaction
             if (comp) {
@@ -7697,7 +7951,7 @@ class ChatMessageAccumulator {
                 }
             }
             // 2. Pending message injection
-            if (pm && queue.length > 0) {
+            if (pm) {
                 const { injected, claimed } = await drainSteeringQueue(pm, resultMessages ?? messages, steps, queue);
                 await this.absorbSteering(claimed, injected);
                 if (injected.length > 0) {
@@ -7705,12 +7959,14 @@ class ChatMessageAccumulator {
                 }
             }
             return resultMessages ? { messages: resultMessages } : undefined;
-        };
+        });
     }
     /**
      * Run outer-loop compaction if needed. Call after adding the response
-     * and capturing usage. Applies `compactModelMessages` and `compactUIMessages`
-     * callbacks if configured.
+     * and capturing usage. Pass the LAST step's usage (`result.usage`), which is
+     * the context the model held on its final call; `result.totalUsage` sums every
+     * step of a tool-using turn and belongs in `context.turnUsage`. Applies
+     * `compactModelMessages` and `compactUIMessages` callbacks if configured.
      *
      * @returns `true` if compaction was performed, `false` otherwise.
      */
@@ -7723,6 +7979,7 @@ class ChatMessageAccumulator {
             inputTokens: usage.inputTokens,
             outputTokens: usage.outputTokens,
             usage,
+            turnUsage: context?.turnUsage,
             totalUsage: context?.totalUsage,
             chatId: context?.chatId,
             turn: context?.turn,
@@ -7955,8 +8212,8 @@ function createChatSession(payload, options) {
                             idleTimeoutInSeconds: sessionIdleTimeoutOpt ?? currentPayload.idleTimeoutInSeconds ?? 30,
                             timeout,
                             spanName: currentPayload.trigger === "preload"
-                                ? "waiting for first message"
-                                : "waiting for first message (continuation)",
+                                ? "first message"
+                                : "first message (continuation)",
                         });
                         if (!result.ok || runSignal.aborted) {
                             stop.cleanup();
@@ -7993,7 +8250,7 @@ function createChatSession(payload, options) {
                         const next = await messagesInput.waitWithIdleTimeout({
                             idleTimeoutInSeconds,
                             timeout,
-                            spanName: "waiting for next message",
+                            spanName: "next message",
                         });
                         if (!next.ok || runSignal.aborted) {
                             stop.cleanup();
@@ -8014,7 +8271,9 @@ function createChatSession(payload, options) {
                     // Reset stop signal for this turn
                     stop.reset();
                     // Reset per-turn state
-                    locals_js_1.locals.set(chatResponsePartsKey, []);
+                    await locals_js_1.locals.get(chatManagedResponseKey)?.close();
+                    locals_js_1.locals.set(chatManagedResponseKey, undefined);
+                    locals_js_1.locals.set(chatManagedResponseActiveKey, true);
                     // Set up steering queue and pending messages config in locals
                     // so toStreamTextOptions() auto-injects prepareStep for steering
                     const turnSteeringQueue = [];
@@ -8159,11 +8418,6 @@ function createChatSession(payload, options) {
                                 if (captured.status === "error") {
                                     if (captured.message) {
                                         const partial = cleanupAbortedParts(captured.message);
-                                        const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
-                                        if (queuedParts && queuedParts.length > 0) {
-                                            partial.parts = [...(partial.parts ?? []), ...queuedParts];
-                                            locals_js_1.locals.set(chatResponsePartsKey, []);
-                                        }
                                         await accumulator.addResponse(partial);
                                     }
                                     throw captured.error;
@@ -8179,31 +8433,14 @@ function createChatSession(payload, options) {
                                 const cleaned = stop.signal.aborted && !runSignal.aborted
                                     ? cleanupAbortedParts(response)
                                     : response;
-                                // Append any non-transient data parts queued via chat.response or writer.write()
-                                const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
-                                if (queuedParts && queuedParts.length > 0) {
-                                    cleaned.parts = [...(cleaned.parts ?? []), ...queuedParts];
-                                    locals_js_1.locals.set(chatResponsePartsKey, []);
-                                }
                                 await accumulator.addResponse(cleaned);
                             }
-                            else {
-                                // No response (manual pipe mode) but there are queued data parts
-                                const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
-                                if (queuedParts && queuedParts.length > 0) {
-                                    await accumulator.addResponse({
-                                        id: (0, ai_runtime_js_1.generateId)(),
-                                        role: "assistant",
-                                        parts: queuedParts,
-                                    });
-                                    locals_js_1.locals.set(chatResponsePartsKey, []);
-                                }
-                            }
                             // Capture token usage from the streamText result. Race with a 2s
                             // timeout — on stop-abort the AI SDK's totalUsage promise can hang
                             // indefinitely, which would wedge the turn loop (same guard as
                             // chat.agent's turn loop).
                             let turnUsage;
+                            let lastStepUsage;
                             if (typeof source.totalUsage?.then === "function") {
                                 try {
                                     const usage = (await Promise.race([
@@ -8220,14 +8457,28 @@ function createChatSession(payload, options) {
                                     /* non-fatal */
                                 }
                             }
+                            const lastStepUsagePromise = source.usage;
+                            if (typeof lastStepUsagePromise?.then === "function") {
+                                try {
+                                    lastStepUsage = (await Promise.race([
+                                        lastStepUsagePromise,
+                                        new Promise((r) => setTimeout(() => r(undefined), 2_000)),
+                                    ]));
+                                }
+                                catch {
+                                    /* non-fatal */
+                                }
+                            }
                             // Outer-loop compaction (same logic as chat.agent)
                             if (sessionCompaction && turnUsage && !turnObj.stopped) {
+                                const contextUsage = lastStepUsage ?? turnUsage;
                                 const shouldTrigger = await sessionCompaction.shouldCompact({
                                     messages: accumulator.modelMessages,
-                                    totalTokens: turnUsage.totalTokens,
-                                    inputTokens: turnUsage.inputTokens,
-                                    outputTokens: turnUsage.outputTokens,
-                                    usage: turnUsage,
+                                    totalTokens: contextUsage.totalTokens,
+                                    inputTokens: contextUsage.inputTokens,
+                                    outputTokens: contextUsage.outputTokens,
+                                    usage: contextUsage,
+                                    turnUsage,
                                     totalUsage: cumulativeUsage,
                                     chatId: currentPayload.chatId,
                                     turn,
@@ -8274,15 +8525,6 @@ function createChatSession(payload, options) {
                             return response;
                         },
                         async addResponse(response) {
-                            // Append any non-transient data parts queued via chat.response or writer.write()
-                            const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
-                            if (queuedParts && queuedParts.length > 0) {
-                                response = {
-                                    ...response,
-                                    parts: [...(response.parts ?? []), ...queuedParts],
-                                };
-                                locals_js_1.locals.set(chatResponsePartsKey, []);
-                            }
                             await accumulator.addResponse(response);
                         },
                         async done() {
@@ -8294,7 +8536,7 @@ function createChatSession(payload, options) {
                             const hasPending = !!sessionPendingMessages;
                             if (!hasCompaction && !hasPending)
                                 return undefined;
-                            return async ({ messages: stepMsgs, steps, }) => {
+                            return (0, steeringContext_js_1.retainStepMessages)(async ({ messages: stepMsgs, steps, }) => {
                                 let resultMessages;
                                 if (sessionCompaction) {
                                     const compactResult = await chatCompact(stepMsgs, steps, {
@@ -8313,7 +8555,7 @@ function createChatSession(payload, options) {
                                     }
                                 }
                                 return resultMessages ? { messages: resultMessages } : undefined;
-                            };
+                            });
                         },
                     };
                     return { done: false, value: turnObj };
@@ -8581,6 +8823,10 @@ function createChatStartSessionAction(taskId, options) {
         const clientDataMetadata = params.clientData !== undefined ? { metadata: params.clientData } : {};
         const maxAttempts = params.triggerConfig?.maxAttempts ?? options?.triggerConfig?.maxAttempts;
         const maxDuration = params.triggerConfig?.maxDuration ?? options?.triggerConfig?.maxDuration;
+        const concurrency = params.triggerConfig?.concurrency !== undefined
+            ? params.triggerConfig.concurrency
+            : options?.triggerConfig?.concurrency;
+        const concurrencyKey = params.triggerConfig?.concurrencyKey ?? options?.triggerConfig?.concurrencyKey;
         const idleTimeoutInSeconds = params.triggerConfig?.idleTimeoutInSeconds ?? options?.triggerConfig?.idleTimeoutInSeconds;
         // Only `undefined` means "not supplied": a per-call `null` (opt out) has to beat a pinning
         // action default, which neither truthiness nor `??` would allow.
@@ -8602,6 +8848,8 @@ function createChatStartSessionAction(taskId, options) {
             ...(options?.triggerConfig?.queue || params.triggerConfig?.queue
                 ? { queue: params.triggerConfig?.queue ?? options?.triggerConfig?.queue }
                 : {}),
+            ...(concurrency !== undefined ? (0, concurrency_shared_js_1.triggerConcurrencyBody)(concurrency) : {}),
+            ...(concurrencyKey !== undefined ? { concurrencyKey } : {}),
             tags,
             ...(maxAttempts !== undefined ? { maxAttempts } : {}),
             ...(maxDuration !== undefined ? { maxDuration } : {}),
@@ -8839,6 +9087,7 @@ exports.chat = {
     cleanupAbortedParts,
     /** Register background work that runs in parallel with streaming. See {@link chatDefer}. */
     defer: chatDefer,
+    deferBeforeOutput: chatDeferBeforeOutput,
     /** Queue model messages for injection at the next `prepareStep` boundary. See {@link injectBackgroundContext}. */
     inject: injectBackgroundContext,
     /** Typed chat output stream for writing custom chunks or piping from subtasks. */
@@ -8948,6 +9197,10 @@ exports.chat = {
  * @internal
  */
 async function writeTurnCompleteChunk(_chatId, publicAccessToken) {
+    locals_js_1.locals.set(chatManagedResponseActiveKey, false);
+    const response = locals_js_1.locals.get(chatManagedResponseKey);
+    if (response)
+        await response.close();
     const session = getChatSession();
     // A handover-prepare boot claims the handover kinds so a signal arriving
     // before `waitForHandover` attaches is not drained. Released here rather than