@trigger.dev/sdk 4.6.4 → 4.7.1

package/dist/esm/v3/ai.js

@@ -3,9 +3,12 @@ import { accessoryAttributes, apiClientManager, controlSubtype, generateJWT, get
 // ESM-only `ai@7` (see ../imports/ai-runtime.ts).
 import { trace } from "@opentelemetry/api";
 import { traceSessionIdle } from "./sessionTracing.js";
+import { waitForChatRouteAfterIdle } from "./chatRouteWait.js";
 import { tool as aiTool, convertToModelMessages, dynamicTool, generateId as generateMessageId, getToolName, isToolUIPart, jsonSchema, readUIMessageStream, streamText as aiStreamText, zodSchema, } from "../imports/ai-runtime.js";
 import { createTranscriptShadow, defaultStorage, diffTranscript, fingerprintMessage, parseTranscriptRuntimeState, restoreModelLane, } from "./transcriptStorage.js";
 import { responseAfterCompaction } from "./compactionResponse.js";
+import { ManagedChatResponse, createOrderedChatWriter } from "./managedChatResponse.js";
+import { convertSteeredMessages, retainStepMessages, steeringMarkers, } from "./steeringContext.js";
 let transcriptStorageOverride;
 /**
  * Test-only override for the storage `chat.agent` persists through, so a
@@ -33,6 +36,7 @@ import { withResolvedExternalDeploymentId } from "./externalDeploymentId.js";
 import { resolvePinToFollow } from "./chatVersionSkew.js";
 import { sessions, } from "./sessions.js";
 import { createTask } from "./shared.js";
+import { triggerConcurrencyBody } from "./concurrency-shared.js";
 import { markChatAgentRunForStreamsWarning } from "./streams.js";
 import { tracer } from "./tracer.js";
 const METADATA_KEY = "tool.execute.options";
@@ -41,17 +45,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.get(chatResolvedToolsKey);
-    return convertToModelMessages(messages, {
+    return convertSteeredMessages(messages, async (batch) => convertToModelMessages(batch, {
         ignoreIncompleteToolCalls: true,
         ...(tools ? { tools } : {}),
-    });
+    }), locals.get(chatSteeringInjectionsKey) ?? new Map(), context ?? locals.get(chatCurrentUIMessagesKey) ?? messages, context !== undefined || locals.get(chatCurrentUIMessagesKey) !== undefined);
 }
 const chatTurnContextKey = locals.create("chat.turnContext");
 /**
@@ -848,7 +852,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
@@ -866,15 +870,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);
     },
 };
 /**
@@ -883,60 +879,13 @@ const chatResponse = {
  * @internal
  */
 function createLazyChatWriter() {
-    let writeImpl = null;
-    let mergeImpl = null;
-    let waitPromise = null;
-    let resolveExecute = null;
-    let started = false;
-    const bufferedParts = [];
-    const bufferedStreams = [];
-    function ensureInitialized() {
-        if (started)
-            return;
-        started = true;
-        const executePromise = new Promise((resolve) => {
-            resolveExecute = resolve;
-        });
-        const { waitUntilComplete } = chatStream.writer({
+    return createOrderedChatWriter(() => (locals.get(chatManagedResponseActiveKey) ? managedResponse() : undefined), async (stream) => {
+        const { waitUntilComplete } = chatStream.pipe(stream, {
             collapsed: true,
             spanName: "callback writer",
-            execute: ({ write, merge }) => {
-                writeImpl = write;
-                mergeImpl = merge;
-                for (const part of bufferedParts.splice(0))
-                    write(part);
-                for (const stream of bufferedStreams.splice(0))
-                    merge(stream);
-                return executePromise;
-            },
         });
-        waitPromise = waitUntilComplete;
-    }
-    return {
-        writer: {
-            write(part) {
-                ensureInitialized();
-                queueResponsePart(part);
-                if (writeImpl)
-                    writeImpl(part);
-                else
-                    bufferedParts.push(part);
-            },
-            merge(stream) {
-                ensureInitialized();
-                if (mergeImpl)
-                    mergeImpl(stream);
-                else
-                    bufferedStreams.push(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.
@@ -1112,31 +1061,20 @@ async function waitOnChatRoute(route, options) {
         if (options.onSuspend)
             await options.onSuspend();
         span.setAttribute("wait.resolved", "suspended");
-        while (true) {
-            /**
-             * The floor doubles as the wake cursor: the server completes the
-             * waitpoint immediately if anything sits after this sequence, so a
-             * floor that has advanced past an unread record parks a waitpoint
-             * nothing will complete. Recorded on the span so a run that never woke
-             * can be diagnosed from its trace alone.
-             */
-            const wakeFrom = router.resumeFloor();
-            span.setAttribute("wait.lastSeqNum", wakeFrom ?? -1);
-            const wake = await session.in.awaitWake({
-                timeout: options.timeout,
-                lastSeqNum: wakeFrom,
-            });
-            if (!wake.ok) {
-                span.recordException(wake.error);
-                return { ok: false, error: wake.error };
-            }
-            const record = await router.next(route);
-            if (!record)
-                continue;
-            if (options.onResume)
-                await options.onResume();
-            return { ok: true, output: record.data, record };
+        const result = await waitForChatRouteAfterIdle(router, route, {
+            timeout: options.timeout,
+            wake: async (timeout, lastSeqNum) => {
+                span.setAttribute("wait.lastSeqNum", lastSeqNum ?? -1);
+                return session.in.awaitWake({ timeout, lastSeqNum });
+            },
+        });
+        if (!result.ok) {
+            span.recordException(result.error);
+            return result;
         }
+        if (options.onResume)
+            await options.onResume();
+        return { ok: true, output: result.record.data, record: result.record };
     }, {
         attributes: {
             [SemanticInternalAttributes.STYLE_ICON]: "sessions",
@@ -2537,29 +2475,19 @@ const chatTurnNewUIMessagesKey = locals.create("chat.turnNewUIMessages");
 const chatPendingSteerKey = locals.create("chat.pendingSteer");
 /** @internal — IDs of messages that were successfully injected via prepareStep */
 const chatInjectedMessageIdsKey = 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.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.get(chatResponsePartsKey) ?? [];
-    parts.push(part);
-    locals.set(chatResponsePartsKey, parts);
+const chatManagedResponseKey = locals.create("chat.managedResponse");
+const chatManagedResponseActiveKey = locals.create("chat.managedResponseActive");
+const chatSteeringInjectionsKey = locals.create("chat.steeringInjections");
+function managedResponse() {
+    let response = locals.get(chatManagedResponseKey);
+    if (!response || response.isClosed) {
+        response = new ManagedChatResponse(async (stream) => {
+            const { waitUntilComplete } = chatStream.pipe(stream, { spanName: "managed chat response" });
+            await waitUntilComplete();
+        });
+        locals.set(chatManagedResponseKey, response);
+    }
+    return response;
 }
 /**
  * Check that no tool calls are in-flight in a step's content.
@@ -2911,6 +2839,8 @@ function modelFormOf(m, batch, injected) {
  * @internal
  */
 async function drainSteeringQueue(config, messages, steps, queueOverride) {
+    if (steps.length === 0)
+        managedResponse().beginGeneration();
     const queue = queueOverride ?? locals.get(chatSteeringQueueKey);
     if (!queue || queue.length === 0)
         return EMPTY_DRAIN;
@@ -3043,31 +2973,24 @@ async function drainSteeringQueue(config, messages, steps, queueOverride) {
             }
             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: PENDING_MESSAGE_INJECTED_TYPE,
-                            id: generateMessageId(),
-                            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 = generateMessageId();
+            const messageIds = claimedUIMessages.map((m) => m.id);
+            const injections = locals.get(chatSteeringInjectionsKey) ?? new Map();
+            injections.set(id, { id, messageIds, messages: injected });
+            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: 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) {
@@ -3368,7 +3291,7 @@ function buildManagedStreamTextOptions(options, config) {
          * regenerate needs: without it a regenerated answer can call nothing.
          */
         tools: (tools ?? agentTools),
-    });
+    }, false);
     const promptSystem = locals.get(chatPromptKey)?.text;
     /**
      * Two managed sources conflict too, not only a caller against a managed one.
@@ -3395,6 +3318,9 @@ function buildManagedStreamTextOptions(options, config) {
             return { ...(first ?? {}), ...(second ?? {}) };
         };
     }
+    if (typeof managed.prepareStep === "function") {
+        managed.prepareStep = retainStepMessages(managed.prepareStep);
+    }
     return { ...managed, ...rest };
 }
 /** @internal Test hook for {@link buildManagedStreamTextOptions}. */
@@ -3410,7 +3336,7 @@ function createBoundStreamText(registry, agentSystem, agentCacheControl, agentSy
     }));
     return bound;
 }
-function toStreamTextOptions(options) {
+function toStreamTextOptions(options, retain = true) {
     const agentDefaults = locals.get(chatAgentManagedConfigKey);
     if (agentDefaults) {
         options = {
@@ -3617,6 +3543,9 @@ function toStreamTextOptions(options) {
             return resultMessages ? { messages: resultMessages } : undefined;
         };
     }
+    if (retain && typeof result.prepareStep === "function") {
+        result.prepareStep = retainStepMessages(result.prepareStep);
+    }
     return result;
 }
 const actionTurnBrand = Symbol.for("trigger.dev/chat/actionTurn");
@@ -3751,7 +3680,7 @@ function isReadableStream(value) {
  * }
  * ```
  */
-async function pipeChat(source, options) {
+async function pipeChat(source, options, capture) {
     locals.set(chatPipeCountKey, (locals.get(chatPipeCountKey) ?? 0) + 1);
     let stream;
     if (isUIMessageStreamable(source)) {
@@ -3780,8 +3709,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;
@@ -4034,11 +3973,13 @@ function chatAgent(options) {
                 if (!pending || pending.length === 0)
                     return [];
                 locals.set(chatPendingSteerKey, []);
-                for (const entry of pending) {
+                const inlineIds = new Set(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.).
@@ -4132,7 +4073,10 @@ function chatAgent(options) {
                 });
                 const throughId = opts.messages.at(-1)?.id ?? "";
                 const queued = 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(steeringMarkers(opts.messages).map((marker) => marker.id));
+                const steering = [...(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
@@ -4145,6 +4089,7 @@ function chatAgent(options) {
                             : {}),
                         ...(laneInjections.length > 0 ? { injections: laneInjections } : {}),
                         ...(queued.length > 0 ? { queued: [...queued] } : {}),
+                        ...(steering.length > 0 ? { steering } : {}),
                     }
                     : null;
                 if (runtimeState !== null || persistedStateSet) {
@@ -4614,6 +4559,8 @@ function chatAgent(options) {
                     }
                     try {
                         const bootRuntimeState = parseTranscriptRuntimeState(bootTranscriptState);
+                        locals.set(chatSteeringInjectionsKey, new Map((bootRuntimeState?.steering ?? []).map((entry) => [entry.id, entry])));
+                        locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
                         const restored = await restoreModelLane(accumulatedUIMessages, bootRuntimeState, (messages) => toModelMessages(messages));
                         accumulatedMessages = restored.messages;
                         laneCompacted = restored.compacted;
@@ -5061,7 +5008,9 @@ function chatAgent(options) {
                             locals.set(chatCompactionStateKey, undefined);
                             locals.set(chatSteeringQueueKey, []);
                             locals.set(chatPendingBackgroundKey, []);
-                            locals.set(chatResponsePartsKey, []);
+                            await locals.get(chatManagedResponseKey)?.close();
+                            locals.set(chatManagedResponseKey, undefined);
+                            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().
@@ -5225,7 +5174,7 @@ function chatAgent(options) {
                                     if (actionOverride) {
                                         locals.set(chatOverrideMessagesKey, undefined);
                                         accumulatedUIMessages = [...actionOverride];
-                                        accumulatedMessages = await toModelMessages(actionOverride);
+                                        accumulatedMessages = await toModelMessages(actionOverride, actionOverride);
                                         laneCompacted = false;
                                         laneInjections = [];
                                         locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
@@ -5383,7 +5332,7 @@ function chatAgent(options) {
                                             accumulatedUIMessages[accumulatedUIMessages.length - 1].role !== "user") {
                                             accumulatedUIMessages.pop();
                                         }
-                                        accumulatedMessages = await toModelMessages(accumulatedUIMessages);
+                                        accumulatedMessages = await toModelMessages(accumulatedUIMessages, accumulatedUIMessages);
                                         laneCompacted = false;
                                         laneInjections = [];
                                     }
@@ -5435,7 +5384,7 @@ function chatAgent(options) {
                                             }
                                             if (!inPlace) {
                                                 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 = [];
                                             }
@@ -5652,7 +5601,7 @@ function chatAgent(options) {
                                         if (turnStartOverride) {
                                             locals.set(chatOverrideMessagesKey, undefined);
                                             accumulatedUIMessages = [...turnStartOverride];
-                                            accumulatedMessages = await toModelMessages(turnStartOverride);
+                                            accumulatedMessages = await toModelMessages(turnStartOverride, turnStartOverride);
                                             laneCompacted = false;
                                             laneInjections = [];
                                             locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
@@ -5732,6 +5681,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.
                                     }
@@ -5791,7 +5741,7 @@ function chatAgent(options) {
                                         await pipeChat(tapUIMessageChunks(uiStream, turnBufferedChunks), {
                                             signal: combinedSignal,
                                             spanName: "stream response",
-                                        });
+                                        }, { originalMessages: isActionTurn ? undefined : accumulatedUIMessages });
                                     }
                                 }
                                 catch (error) {
@@ -5819,6 +5769,10 @@ function chatAgent(options) {
                                         new Promise((r) => setTimeout(r, 2_000)),
                                     ]);
                                 }
+                                capturedResponseMessage =
+                                    (await 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
@@ -5942,6 +5896,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
@@ -5964,15 +5919,6 @@ function chatAgent(options) {
                                             id: generateMessageId(),
                                         };
                                     }
-                                    // Append any non-transient data parts queued via chat.response or writer.write()
-                                    const queuedParts = locals.get(chatResponsePartsKey);
-                                    if (queuedParts && queuedParts.length > 0) {
-                                        capturedResponseMessage = {
-                                            ...capturedResponseMessage,
-                                            parts: [...capturedResponseMessage.parts, ...queuedParts],
-                                        };
-                                        locals.set(chatResponsePartsKey, []);
-                                    }
                                     const responseHasContent = capturedResponseMessage.parts.some((part) => part.type !== "step-start");
                                     if (responseHasContent) {
                                         // Tool-approval continuations: the AI SDK reuses the trailing
@@ -6034,7 +5980,7 @@ function chatAgent(options) {
                                                     locals.set(chatHandoverSplicedRunKey, undefined);
                                                 if (!ok) {
                                                     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 = [];
                                                 }
@@ -6052,22 +5998,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.get(chatResponsePartsKey);
-                                    if (remainingParts && remainingParts.length > 0) {
-                                        capturedResponseMessage = {
-                                            id: generateMessageId(),
-                                            role: "assistant",
-                                            parts: [...remainingParts],
-                                        };
-                                        locals.set(chatResponsePartsKey, []);
-                                        accumulatedUIMessages.push(capturedResponseMessage);
-                                        turnNewUIMessages.push(capturedResponseMessage);
-                                        locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
-                                    }
-                                }
                                 if (capturedResponseMessage) {
                                     responseCommitted = true;
                                     capturedPartialResponse = capturedResponseMessage;
@@ -6229,6 +6159,8 @@ function chatAgent(options) {
                                     totalUsage: cumulativeUsage,
                                     finishReason: capturedFinishReason,
                                 };
+                                const beforeHookRevision = 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) {
@@ -6239,9 +6171,10 @@ function chatAgent(options) {
                                         // Check if the hook replaced messages (compaction or chat.history)
                                         const override = locals.get(chatOverrideMessagesKey);
                                         if (override) {
+                                            beforeHookHistoryEdited = true;
                                             locals.set(chatOverrideMessagesKey, undefined);
                                             accumulatedUIMessages = [...override];
-                                            accumulatedMessages = await toModelMessages(override);
+                                            accumulatedMessages = await toModelMessages(override, override);
                                             laneCompacted = false;
                                             laneInjections = [];
                                             locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
@@ -6258,35 +6191,33 @@ function chatAgent(options) {
                                         },
                                     });
                                 }
-                                // Drain any late response parts added during onBeforeTurnComplete
-                                const lateParts = 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.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
+                                    .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.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
                                     }
-                                    locals.set(chatResponsePartsKey, []);
                                 }
                                 settleRecoveredTurn(currentWirePayload);
                                 // Write turn-complete control chunk — closes the frontend stream.
@@ -6303,7 +6234,7 @@ function chatAgent(options) {
                                         if (turnCompleteOverride) {
                                             locals.set(chatOverrideMessagesKey, undefined);
                                             accumulatedUIMessages = [...turnCompleteOverride];
-                                            accumulatedMessages = await toModelMessages(turnCompleteOverride);
+                                            accumulatedMessages = await toModelMessages(turnCompleteOverride, turnCompleteOverride);
                                             laneCompacted = false;
                                             laneInjections = [];
                                             locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
@@ -6539,7 +6470,8 @@ function chatAgent(options) {
                             !accumulatedUIMessages.some((m) => m.id === erroredWireMessage.id)
                             ? [...accumulatedUIMessages, erroredWireMessage]
                             : accumulatedUIMessages;
-                        let partialResponse = capturedPartialResponse ??
+                        let partialResponse = (await locals.get(chatManagedResponseKey)?.snapshot()) ??
+                            capturedPartialResponse ??
                             (await assemblePartialFromChunks(turnBufferedChunks));
                         if (partialResponse) {
                             partialResponse = cleanupAbortedParts(partialResponse);
@@ -6547,23 +6479,16 @@ 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.get(chatManagedResponseKey)?.continues(partialResponse.id) &&
+                            partialIdx !== -1) {
                             partialResponse = undefined;
                             partialIdx = -1;
                         }
                         if (partialResponse && !partialResponse.id) {
                             partialResponse = { ...partialResponse, id: generateMessageId() };
                         }
-                        if (partialResponse && !responseCommitted) {
-                            const queuedParts = locals.get(chatResponsePartsKey);
-                            if (queuedParts && queuedParts.length > 0) {
-                                partialResponse = {
-                                    ...partialResponse,
-                                    parts: [...partialResponse.parts, ...queuedParts],
-                                };
-                                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
@@ -6596,7 +6521,7 @@ function chatAgent(options) {
                         };
                         let erroredNewUIMessages = buildErroredNew();
                         let erroredNewModelMessages = [];
-                        const reconciledSteer = reconcilePendingSteer();
+                        const reconciledSteer = reconcilePendingSteer({ response: partialResponse });
                         const backgroundTailThisTurn = reconcilePendingBackground();
                         if (!responseCommitted) {
                             try {
@@ -6607,14 +6532,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) {
@@ -6626,7 +6544,7 @@ function chatAgent(options) {
                                             backgroundTailThisTurn);
                                         if (!ok) {
                                             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 = [];
                                         }
@@ -6683,7 +6601,7 @@ function chatAgent(options) {
                                         // 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);
+                                        const overrideModelMessages = await toModelMessages(errorTurnOverride, errorTurnOverride);
                                         erroredUIMessagesWithPartial = overrideUIMessages;
                                         accumulatedUIMessages = overrideUIMessages;
                                         accumulatedMessages = overrideModelMessages;
@@ -6776,6 +6694,11 @@ function chatAgent(options) {
                     }
                     finally {
                         turnMsgSub?.off();
+                        locals.set(chatManagedResponseActiveKey, false);
+                        await locals
+                            .get(chatManagedResponseKey)
+                            ?.close()
+                            .catch(() => { });
                     }
                 }
             }
@@ -7745,7 +7668,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) {
@@ -7771,6 +7694,9 @@ async function pipeChatAndCapture(source, options) {
     if (!captured && bufferedChunks.length > 0) {
         captured = await assemblePartialFromChunks(bufferedChunks);
     }
+    captured = (await locals.get(chatManagedResponseKey)?.snapshot()) ?? captured;
+    if (!locals.get(chatTurnContextKey))
+        await locals.get(chatManagedResponseKey)?.close();
     return {
         message: captured,
         status,
@@ -7804,6 +7730,7 @@ class ChatMessageAccumulator {
     _handoverRun;
     _pendingMessages;
     _steeringQueue = [];
+    _pendingSteer = [];
     constructor(options) {
         this._compaction = options?.compaction;
         this._pendingMessages = options?.pendingMessages;
@@ -7876,6 +7803,19 @@ class ChatMessageAccumulator {
         return { isFinal: signal.isFinal, skipped: false };
     }
     async addResponse(response) {
+        const inlineIds = new Set(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: generateMessageId() };
         }
@@ -7952,7 +7892,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.
@@ -7972,7 +7915,7 @@ class ChatMessageAccumulator {
         const comp = this._compaction;
         const pm = this._pendingMessages;
         const queue = this._steeringQueue;
-        return async ({ messages, steps }) => {
+        return retainStepMessages(async ({ messages, steps }) => {
             let resultMessages;
             // 1. Compaction
             if (comp) {
@@ -7985,7 +7928,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) {
@@ -7993,7 +7936,7 @@ class ChatMessageAccumulator {
                 }
             }
             return resultMessages ? { messages: resultMessages } : undefined;
-        };
+        });
     }
     /**
      * Run outer-loop compaction if needed. Call after adding the response
@@ -8305,7 +8248,9 @@ function createChatSession(payload, options) {
                     // Reset stop signal for this turn
                     stop.reset();
                     // Reset per-turn state
-                    locals.set(chatResponsePartsKey, []);
+                    await locals.get(chatManagedResponseKey)?.close();
+                    locals.set(chatManagedResponseKey, undefined);
+                    locals.set(chatManagedResponseActiveKey, true);
                     // Set up steering queue and pending messages config in locals
                     // so toStreamTextOptions() auto-injects prepareStep for steering
                     const turnSteeringQueue = [];
@@ -8450,11 +8395,6 @@ function createChatSession(payload, options) {
                                 if (captured.status === "error") {
                                     if (captured.message) {
                                         const partial = cleanupAbortedParts(captured.message);
-                                        const queuedParts = locals.get(chatResponsePartsKey);
-                                        if (queuedParts && queuedParts.length > 0) {
-                                            partial.parts = [...(partial.parts ?? []), ...queuedParts];
-                                            locals.set(chatResponsePartsKey, []);
-                                        }
                                         await accumulator.addResponse(partial);
                                     }
                                     throw captured.error;
@@ -8470,26 +8410,8 @@ 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.get(chatResponsePartsKey);
-                                if (queuedParts && queuedParts.length > 0) {
-                                    cleaned.parts = [...(cleaned.parts ?? []), ...queuedParts];
-                                    locals.set(chatResponsePartsKey, []);
-                                }
                                 await accumulator.addResponse(cleaned);
                             }
-                            else {
-                                // No response (manual pipe mode) but there are queued data parts
-                                const queuedParts = locals.get(chatResponsePartsKey);
-                                if (queuedParts && queuedParts.length > 0) {
-                                    await accumulator.addResponse({
-                                        id: generateMessageId(),
-                                        role: "assistant",
-                                        parts: queuedParts,
-                                    });
-                                    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
@@ -8580,15 +8502,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.get(chatResponsePartsKey);
-                            if (queuedParts && queuedParts.length > 0) {
-                                response = {
-                                    ...response,
-                                    parts: [...(response.parts ?? []), ...queuedParts],
-                                };
-                                locals.set(chatResponsePartsKey, []);
-                            }
                             await accumulator.addResponse(response);
                         },
                         async done() {
@@ -8600,7 +8513,7 @@ function createChatSession(payload, options) {
                             const hasPending = !!sessionPendingMessages;
                             if (!hasCompaction && !hasPending)
                                 return undefined;
-                            return async ({ messages: stepMsgs, steps, }) => {
+                            return retainStepMessages(async ({ messages: stepMsgs, steps, }) => {
                                 let resultMessages;
                                 if (sessionCompaction) {
                                     const compactResult = await chatCompact(stepMsgs, steps, {
@@ -8619,7 +8532,7 @@ function createChatSession(payload, options) {
                                     }
                                 }
                                 return resultMessages ? { messages: resultMessages } : undefined;
-                            };
+                            });
                         },
                     };
                     return { done: false, value: turnObj };
@@ -8887,6 +8800,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.
@@ -8908,6 +8825,8 @@ function createChatStartSessionAction(taskId, options) {
             ...(options?.triggerConfig?.queue || params.triggerConfig?.queue
                 ? { queue: params.triggerConfig?.queue ?? options?.triggerConfig?.queue }
                 : {}),
+            ...(concurrency !== undefined ? triggerConcurrencyBody(concurrency) : {}),
+            ...(concurrencyKey !== undefined ? { concurrencyKey } : {}),
             tags,
             ...(maxAttempts !== undefined ? { maxAttempts } : {}),
             ...(maxDuration !== undefined ? { maxDuration } : {}),
@@ -9255,6 +9174,10 @@ export const chat = {
  * @internal
  */
 async function writeTurnCompleteChunk(_chatId, publicAccessToken) {
+    locals.set(chatManagedResponseActiveKey, false);
+    const response = 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