@trigger.dev/sdk 4.5.1 → 4.5.2

package/dist/esm/v3/ai.js

@@ -2916,6 +2916,11 @@ function chatAgent(options) {
             // default, `inFlightUsers`). The turn-loop checks this queue ahead of
             // `messagesInput.waitWithIdleTimeout` so recovered turns fire first.
             const bootInjectedQueue = [];
+            // Messages consumed by a turn's `messagesInput.on` handler, dispatched
+            // one per turn by the end-of-turn pickup. Loop-level on purpose:
+            // consuming a record advances the committed `.in` cursor, so entries
+            // dropped with a turn-local buffer are lost permanently.
+            const pendingWireMessages = [];
             const couldHavePriorState = payload.continuation === true || ctx.attempt.number > 1;
             // `.in` resume cursor, computed at most once per boot. The boot
             // block below resolves it (snapshot field or records scan) and the
@@ -3622,6 +3627,9 @@ function chatAgent(options) {
                     } // end else (no boot-injected first turn)
                 }
                 for (let turn = 0; turn < maxTurns; turn++) {
+                    // Declared here so the finally can detach it — a handler leaked past
+                    // its turn duplicates every mid-stream message into the shared buffer.
+                    let turnMsgSub;
                     try {
                         // Extract turn-level context before entering the span. Slim
                         // wire: at most one delta message per record. `headStartMessages`
@@ -3697,8 +3705,6 @@ function chatAgent(options) {
                             const stopSignal = stopController.signal;
                             const cancelSignal = runSignal;
                             const combinedSignal = AbortSignal.any([runSignal, stopController.signal]);
-                            // Buffer messages that arrive during streaming
-                            const pendingMessages = [];
                             const pmConfig = locals.get(chatPendingMessagesKey);
                             const msgSub = messagesInput.on(async (msg) => {
                                 // If pendingMessages is configured, route to the steering queue
@@ -3745,8 +3751,9 @@ function chatAgent(options) {
                                     return; // Don't add to wire buffer — frontend handles non-injected case
                                 }
                                 // No pendingMessages config — standard wire buffer for next turn
-                                pendingMessages.push(msg);
+                                pendingWireMessages.push(msg);
                             });
+                            turnMsgSub = msgSub;
                             // Track new messages for this turn (user input + assistant response).
                             const turnNewModelMessages = [];
                             const turnNewUIMessages = [];
@@ -4801,9 +4808,10 @@ function chatAgent(options) {
                                 return "continue";
                             }
                             // If messages arrived during streaming (without pendingMessages config),
-                            // use the first one immediately as the next turn.
-                            if (pendingMessages.length > 0) {
-                                currentWirePayload = pendingMessages[0];
+                            // dispatch the oldest as the next turn. The rest stay queued
+                            // and drain one per turn.
+                            if (pendingWireMessages.length > 0) {
+                                currentWirePayload = pendingWireMessages.shift();
                                 return "continue";
                             }
                             // chat.requestUpgrade() was called — exit the loop so the
@@ -4889,6 +4897,9 @@ function chatAgent(options) {
                         // Turn error handler: write an error chunk + turn-complete to the stream
                         // so the client sees the error, then wait for the next message instead
                         // of killing the entire run. This keeps the conversation alive.
+                        // Detach the turn's message handler first — left attached it would
+                        // eat the very message the wait below is waiting for.
+                        turnMsgSub?.off();
                         if (turnError instanceof Error &&
                             turnError.name === "AbortError" &&
                             runSignal.aborted) {
@@ -5008,6 +5019,11 @@ function chatAgent(options) {
                             currentWirePayload = bootInjectedQueue.shift();
                             continue;
                         }
+                        // Same for messages buffered during the errored turn — already consumed, idling strands them.
+                        if (pendingWireMessages.length > 0) {
+                            currentWirePayload = pendingWireMessages.shift();
+                            continue;
+                        }
                         // Wait for the next message — same as after a successful turn
                         const effectiveIdleTimeout = metadata.get(IDLE_TIMEOUT_METADATA_KEY) ??
                             idleTimeoutInSeconds;
@@ -5023,6 +5039,9 @@ function chatAgent(options) {
                         currentWirePayload = next.output;
                         // Continue to next iteration of the for loop
                     }
+                    finally {
+                        turnMsgSub?.off();
+                    }
                 }
             }
             finally {
@@ -5933,8 +5952,17 @@ function createChatSession(payload, options) {
             const accumulator = new ChatMessageAccumulator();
             let previousTurnUsage;
             let cumulativeUsage = emptyUsage();
+            // Messages consumed mid-turn, dispatched one per next(). Iterator-level
+            // for the same reason as the agent loop's `pendingWireMessages`:
+            // consumed records never replay, so a turn-local buffer loses them.
+            const sessionPendingWire = [];
+            // The current turn's message subscription — detached defensively at the
+            // top of next() in case user code threw without complete()/done().
+            let activeMsgSub;
             return {
                 async next() {
+                    activeMsgSub?.off();
+                    activeMsgSub = undefined;
                     if (!booted) {
                         booted = true;
                         await seedSessionInResumeCursorForCustomLoop(currentPayload);
@@ -5994,23 +6022,29 @@ function createChatSession(payload, options) {
                             currentPayload = { ...currentPayload, continuation: true };
                         }
                     }
-                    // Subsequent turns: wait for the next message
+                    // Subsequent turns: drain buffered mid-turn messages first (they
+                    // were consumed and won't be re-delivered), then wait.
                     if (turn > 0) {
-                        // chat.requestUpgrade() / chat.endRun() — exit before waiting
-                        if (locals.get(chatUpgradeRequestedKey) || locals.get(chatEndRunRequestedKey)) {
-                            stop.cleanup();
-                            return { done: true, value: undefined };
+                        if (sessionPendingWire.length > 0) {
+                            currentPayload = sessionPendingWire.shift();
                         }
-                        const next = await messagesInput.waitWithIdleTimeout({
-                            idleTimeoutInSeconds,
-                            timeout,
-                            spanName: "waiting for next message",
-                        });
-                        if (!next.ok || runSignal.aborted) {
-                            stop.cleanup();
-                            return { done: true, value: undefined };
+                        else {
+                            // chat.requestUpgrade() / chat.endRun() — exit before waiting
+                            if (locals.get(chatUpgradeRequestedKey) || locals.get(chatEndRunRequestedKey)) {
+                                stop.cleanup();
+                                return { done: true, value: undefined };
+                            }
+                            const next = await messagesInput.waitWithIdleTimeout({
+                                idleTimeoutInSeconds,
+                                timeout,
+                                spanName: "waiting for next message",
+                            });
+                            if (!next.ok || runSignal.aborted) {
+                                stop.cleanup();
+                                return { done: true, value: undefined };
+                            }
+                            currentPayload = next.output;
                         }
-                        currentPayload = next.output;
                     }
                     // Check limits
                     if (turn >= maxTurns || runSignal.aborted) {
@@ -6035,10 +6069,10 @@ function createChatSession(payload, options) {
                         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) {
+                            // Steering route — the frontend re-sends non-injected
+                            // messages on turn complete, so don't also buffer the wire.
                             // Slim wire: at most one delta message per record. Read
                             // `msg.message` directly — no array slicing needed.
                             const lastUIMessage = msg.message;
@@ -6063,8 +6097,11 @@ function createChatSession(payload, options) {
                                     /* non-fatal */
                                 }
                             }
+                            return;
                         }
+                        sessionPendingWire.push(msg);
                     });
+                    activeMsgSub = sessionMsgSub;
                     // Accumulate messages. Slim wire: pass the single delta message as
                     // a 0-or-1-length array. The accumulator's behavior is unchanged —
                     // it still appends user messages and reconverts on regenerate.
@@ -6155,6 +6192,11 @@ function createChatSession(payload, options) {
                                     throw error;
                                 }
                             }
+                            finally {
+                                // Detach at stream end (like the agent loop): the steering queue
+                                // can't inject anymore, so later arrivals must buffer for the next turn.
+                                sessionMsgSub.off();
+                            }
                             if (response) {
                                 const cleaned = stop.signal.aborted && !runSignal.aborted
                                     ? cleanupAbortedParts(response)
@@ -6298,6 +6340,8 @@ function createChatSession(payload, options) {
                     return { done: false, value: turnObj };
                 },
                 async return() {
+                    activeMsgSub?.off();
+                    activeMsgSub = undefined;
                     // `stop` only exists once next() has booted the iterator.
                     stop?.cleanup();
                     return { done: true, value: undefined };