@trigger.dev/sdk 0.0.0-prerelease-20260324161542 → 0.0.0-prerelease-20260325143642

package/dist/commonjs/v3/ai.d.ts

@@ -279,6 +279,84 @@ export type ChatTaskCompactionOptions = {
      */
     compactModelMessages?: (event: CompactMessagesEvent) => ModelMessage[] | Promise<ModelMessage[]>;
 };
+/**
+ * Event passed to `shouldInject` and `prepareMessages` callbacks.
+ */
+export type PendingMessagesBatchEvent = {
+    /** All pending UI messages that arrived during streaming (batch). */
+    messages: UIMessage[];
+    /** Current model messages in the conversation. */
+    modelMessages: ModelMessage[];
+    /** Completed steps so far. */
+    steps: CompactionStep[];
+    /** Current step number (0-indexed). */
+    stepNumber: number;
+    /** Chat session ID. */
+    chatId: string;
+    /** Current turn number (0-indexed). */
+    turn: number;
+    /** Custom data from the frontend. */
+    clientData?: unknown;
+};
+/**
+ * Event passed to `onReceived` callback (per-message, as they arrive).
+ */
+export type PendingMessageReceivedEvent = {
+    /** The UI message that arrived during streaming. */
+    message: UIMessage;
+    /** Chat session ID. */
+    chatId: string;
+    /** Current turn number (0-indexed). */
+    turn: number;
+};
+/**
+ * Event passed to `onInjected` callback (batch, after injection).
+ */
+export type PendingMessagesInjectedEvent = {
+    /** All UI messages that were injected. */
+    messages: UIMessage[];
+    /** The model messages that were injected. */
+    injectedModelMessages: ModelMessage[];
+    /** Chat session ID. */
+    chatId: string;
+    /** Current turn number (0-indexed). */
+    turn: number;
+    /** Step number where injection occurred. */
+    stepNumber: number;
+};
+/**
+ * Options for the `pendingMessages` field on `chat.task()`, `chat.createSession()`,
+ * or `ChatMessageAccumulator`.
+ *
+ * Configures how messages that arrive during streaming are handled. When
+ * `shouldInject` is provided and returns `true`, the full batch of pending
+ * messages is injected between tool-call steps via `prepareStep`.
+ * Otherwise, messages queue for the next turn.
+ */
+export type PendingMessagesOptions = {
+    /**
+     * Decide whether to inject pending messages between tool-call steps.
+     * Called once per step boundary with the full batch of pending messages.
+     * If absent, no injection happens — messages only queue for the next turn.
+     */
+    shouldInject?: (event: PendingMessagesBatchEvent) => boolean | Promise<boolean>;
+    /**
+     * Transform the batch of pending messages before injection.
+     * Return the model messages to inject.
+     * Default: convert each UI message via `convertToModelMessages`.
+     */
+    prepare?: (event: PendingMessagesBatchEvent) => ModelMessage[] | Promise<ModelMessage[]>;
+    /** Called when a message arrives during streaming (per-message). */
+    onReceived?: (event: PendingMessageReceivedEvent) => void | Promise<void>;
+    /** Called after a batch of messages is injected via `prepareStep`. */
+    onInjected?: (event: PendingMessagesInjectedEvent) => void | Promise<void>;
+};
+/**
+ * The data part type used to signal that pending messages were injected
+ * between tool-call steps. The frontend can match on this to render
+ * injection points inline in the assistant response.
+ */
+export declare const PENDING_MESSAGE_INJECTED_TYPE: "data-pending-message-injected";
 /**
  * Event passed to the `prepareMessages` hook.
  */
