@trigger.dev/sdk 4.5.15 → 4.6.0

package/dist/commonjs/v3/chat.js

@@ -44,6 +44,32 @@ function isAuthError(error) {
     const e = error;
     return e.name === "TriggerApiError" && (e.status === 401 || e.status === 403);
 }
+/**
+ * Detect the closed-session refusal from `.in/append`: HTTP 409 with the
+ * stable `session_closed` code. Terminal — never retried.
+ */
+function isSessionClosedError(error) {
+    if (error === null || typeof error !== "object")
+        return false;
+    const e = error;
+    return e.name === "TriggerApiError" && e.status === 409 && e.code === "session_closed";
+}
+function sessionClosedReasonOf(error) {
+    if (error === null || typeof error !== "object")
+        return undefined;
+    const reason = error.closedReason;
+    return typeof reason === "string" ? reason : undefined;
+}
+/** The local form of the refusal, for sends the transport rejects itself. */
+function sessionClosedError(chatId, reason) {
+    const err = new Error(reason ? `Chat session ${chatId} is closed: ${reason}` : `Chat session ${chatId} is closed`);
+    err.name = "TriggerApiError";
+    err.status = 409;
+    err.code = "session_closed";
+    if (reason)
+        err.closedReason = reason;
+    return err;
+}
 /**
  * Detect a 404 from a session-PAT-authed call — i.e. the session doesn't
  * exist in the current environment. Happens when hydrated session state
@@ -149,6 +175,7 @@ class TriggerChatTransport {
     _onSessionChange;
     _onEvent;
     sessions = new Map();
+    pendingResumeCursors = new Map();
     activeStreams = new Map();
     pendingStarts = new Map();
     // Last turn-producing send per chat — attribution source for the
@@ -188,6 +215,8 @@ class TriggerChatTransport {
                     lastEventId: session.lastEventId,
                     activeInputSeq: session.activeInputSeq,
                     isStreaming: session.isStreaming,
+                    closed: session.closed,
+                    closedReason: session.closedReason,
                 });
             }
         }
@@ -237,6 +266,10 @@ class TriggerChatTransport {
      */
     sendMessages = async (options) => {
         const { trigger, chatId, messageId, messages, abortSignal, body, metadata } = options;
+        const closedState = this.sessions.get(chatId);
+        if (closedState?.closed) {
+            throw sessionClosedError(chatId, closedState.closedReason);
+        }
         if (this.coordinator) {
             if (this.coordinator.isReadOnly(chatId)) {
                 throw new Error("This chat is active in another tab");
@@ -246,6 +279,14 @@ class TriggerChatTransport {
         const mergedMetadata = this.defaultMetadata || metadata
             ? { ...(this.defaultMetadata ?? {}), ...(metadata ?? {}) }
             : undefined;
+        // An action sent through `useChat`. `useChatActions` (or any caller) puts
+        // it in `body.action`; sending it here rather than through
+        // `transport.sendAction` means `useChat` owns the response stream, so an
+        // action that becomes a turn renders the way a message turn does.
+        const actionInBody = body?.action;
+        if (actionInBody !== undefined) {
+            return this.sendAction(chatId, actionInBody, { abortSignal, metadata: mergedMetadata });
+        }
         // First-turn handover routing — when `headStart` is set AND no
         // session state exists yet for this chatId, POST the wire payload
         // to the customer's `chat.handover` route handler. The handler
@@ -308,11 +349,9 @@ class TriggerChatTransport {
             activeStream.abort();
             this.activeStreams.delete(chatId);
         }
-        // A stop that never saw its TURN_COMPLETE leaves the flag set, and the new
-        // turn would be skipped record by record.
-        state.skipToTurnComplete = false;
         state.activeInputSeq = inSeq;
         state.isStreaming = true;
+        state.outstandingTurnAbandoned = false;
         this.notifySessionChange(chatId, state);
         // Owning turn: aborting this live send stops the turn the user drives.
         return this.subscribeToSessionStream(state, abortSignal, chatId, {
@@ -384,6 +423,16 @@ class TriggerChatTransport {
         };
         this.sessions.set(chatId, state);
         this.notifySessionChange(chatId, state);
+        // Step 1 streams from the warm server either way; this says the agent run that owes step 2
+        // is parked on an undeployed external deployment id.
+        if (response.headers.get("X-Trigger-Chat-Pending-Version") === "1") {
+            this.emitEvent({
+                type: "run-pending-version",
+                chatId,
+                timestamp: Date.now(),
+                source: "head-start",
+            });
+        }
         // Filter the parsed UIMessage stream:
         //   - Drop control chunks (`trigger:turn-complete`,
         //     `trigger:session-state`) before they reach AI SDK — they
@@ -550,6 +599,9 @@ class TriggerChatTransport {
         const state = this.sessions.get(options.chatId);
         if (!state)
             return null;
+        // A closed session has no further turns to resume.
+        if (state.closed)
+            return null;
         // Watch is a standing subscription: a settled session is exactly the
         // state it waits in, so a completed last turn must not block the resume.
         if (state.isStreaming === false && !this.watchMode)
@@ -594,7 +646,13 @@ class TriggerChatTransport {
         catch {
             return false;
         }
-        state.skipToTurnComplete = true;
+        // Only gate when a sent turn is still outstanding. A stop at a boundary has
+        // nothing to supersede, and gating it would swallow the next turn.
+        if (!state.outstandingTurnAbandoned &&
+            (state.isStreaming || state.activeInputSeq !== undefined)) {
+            state.skipToTurnComplete = true;
+            state.supersededInputSeq = state.activeInputSeq;
+        }
         const activeStream = this.activeStreams.get(chatId);
         if (activeStream) {
             activeStream.abort();
@@ -613,15 +671,28 @@ class TriggerChatTransport {
         this.notifySessionChange(chatId, state);
         return true;
     };
+    /**
+     * Clear the supersede gate armed by a stop. Call this when the stopped
+     * turn died without ever writing its `trigger:turn-complete` boundary,
+     * otherwise the next turn stays gated forever.
+     */
+    clearSupersedeGate = (chatId) => {
+        const state = this.sessions.get(chatId);
+        if (!state)
+            return;
+        state.skipToTurnComplete = false;
+        state.supersededInputSeq = undefined;
+        state.outstandingTurnAbandoned = true;
+    };
     /**
      * Send a custom action chunk (for `chat.agent`'s `actionSchema` /
-     * `onAction` hook). Actions are not turns — only `hydrateMessages`
-     * and `onAction` fire on the agent side. The returned stream
-     * carries any model response `onAction` produced (when it returns a
-     * `StreamTextResult`); for `void`-returning side-effect-only actions
-     * the stream completes immediately with `trigger:turn-complete`.
+     * `onAction` hook). An action is an edit: only `hydrateMessages` and
+     * `onAction` fire on the agent side, and the returned stream completes
+     * with `trigger:turn-complete` once the edit is persisted. When `onAction`
+     * returns `chat.turn()` the turn's response follows on the same stream.
+     * Per-action `metadata` is merged over the transport's `clientData`.
      */
-    sendAction = async (chatId, action) => {
+    sendAction = async (chatId, action, options) => {
         if (this.coordinator) {
             if (this.coordinator.isReadOnly(chatId)) {
                 throw new Error("This chat is active in another tab");
@@ -633,7 +704,9 @@ class TriggerChatTransport {
             chatId,
             trigger: "action",
             action,
-            metadata: this.defaultMetadata ?? undefined,
+            metadata: this.defaultMetadata || options?.metadata
+                ? { ...(this.defaultMetadata ?? {}), ...(options?.metadata ?? {}) }
+                : undefined,
         };
         const body = this.serializeInputChunk({ kind: "message", payload: wirePayload });
         const partId = crypto.randomUUID();
@@ -648,16 +721,14 @@ class TriggerChatTransport {
             activeStream.abort();
             this.activeStreams.delete(chatId);
         }
-        // A stop that never saw its TURN_COMPLETE leaves the flag set, and the new
-        // turn would be skipped record by record.
-        state.skipToTurnComplete = false;
         // Mark streaming + persist so a reload mid-action resumes (reconnectToStream
         // no-ops when the persisted session says isStreaming: false).
         state.activeInputSeq = inSeq;
         state.isStreaming = true;
+        state.outstandingTurnAbandoned = false;
         this.notifySessionChange(chatId, state);
         // Owning action: aborting this send stops the turn the user drives.
-        return this.subscribeToSessionStream(state, undefined, chatId, {
+        return this.subscribeToSessionStream(state, options?.abortSignal, chatId, {
             sinceInSeq: inSeq,
             sendStopOnAbort: true,
         });
@@ -672,14 +743,42 @@ class TriggerChatTransport {
         return this.toPersisted(state);
     };
     setSession(chatId, session) {
-        this.sessions.set(chatId, {
+        this.sessions.set(chatId, this.applyPendingResumeCursor(chatId, {
             publicAccessToken: session.publicAccessToken,
             lastEventId: session.lastEventId,
             activeInputSeq: session.activeInputSeq,
             isStreaming: session.isStreaming,
-        });
+        }));
         this.notifySessionChange(chatId, this.toPersisted(this.sessions.get(chatId)));
     }
+    /**
+     * Seed the `.out` resume cursor from a loaded transcript. Applied to the
+     * session now if it exists, otherwise held until the session is created so
+     * the first live subscription opens past the persisted history instead of
+     * replaying it. Never moves an existing cursor backward: the transcript load
+     * is async, so a live `.out` record can already have advanced the session
+     * past the snapshot, and overwriting it would replay those records.
+     */
+    seedResumeCursor = (chatId, lastEventId) => {
+        const existing = this.sessions.get(chatId);
+        if (existing?.publicAccessToken) {
+            if (existing.lastEventId === undefined) {
+                existing.lastEventId = lastEventId;
+                this.notifySessionChange(chatId, this.toPersisted(existing));
+            }
+            this.pendingResumeCursors.delete(chatId);
+            return;
+        }
+        this.pendingResumeCursors.set(chatId, lastEventId);
+    };
+    applyPendingResumeCursor(chatId, state) {
+        const pending = this.pendingResumeCursors.get(chatId);
+        if (pending !== undefined && state.lastEventId === undefined) {
+            state.lastEventId = pending;
+        }
+        this.pendingResumeCursors.delete(chatId);
+        return state;
+    }
     setOnSessionChange(callback) {
         this._onSessionChange = callback;
     }
@@ -750,6 +849,22 @@ class TriggerChatTransport {
     setClientData(clientData) {
         this.defaultMetadata = clientData;
     }
+    /**
+     * Update the request-time callbacks. Same reason as `setClientData`:
+     * a host that rebuilds these per render (a dashboard navigating between
+     * projects) would otherwise keep hitting the endpoint captured at
+     * construction. Every read goes through the live field, so the next
+     * request uses the latest callback.
+     */
+    setAccessToken(accessToken) {
+        this.resolveAccessToken = accessToken;
+    }
+    setStartSession(startSession) {
+        this.resolveStartSession = startSession;
+    }
+    setFetch(fetchOverride) {
+        this.fetchOverride = fetchOverride;
+    }
     // -------------------------------------------------------------------------
     // Multi-tab coordination passthrough
     // -------------------------------------------------------------------------
@@ -797,7 +912,42 @@ class TriggerChatTransport {
         lastEventId: state.lastEventId,
         activeInputSeq: state.activeInputSeq,
         isStreaming: state.isStreaming,
+        closed: state.closed,
+        closedReason: state.closedReason,
     });
+    /**
+     * Flip a session to closed and tell listeners once. Terminal: sends and
+     * reconnects stop from here on, and there is no reopening.
+     */
+    markSessionClosed(chatId, state, reason, source) {
+        if (state.closed)
+            return;
+        state.closed = true;
+        if (reason)
+            state.closedReason = reason;
+        state.isStreaming = false;
+        state.activeInputSeq = undefined;
+        state.skipToTurnComplete = false;
+        state.supersededInputSeq = undefined;
+        this.emitEvent({
+            type: "session-closed",
+            chatId,
+            timestamp: Date.now(),
+            ...(reason ? { reason } : {}),
+            source,
+        });
+        this.notifySessionChange(chatId, state);
+        this.coordinator?.release(chatId);
+    }
+    /**
+     * Whether the conversation has been closed — by the agent via
+     * `chat.close()`, or from outside via `sessions.close()`. Closed is
+     * one-way: the transport refuses further sends and reconnects, and the
+     * transcript stays readable.
+     */
+    sessionStatus = (chatId) => this.sessions.get(chatId)?.closed ? "closed" : "open";
+    /** The reason the session was closed, when one was given. */
+    sessionClosedReason = (chatId) => this.sessions.get(chatId)?.closedReason;
     notifySessionChange(chatId, session) {
         if (!this._onSessionChange)
             return;
@@ -832,7 +982,7 @@ class TriggerChatTransport {
         // `sessions: { ... }` already, or the very first `accessToken` call
         // returns a PAT for an out-of-band-created session.
         const token = await this.resolveAccessToken({ chatId });
-        const state = { publicAccessToken: token };
+        const state = this.applyPendingResumeCursor(chatId, { publicAccessToken: token });
         this.sessions.set(chatId, state);
         this.notifySessionChange(chatId, state);
         return state;
@@ -841,15 +991,23 @@ class TriggerChatTransport {
         if (!this.resolveStartSession) {
             throw new Error("TriggerChatTransport: `startSession` is required to call `start()` / `preload()`. Either provide it or pre-hydrate the session via `sessions: { ... }`.");
         }
-        const { publicAccessToken } = await this.resolveStartSession({
+        const { publicAccessToken, pendingVersion } = await this.resolveStartSession({
             taskId: this.taskId,
             chatId,
             clientData: (this.defaultMetadata ?? {}),
         });
-        const state = {
+        if (pendingVersion) {
+            this.emitEvent({
+                type: "run-pending-version",
+                chatId,
+                timestamp: Date.now(),
+                source: "start",
+            });
+        }
+        const state = this.applyPendingResumeCursor(chatId, {
             publicAccessToken,
             isStreaming: false,
-        };
+        });
         this.sessions.set(chatId, state);
         this.notifySessionChange(chatId, state);
         return state;
@@ -862,6 +1020,33 @@ class TriggerChatTransport {
         const raw = this.resolveBaseURLFn(ctx);
         return raw.replace(/\/$/, "");
     }
+    /**
+     * `fetchClient` for an `out` subscription. Reads `this.fetchOverride` on
+     * every call, not once per subscription: a watch-mode subscription
+     * reconnects for the lifetime of the page, and `setFetch` may have swapped
+     * the override in between.
+     */
+    sseFetchClient(ctx) {
+        return ((input, init) => {
+            const override = this.fetchOverride;
+            if (!override)
+                return fetch(input, init);
+            if (typeof input === "string") {
+                return override(input, init ?? {}, ctx);
+            }
+            if (input instanceof URL) {
+                return override(input.toString(), init ?? {}, ctx);
+            }
+            // Request — preserve its url + intrinsic init, let any provided init
+            // override on top (matches fetch(Request, init) semantics).
+            return override(input.url, {
+                method: input.method,
+                headers: input.headers,
+                signal: input.signal,
+                ...(init ?? {}),
+            }, ctx);
+        });
+    }
     async doFetch(ctx, url, init) {
         return this.fetchOverride ? this.fetchOverride(url, init, ctx) : fetch(url, init);
     }
@@ -883,24 +1068,65 @@ class TriggerChatTransport {
             const err = new Error(`appendToSessionStream failed: ${response.status} ${text}`);
             err.name = "TriggerApiError";
             err.status = response.status;
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = undefined;
+            }
+            if (typeof parsed?.code === "string")
+                err.code = parsed.code;
+            if (typeof parsed?.closedReason === "string")
+                err.closedReason = parsed.closedReason;
             throw err;
         }
         // The appended record's `.in` seq, for correlating the response stream to
         // this send. Omitted by older webapps / a lost idempotency claim.
         const data = (await response.json().catch(() => undefined));
+        if (data?.pendingVersion === true) {
+            this.emitEvent({
+                type: "run-pending-version",
+                chatId,
+                timestamp: Date.now(),
+                source: "send",
+            });
+        }
         return typeof data?.seq === "number" ? data.seq : undefined;
     }
     async callWithAuthRetry(chatId, state, op) {
+        if (state.closed) {
+            throw sessionClosedError(chatId, state.closedReason);
+        }
+        // Every attempt goes through here, so a closed-session refusal is terminal
+        // on whichever one hits it. Reaching a 409 from a later attempt and not
+        // marking it would leave local status open on a conversation the server
+        // has already ended.
+        const attempt = async (token) => {
+            try {
+                return await op(token);
+            }
+            catch (err) {
+                if (isSessionClosedError(err)) {
+                    // Terminal. Retrying, refreshing the PAT, or recreating the session
+                    // would all be wrong: the conversation is over.
+                    this.markSessionClosed(chatId, state, sessionClosedReasonOf(err), "append");
+                }
+                throw err;
+            }
+        };
         // 1) Try with the current PAT.
         try {
-            return await op(state.publicAccessToken);
+            return await attempt(state.publicAccessToken);
         }
         catch (err) {
+            if (isSessionClosedError(err))
+                throw err;
             if (isSessionNotFoundError(err)) {
                 // The cached PAT authenticated but the session doesn't exist here —
                 // recreate it and retry.
                 await this.recreateSession(chatId, state);
-                return await op(state.publicAccessToken);
+                return await attempt(state.publicAccessToken);
             }
             if (!isAuthError(err))
                 throw err;
@@ -911,7 +1137,7 @@ class TriggerChatTransport {
         state.publicAccessToken = fresh;
         this.notifySessionChange(chatId, state);
         try {
-            return await op(fresh);
+            return await attempt(fresh);
         }
         catch (err) {
             if (!isSessionNotFoundError(err))
@@ -921,7 +1147,7 @@ class TriggerChatTransport {
         //    state is stale (created in a different environment, or before the
         //    sessions upgrade). Recreate the session and retry once.
         await this.recreateSession(chatId, state);
-        return await op(state.publicAccessToken);
+        return await attempt(state.publicAccessToken);
     }
     /**
      * Repair a stale/phantom hydrated session. The cached state pointed at a
@@ -937,11 +1163,19 @@ class TriggerChatTransport {
         if (!this.resolveStartSession) {
             throw new Error("TriggerChatTransport: session not found and no `startSession` configured to recreate it. The stored session state for this chat may be stale (e.g. created in a different environment) — provide `startSession` or clear the stored session so a fresh one can be created.");
         }
-        const { publicAccessToken } = await this.resolveStartSession({
+        const { publicAccessToken, pendingVersion } = await this.resolveStartSession({
             taskId: this.taskId,
             chatId,
             clientData: (this.defaultMetadata ?? {}),
         });
+        if (pendingVersion) {
+            this.emitEvent({
+                type: "run-pending-version",
+                chatId,
+                timestamp: Date.now(),
+                source: "start",
+            });
+        }
         state.publicAccessToken = publicAccessToken;
         state.lastEventId = undefined;
         state.isStreaming = false;
@@ -965,8 +1199,13 @@ class TriggerChatTransport {
             : internalAbort.signal;
         if (abortSignal) {
             abortSignal.addEventListener("abort", () => {
-                if (options?.sendStopOnAbort !== false) {
+                // A late abort (unmount, or the consumer dropping a drained stream)
+                // has no turn to stop: don't gate the next one, don't write a stop.
+                const outstanding = !state.outstandingTurnAbandoned &&
+                    (state.isStreaming || state.activeInputSeq !== undefined);
+                if (options?.sendStopOnAbort !== false && outstanding && !internalAbort.signal.aborted) {
                     state.skipToTurnComplete = true;
+                    state.supersededInputSeq = state.activeInputSeq;
                     this.appendInputChunk(chatId, state.publicAccessToken, this.serializeInputChunk({ kind: "stop" })).catch(() => { });
                 }
                 internalAbort.abort();
@@ -1026,26 +1265,7 @@ class TriggerChatTransport {
                     })()
                     : () => { };
                 const sseCtx = { endpoint: "out", chatId };
-                const fetchOverride = this.fetchOverride;
-                const sseFetchClient = fetchOverride
-                    ? ((input, init) => {
-                        if (typeof input === "string") {
-                            return fetchOverride(input, init ?? {}, sseCtx);
-                        }
-                        if (input instanceof URL) {
-                            return fetchOverride(input.toString(), init ?? {}, sseCtx);
-                        }
-                        // Request — preserve its url + intrinsic init, let any
-                        // provided init override on top (matches fetch(Request, init)
-                        // semantics).
-                        return fetchOverride(input.url, {
-                            method: input.method,
-                            headers: input.headers,
-                            signal: input.signal,
-                            ...(init ?? {}),
-                        }, sseCtx);
-                    })
-                    : undefined;
+                const sseFetchClient = this.sseFetchClient(sseCtx);
                 let sawFirstChunk = false;
                 let sinceInSeq = options?.sinceInSeq;
                 const connectSseOnce = async (token) => {
@@ -1093,36 +1313,16 @@ class TriggerChatTransport {
                         return await connectSseOnce(fresh);
                     }
                 };
-                // A body that ends without a turn-complete is only terminal when the
-                // server says the session settled — otherwise the turn is still
-                // running and we lost the connection (long-poll window closed, proxy
-                // restarted). Resubscribe from `state.lastEventId`, bounded so a
-                // permanently empty stream can't spin.
-                const MAX_EOF_RESUBSCRIBES = 5;
                 let eofResubscribes = 0;
                 const resumeAfterEof = async () => {
                     // Watch mode is a standing subscription: it outlives turn-complete
                     // (which clears `isStreaming`) and idle windows EOF by design, so the
                     // give-up budget doesn't apply. Only abort or a settled session ends it.
-                    while ((this.watchMode || (state.isStreaming && eofResubscribes < MAX_EOF_RESUBSCRIBES)) &&
+                    while ((this.watchMode || (state.isStreaming && eofResubscribes < ai_shared_js_1.MAX_EOF_RESUBSCRIBES)) &&
                         !currentSubscription?.sessionSettled &&
                         !combinedSignal.aborted) {
                         eofResubscribes++;
-                        // Sleep, but wake immediately on abort — otherwise a stop lands
-                        // mid-backoff and the stream stays open for the rest of it.
-                        await new Promise((resolve) => {
-                            let timer;
-                            const done = () => {
-                                clearTimeout(timer);
-                                combinedSignal.removeEventListener("abort", done);
-                                resolve();
-                            };
-                            // Jitter the backoff so many clients reconnecting after the same
-                            // dropped window don't resubscribe in lockstep.
-                            const backoff = Math.min(100 * 2 ** (eofResubscribes - 1), 5_000);
-                            timer = setTimeout(done, backoff * (0.5 + Math.random() * 0.5));
-                            combinedSignal.addEventListener("abort", done);
-                        });
+                        await (0, ai_shared_js_1.waitBeforeEofResubscribe)(eofResubscribes, combinedSignal);
                         if (combinedSignal.aborted)
                             break;
                         const opened = await openWithAuthRetry();
@@ -1246,11 +1446,41 @@ class TriggerChatTransport {
                                 continue;
                             }
                         }
-                        if (state.skipToTurnComplete) {
-                            if (controlValue === v3_1.TRIGGER_CONTROL_SUBTYPE.TURN_COMPLETE) {
-                                state.skipToTurnComplete = false;
+                        if (state.skipToTurnComplete &&
+                            controlValue !== v3_1.TRIGGER_CONTROL_SUBTYPE.SESSION_CLOSED &&
+                            controlValue !== v3_1.TRIGGER_CONTROL_SUBTYPE.PENDING_VERSION) {
+                            // Fall through on a boundary so the `sinceInSeq` check and the
+                            // turn-completed emit below still run; content records are skipped.
+                            // A close is terminal and a pending version is the gated turn's own
+                            // handover status, so neither is ever gated away.
+                            if (controlValue !== v3_1.TRIGGER_CONTROL_SUBTYPE.TURN_COMPLETE)
+                                continue;
+                            // A boundary older than the superseded turn is not its boundary —
+                            // keep gating. A header-less boundary (legacy wire) still clears.
+                            const gateCursorRaw = (0, v3_1.headerValue)(value.headers, v3_1.SESSION_IN_EVENT_ID_HEADER);
+                            const gateCursor = gateCursorRaw !== undefined ? Number.parseInt(gateCursorRaw, 10) : NaN;
+                            if (state.supersededInputSeq !== undefined &&
+                                !Number.isNaN(gateCursor) &&
+                                gateCursor < state.supersededInputSeq) {
+                                continue;
+                            }
+                            state.skipToTurnComplete = false;
+                            state.supersededInputSeq = undefined;
+                            // This boundary is the new turn's own, so the gate swallowed its
+                            // output: fail the turn instead of completing an empty answer, and
+                            // leave nothing armed for the retry.
+                            if (sinceInSeq !== undefined &&
+                                !Number.isNaN(gateCursor) &&
+                                gateCursor >= sinceInSeq) {
+                                // The lost boundary may also carry the session close.
+                                if ((0, v3_1.headerValue)(value.headers, v3_1.SESSION_CLOSED_HEADER) === "true") {
+                                    this.markSessionClosed(chatId, state, (0, v3_1.headerValue)(value.headers, v3_1.SESSION_CLOSED_REASON_HEADER), "stream");
+                                }
+                                state.activeInputSeq = undefined;
+                                state.isStreaming = false;
+                                this.notifySessionChange(chatId, state);
+                                throw new Error("The previous turn's output was lost. Try again.");
                             }
-                            continue;
                         }
                         if (controlValue === v3_1.TRIGGER_CONTROL_SUBTYPE.UPGRADE_REQUIRED) {
                             // Server has already triggered the new run via
@@ -1259,6 +1489,26 @@ class TriggerChatTransport {
                             // and keep reading.
                             continue;
                         }
+                        if (controlValue === v3_1.TRIGGER_CONTROL_SUBTYPE.SESSION_CLOSED) {
+                            this.markSessionClosed(chatId, state, (0, v3_1.headerValue)(value.headers, v3_1.SESSION_CLOSED_REASON_HEADER), "stream");
+                            internalAbort.abort();
+                            try {
+                                controller.close();
+                            }
+                            catch {
+                                /* already closed */
+                            }
+                            return;
+                        }
+                        if (controlValue === v3_1.TRIGGER_CONTROL_SUBTYPE.PENDING_VERSION) {
+                            this.emitEvent({
+                                type: "run-pending-version",
+                                chatId,
+                                timestamp: Date.now(),
+                                source: "upgrade",
+                            });
+                            continue;
+                        }
                         if (controlValue === v3_1.TRIGGER_CONTROL_SUBTYPE.TURN_COMPLETE) {
                             // Skip a turn-complete from an earlier turn (committed `.in` cursor
                             // below this send's seq), e.g. an undo action that raced this send.
@@ -1269,6 +1519,11 @@ class TriggerChatTransport {
                                     continue;
                                 }
                             }
+                            // A close decided during this turn rides out on turn-complete —
+                            // the last record a reader sees before it ends the stream.
+                            if ((0, v3_1.headerValue)(value.headers, v3_1.SESSION_CLOSED_HEADER) === "true") {
+                                this.markSessionClosed(chatId, state, (0, v3_1.headerValue)(value.headers, v3_1.SESSION_CLOSED_REASON_HEADER), "stream");
+                            }
                             const refreshedToken = (0, v3_1.headerValue)(value.headers, v3_1.PUBLIC_ACCESS_TOKEN_HEADER) ??
                                 legacyChunk?.publicAccessToken;
                             if (refreshedToken) {