@@ -888,7 +966,22 @@ export type ChatTaskOptions<TIdentifier extends string, TClientDataSchema extend
      */
     compaction?: ChatTaskCompactionOptions;
     /**
-     * Called after the stream closes for this turn. Use this to persist the
+     * Configure how messages that arrive during streaming are handled.
+     *
+     * By default, messages queue for the next turn. When `shouldInject` is provided
+     * and returns `true`, messages are injected between tool-call steps via
+     * `prepareStep` — allowing users to steer the agent mid-execution.
+     *
+     * @example
+     * ```ts
+     * pendingMessages: {
+     *   shouldInject: ({ steps }) => steps.length > 0,
+     *   onReceived: ({ message }) => logger.info("Steering message received"),
+     * },
+     * ```
+     */
+    pendingMessages?: PendingMessagesOptions;
+    /**
      * conversation to your database after each assistant response.
      *
      * @example
@@ -1249,8 +1342,11 @@ declare class ChatMessageAccumulator {
     modelMessages: ModelMessage[];
     uiMessages: UIMessage[];
     private _compaction?;
+    private _pendingMessages?;
+    private _steeringQueue;
     constructor(options?: {
         compaction?: ChatTaskCompactionOptions;
+        pendingMessages?: PendingMessagesOptions;
     });
     /**
      * Add incoming messages from the transport payload.
@@ -1268,9 +1364,21 @@ declare class ChatMessageAccumulator {
     setMessages(uiMessages: UIMessage[]): Promise<void>;
     addResponse(response: UIMessage): Promise<void>;
     /**
-     * Returns a `prepareStep` function for inner-loop compaction.
-     * Only available when `compaction` was provided to the constructor.
-     * Pass the result to `streamText({ prepareStep: conversation.prepareStep() })`.
+     * Queue a message for injection via `prepareStep`. Call from a
+     * `messagesInput.on()` listener when a message arrives during streaming.
+     */
+    steer(message: UIMessage, modelMessages?: ModelMessage[]): void;
+    /**
+     * Queue a message for injection, converting to model messages automatically.
+     */
+    steerAsync(message: UIMessage): Promise<void>;
+    /**
+     * Get and clear unconsumed steering messages.
+     */
+    drainSteering(): UIMessage[];
+    /**
+     * Returns a `prepareStep` function that handles both compaction and
+     * pending message injection. Pass to `streamText({ prepareStep: conversation.prepareStep() })`.
      */
     prepareStep(): ((args: {
         messages: ModelMessage[];
@@ -1303,6 +1411,8 @@ export type ChatSessionOptions = {
     maxTurns?: number;
     /** Automatic context compaction — same options as `chat.task({ compaction })`. */
     compaction?: ChatTaskCompactionOptions;
+    /** Configure mid-execution message injection — same options as `chat.task({ pendingMessages })`. */
+    pendingMessages?: PendingMessagesOptions;
 };
 export type ChatTurn = {
     /** Turn number (0-indexed). */
@@ -1348,6 +1458,17 @@ export type ChatTurn = {
      * Use with `chat.pipeAndCapture` when you need control between pipe and done.
      */
     addResponse(response: UIMessage): Promise<void>;
+    /**
+     * Returns a `prepareStep` function that handles both compaction and
+     * pending message injection. Pass to `streamText({ prepareStep: turn.prepareStep() })`.
+     * Only needed when not using `chat.toStreamTextOptions()` (which auto-injects it).
+     */
+    prepareStep(): ((args: {
+        messages: ModelMessage[];
+        steps: CompactionStep[];
+    }) => Promise<{
+        messages: ModelMessage[];
+    } | undefined>) | undefined;
 };
 /**
  * Create a chat session that yields turns as an async iterator.

package/dist/commonjs/v3/ai.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.chat = exports.CHAT_STOP_STREAM_ID = exports.CHAT_MESSAGES_STREAM_ID = exports.CHAT_STREAM_KEY = exports.ai = void 0;
+exports.chat = exports.PENDING_MESSAGE_INJECTED_TYPE = exports.CHAT_STOP_STREAM_ID = exports.CHAT_MESSAGES_STREAM_ID = exports.CHAT_STREAM_KEY = exports.ai = void 0;
 const v3_1 = require("@trigger.dev/core/v3");
 const ai_1 = require("ai");
 const api_1 = require("@opentelemetry/api");
@@ -281,6 +281,18 @@ const chatOnCompactedKey = locals_js_1.locals.create("chat.onCompacted");
 const chatPrepareMessagesKey = locals_js_1.locals.create("chat.prepareMessages");
 /** @internal */
 const chatTaskCompactionKey = locals_js_1.locals.create("chat.taskCompaction");
+/**
+ * The data part type used to signal that pending messages were injected
+ * between tool-call steps. The frontend can match on this to render
+ * injection points inline in the assistant response.
+ */
+exports.PENDING_MESSAGE_INJECTED_TYPE = "data-pending-message-injected";
+/** @internal */
+const chatPendingMessagesKey = locals_js_1.locals.create("chat.pendingMessages");
+/** @internal */
+const chatSteeringQueueKey = locals_js_1.locals.create("chat.steeringQueue");
+/** @internal — IDs of messages that were successfully injected via prepareStep */
+const chatInjectedMessageIdsKey = locals_js_1.locals.create("chat.injectedMessageIds");
 /**
  * Check that no tool calls are in-flight in a step's content.
  * Used before compaction to avoid losing tool state mid-execution.
@@ -514,6 +526,111 @@ function chatCompactionStep(options) {
     };
 }
 // ---------------------------------------------------------------------------
+// Steering queue drain — shared by toStreamTextOptions, session, accumulator
+// ---------------------------------------------------------------------------
+/**
+ * Drain the steering queue as a batch. Calls `shouldInject` once with all
+ * pending messages. If it returns true, calls `prepareMessages` once to
+ * transform the batch, then clears the queue.
+ * Returns the model messages to inject (empty if none).
+ * @internal
+ */
+async function drainSteeringQueue(config, messages, steps, queueOverride) {
+    const queue = queueOverride ?? locals_js_1.locals.get(chatSteeringQueueKey);
+    if (!queue || queue.length === 0)
+        return [];
+    const ctx = locals_js_1.locals.get(chatTurnContextKey);
+    const stepNumber = steps.length - 1;
+    const uiMessages = queue.map((e) => e.uiMessage);
+    const batchEvent = {
+        messages: uiMessages,
+        modelMessages: messages,
+        steps,
+        stepNumber,
+        chatId: ctx?.chatId ?? "",
+        turn: ctx?.turn ?? 0,
+        clientData: ctx?.clientData,
+    };
+    // Call shouldInject once for the whole batch
+    const shouldInject = config.shouldInject
+        ? await config.shouldInject(batchEvent)
+        : false;
+    if (!shouldInject)
+        return [];
+    // Extract message texts for span attributes
+    const messageTexts = uiMessages.map((m) => (m.parts ?? []).filter((p) => p.type === "text").map((p) => p.text).join("") || "");
+    const previewText = messageTexts.length === 1
+        ? messageTexts[0].slice(0, 80)
+        : `${queue.length} messages`;
+    return tracer_js_1.tracer.startActiveSpan("pending message injected", async () => {
+        // Transform the batch — default: concatenate all pre-converted model messages
+        const injected = config.prepare
+            ? await config.prepare(batchEvent)
+            : queue.flatMap((e) => e.modelMessages);
+        // Clear the queue and record injected IDs
+        queue.length = 0;
+        const injectedIds = locals_js_1.locals.get(chatInjectedMessageIdsKey);
+        if (injectedIds) {
+            for (const m of uiMessages)
+                injectedIds.add(m.id);
+        }
+        // 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 } = streams_js_1.streams.writer(exports.CHAT_STREAM_KEY, {
+                    collapsed: true,
+                    execute: ({ write }) => {
+                        write({
+                            type: exports.PENDING_MESSAGE_INJECTED_TYPE,
+                            id: (0, ai_1.generateId)(),
+                            data: {
+                                messageIds: uiMessages.map((m) => m.id),
+                                messages: uiMessages.map((m, idx) => ({
+                                    id: m.id,
+                                    text: messageTexts[idx] ?? "",
+                                })),
+                            },
+                        });
+                    },
+                });
+                await waitUntilComplete();
+            }
+            catch { /* non-fatal — stream write failed */ }
+        }
+        // Fire onInjected callback
+        if (config.onInjected && injected.length > 0) {
+            try {
+                await config.onInjected({
+                    messages: uiMessages,
+                    injectedModelMessages: injected,
+                    chatId: ctx?.chatId ?? "",
+                    turn: ctx?.turn ?? 0,
+                    stepNumber,
+                });
+            }
+            catch { /* non-fatal */ }
+        }
+        return injected;
+    }, {
+        attributes: {
+            [v3_1.SemanticInternalAttributes.STYLE_ICON]: "tabler-message-forward",
+            "pending.message_count": uiMessages.length,
+            "pending.step_number": stepNumber,
+            "pending.messages": messageTexts,
+            ...(ctx?.chatId ? { "pending.chat_id": ctx.chatId } : {}),
+            ...(ctx?.turn != null ? { "pending.turn": ctx.turn } : {}),
+            ...(0, v3_1.accessoryAttributes)({
+                items: [
+                    { text: `${uiMessages.length} message${uiMessages.length === 1 ? "" : "s"}`, variant: "normal" },
+                    { text: `between steps ${stepNumber} and ${stepNumber + 1}`, variant: "normal" },
+                ],
+                style: "codepath",
+            }),
+        },
+    });
+}
+// ---------------------------------------------------------------------------
 // chat.isCompactionSafe — check if it's safe to compact messages
 // ---------------------------------------------------------------------------
 /**
@@ -600,29 +717,42 @@ function toStreamTextOptions(options) {
     // Add telemetry (forward additional metadata from caller)
     const telemetry = prompt.toAISDKTelemetry(options?.telemetry);
     Object.assign(result, telemetry);
-    // Auto-inject prepareStep when task-level compaction is configured.
-    // We build a custom prepareStep instead of using chatCompactionStep so we
-    // can pass the enriched SummarizeEvent to taskCompaction.summarize.
+    // Auto-inject prepareStep when compaction or pendingMessages is configured.
     const taskCompaction = locals_js_1.locals.get(chatTaskCompactionKey);
-    if (taskCompaction) {
+    const taskPendingMessages = locals_js_1.locals.get(chatPendingMessagesKey);
+    if (taskCompaction || taskPendingMessages) {
         result.prepareStep = async ({ messages, steps }) => {
-            const compactResult = await chatCompact(messages, steps, {
-                shouldCompact: taskCompaction.shouldCompact,
-                summarize: (msgs) => {
-                    const ctx = locals_js_1.locals.get(chatTurnContextKey);
-                    const lastStep = steps.at(-1);
-                    return taskCompaction.summarize({
-                        messages: msgs,
-                        usage: lastStep?.usage,
-                        source: "inner",
-                        stepNumber: steps.length - 1,
-                        chatId: ctx?.chatId,
-                        turn: ctx?.turn,
-                        clientData: ctx?.clientData,
-                    });
-                },
-            });
-            return compactResult.type === "skipped" ? undefined : compactResult;
+            let resultMessages;
+            // 1. Compaction
+            if (taskCompaction) {
+                const compactResult = await chatCompact(messages, steps, {
+                    shouldCompact: taskCompaction.shouldCompact,
+                    summarize: (msgs) => {
+                        const ctx = locals_js_1.locals.get(chatTurnContextKey);
+                        const lastStep = steps.at(-1);
+                        return taskCompaction.summarize({
+                            messages: msgs,
+                            usage: lastStep?.usage,
+                            source: "inner",
+                            stepNumber: steps.length - 1,
+                            chatId: ctx?.chatId,
+                            turn: ctx?.turn,
+                            clientData: ctx?.clientData,
+                        });
+                    },
+                });
+                if (compactResult.type !== "skipped") {
+                    resultMessages = compactResult.messages;
+                }
+            }
+            // 2. Pending message injection (steering)
+            if (taskPendingMessages) {
+                const injected = await drainSteeringQueue(taskPendingMessages, resultMessages ?? messages, steps);
+                if (injected.length > 0) {
+                    resultMessages = [...(resultMessages ?? messages), ...injected];
+                }
+            }
+            return resultMessages ? { messages: resultMessages } : undefined;
         };
     }
     return result;
@@ -733,7 +863,7 @@ async function pipeChat(source, options) {
  * ```
  */
 function chatTask(options) {
-    const { run: userRun, clientDataSchema, onPreload, onChatStart, onTurnStart, onBeforeTurnComplete, onCompacted, compaction, prepareMessages, onTurnComplete, maxTurns = 100, turnTimeout = "1h", idleTimeoutInSeconds = 30, chatAccessTokenTTL = "1h", preloadIdleTimeoutInSeconds, preloadTimeout, uiMessageStreamOptions, ...restOptions } = options;
+    const { run: userRun, clientDataSchema, onPreload, onChatStart, onTurnStart, onBeforeTurnComplete, onCompacted, compaction, pendingMessages: pendingMessagesConfig, prepareMessages, onTurnComplete, maxTurns = 100, turnTimeout = "1h", idleTimeoutInSeconds = 30, chatAccessTokenTTL = "1h", preloadIdleTimeoutInSeconds, preloadTimeout, uiMessageStreamOptions, ...restOptions } = options;
     const parseClientData = clientDataSchema
         ? (0, v3_1.getSchemaParseFn)(clientDataSchema)
         : undefined;
@@ -759,6 +889,9 @@ function chatTask(options) {
             if (compaction) {
                 locals_js_1.locals.set(chatTaskCompactionKey, compaction);
             }
+            if (pendingMessagesConfig) {
+                locals_js_1.locals.set(chatPendingMessagesKey, pendingMessagesConfig);
+            }
             let currentWirePayload = payload;
             const continuation = payload.continuation ?? false;
             const previousRunId = payload.previousRunId;
@@ -876,6 +1009,8 @@ function chatTask(options) {
                         locals_js_1.locals.set(chatPipeCountKey, 0);
                         locals_js_1.locals.set(chatDeferKey, new Set());
                         locals_js_1.locals.set(chatCompactionStateKey, undefined);
+                        locals_js_1.locals.set(chatSteeringQueueKey, []);
+                        locals_js_1.locals.set(chatInjectedMessageIdsKey, new Set());
                         // Store chat context for auto-detection by ai.tool subtasks
                         locals_js_1.locals.set(chatTurnContextKey, {
                             chatId: currentWirePayload.chatId,
@@ -893,7 +1028,39 @@ function chatTask(options) {
                         const combinedSignal = AbortSignal.any([runSignal, stopController.signal]);
                         // Buffer messages that arrive during streaming
                         const pendingMessages = [];
-                        const msgSub = messagesInput.on((msg) => {
+                        const pmConfig = locals_js_1.locals.get(chatPendingMessagesKey);
+                        const msgSub = messagesInput.on(async (msg) => {
+                            // If pendingMessages is configured, route to the steering queue
+                            // instead of the wire buffer. The frontend handles re-sending
+                            // non-injected messages via sendMessage on turn complete.
+                            if (pmConfig) {
+                                const lastUIMessage = msg.messages?.[msg.messages.length - 1];
+                                if (lastUIMessage) {
+                                    if (pmConfig.onReceived) {
+                                        try {
+                                            await pmConfig.onReceived({
+                                                message: lastUIMessage,
+                                                chatId: currentWirePayload.chatId,
+                                                turn,
+                                            });
+                                        }
+                                        catch { /* non-fatal */ }
+                                    }
+                                    try {
+                                        const queue = locals_js_1.locals.get(chatSteeringQueueKey) ?? [];
+                                        // Deduplicate by message ID — guards against double-sends
+                                        if (lastUIMessage.id && queue.some((e) => e.uiMessage.id === lastUIMessage.id)) {
+                                            return;
+                                        }
+                                        const modelMsgs = await toModelMessages([lastUIMessage]);
+                                        queue.push({ uiMessage: lastUIMessage, modelMessages: modelMsgs });
+                                        locals_js_1.locals.set(chatSteeringQueueKey, queue);
+                                    }
+                                    catch { /* conversion failed — skip steering queue */ }
+                                }
+                                return; // Don't add to wire buffer — frontend handles non-injected case
+                            }
+                            // No pendingMessages config — standard wire buffer for next turn
                             pendingMessages.push(msg);
                         });
                         // Clean up any incomplete tool parts in the incoming history.
@@ -1373,7 +1540,8 @@ function chatTask(options) {
                                 },
                             });
                         }
-                        // If messages arrived during streaming, use the first one immediately
+                        // If messages arrived during streaming (without pendingMessages config),
+                        // use the first one immediately as the next turn.
                         if (pendingMessages.length > 0) {
                             currentWirePayload = pendingMessages[0];
                             return "continue";
@@ -1742,8 +1910,11 @@ class ChatMessageAccumulator {
     modelMessages = [];
     uiMessages = [];
     _compaction;
+    _pendingMessages;
+    _steeringQueue = [];
     constructor(options) {
         this._compaction = options?.compaction;
+        this._pendingMessages = options?.pendingMessages;
     }
     /**
      * Add incoming messages from the transport payload.
@@ -1788,20 +1959,63 @@ class ChatMessageAccumulator {
         }
     }
     /**
-     * Returns a `prepareStep` function for inner-loop compaction.
-     * Only available when `compaction` was provided to the constructor.
-     * Pass the result to `streamText({ prepareStep: conversation.prepareStep() })`.
+     * Queue a message for injection via `prepareStep`. Call from a
+     * `messagesInput.on()` listener when a message arrives during streaming.
+     */
+    steer(message, modelMessages) {
+        if (modelMessages) {
+            this._steeringQueue.push({ uiMessage: message, modelMessages });
+        }
+        else {
+            // Defer conversion — will be done in prepareStep if needed
+            this._steeringQueue.push({ uiMessage: message, modelMessages: [] });
+        }
+    }
+    /**
+     * Queue a message for injection, converting to model messages automatically.
+     */
+    async steerAsync(message) {
+        const modelMsgs = await toModelMessages([message]);
+        this._steeringQueue.push({ uiMessage: message, modelMessages: modelMsgs });
+    }
+    /**
+     * Get and clear unconsumed steering messages.
+     */
+    drainSteering() {
+        const result = this._steeringQueue.map((e) => e.uiMessage);
+        this._steeringQueue = [];
+        return result;
+    }
+    /**
+     * Returns a `prepareStep` function that handles both compaction and
+     * pending message injection. Pass to `streamText({ prepareStep: conversation.prepareStep() })`.
      */
     prepareStep() {
-        if (!this._compaction)
+        if (!this._compaction && !this._pendingMessages)
             return undefined;
         const comp = this._compaction;
+        const pm = this._pendingMessages;
+        const queue = this._steeringQueue;
         return async ({ messages, steps }) => {
-            const result = await chatCompact(messages, steps, {
-                shouldCompact: comp.shouldCompact,
-                summarize: (msgs) => comp.summarize({ messages: msgs, source: "inner" }),
-            });
-            return result.type === "skipped" ? undefined : result;
+            let resultMessages;
+            // 1. Compaction
+            if (comp) {
+                const result = await chatCompact(messages, steps, {
+                    shouldCompact: comp.shouldCompact,
+                    summarize: (msgs) => comp.summarize({ messages: msgs, source: "inner" }),
+                });
+                if (result.type !== "skipped") {
+                    resultMessages = result.messages;
+                }
+            }
+            // 2. Pending message injection
+            if (pm && queue.length > 0) {
+                const injected = await drainSteeringQueue(pm, resultMessages ?? messages, steps, queue);
+                if (injected.length > 0) {
+                    resultMessages = [...(resultMessages ?? messages), ...injected];
+                }
+            }
+            return resultMessages ? { messages: resultMessages } : undefined;
         };
     }
     /**
@@ -1887,7 +2101,7 @@ class ChatMessageAccumulator {
  * ```
  */
 function createChatSession(payload, options) {
-    const { signal: runSignal, idleTimeoutInSeconds = 30, timeout = "1h", maxTurns = 100, compaction: sessionCompaction, } = options;
+    const { signal: runSignal, idleTimeoutInSeconds = 30, timeout = "1h", maxTurns = 100, compaction: sessionCompaction, pendingMessages: sessionPendingMessages, } = options;
     return {
         [Symbol.asyncIterator]() {
             let currentPayload = payload;
@@ -1932,6 +2146,44 @@ function createChatSession(payload, options) {
                     }
                     // Reset stop signal for this turn
                     stop.reset();
+                    // Set up steering queue and pending messages config in locals
+                    // so toStreamTextOptions() auto-injects prepareStep for steering
+                    const turnSteeringQueue = [];
+                    locals_js_1.locals.set(chatSteeringQueueKey, turnSteeringQueue);
+                    if (sessionPendingMessages) {
+                        locals_js_1.locals.set(chatPendingMessagesKey, sessionPendingMessages);
+                    }
+                    locals_js_1.locals.set(chatTurnContextKey, {
+                        chatId: currentPayload.chatId,
+                        turn,
+                        continuation: currentPayload.continuation ?? false,
+                        clientData: currentPayload.metadata,
+                    });
+                    // Listen for messages during streaming (steering + next-turn buffer)
+                    const sessionPendingWire = [];
+                    const sessionMsgSub = messagesInput.on(async (msg) => {
+                        sessionPendingWire.push(msg);
+                        if (sessionPendingMessages) {
+                            const lastUIMessage = msg.messages?.[msg.messages.length - 1];
+                            if (lastUIMessage) {
+                                if (sessionPendingMessages.onReceived) {
+                                    try {
+                                        await sessionPendingMessages.onReceived({
+                                            message: lastUIMessage,
+                                            chatId: currentPayload.chatId,
+                                            turn,
+                                        });
+                                    }
+                                    catch { /* non-fatal */ }
+                                }
+                                try {
+                                    const modelMsgs = await toModelMessages([lastUIMessage]);
+                                    turnSteeringQueue.push({ uiMessage: lastUIMessage, modelMessages: modelMsgs });
+                                }
+                                catch { /* non-fatal */ }
+                            }
+                        }
+                    });
                     // Accumulate messages
                     const messages = await accumulator.addIncoming(currentPayload.messages, currentPayload.trigger, turn);
                     const combinedSignal = AbortSignal.any([runSignal, stop.signal]);
@@ -1959,6 +2211,7 @@ function createChatSession(payload, options) {
                                 if (error instanceof Error && error.name === "AbortError") {
                                     if (runSignal.aborted) {
                                         // Full cancel — don't accumulate
+                                        sessionMsgSub.off();
                                         await chatWriteTurnComplete();
                                         return undefined;
                                     }
@@ -2026,6 +2279,7 @@ function createChatSession(payload, options) {
                                     }
                                 }
                             }
+                            sessionMsgSub.off();
                             await chatWriteTurnComplete();
                             return response;
                         },
@@ -2033,8 +2287,34 @@ function createChatSession(payload, options) {
                             await accumulator.addResponse(response);
                         },
                         async done() {
+                            sessionMsgSub.off();
                             await chatWriteTurnComplete();
                         },
+                        prepareStep() {
+                            const hasCompaction = !!sessionCompaction;
+                            const hasPending = !!sessionPendingMessages;
+                            if (!hasCompaction && !hasPending)
+                                return undefined;
+                            return async ({ messages: stepMsgs, steps }) => {
+                                let resultMessages;
+                                if (sessionCompaction) {
+                                    const compactResult = await chatCompact(stepMsgs, steps, {
+                                        shouldCompact: sessionCompaction.shouldCompact,
+                                        summarize: (msgs) => sessionCompaction.summarize({ messages: msgs, source: "inner" }),
+                                    });
+                                    if (compactResult.type !== "skipped") {
+                                        resultMessages = compactResult.messages;
+                                    }
+                                }
+                                if (sessionPendingMessages) {
+                                    const injected = await drainSteeringQueue(sessionPendingMessages, resultMessages ?? stepMsgs, steps, turnSteeringQueue);
+                                    if (injected.length > 0) {
+                                        resultMessages = [...(resultMessages ?? stepMsgs), ...injected];
+                                    }
+                                }
+                                return resultMessages ? { messages: resultMessages } : undefined;
+                            };
+                        },
                     };
                     return { done: false, value: turnObj };
                 },