@trigger.dev/sdk 0.0.0-prerelease-20260909071038 → 0.0.0-prerelease-streamfix-20260909094302

package/dist/commonjs/v3/chat.js

@@ -44,32 +44,6 @@ 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
@@ -175,7 +149,6 @@ 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
@@ -215,8 +188,6 @@ class TriggerChatTransport {
                     lastEventId: session.lastEventId,
                     activeInputSeq: session.activeInputSeq,
                     isStreaming: session.isStreaming,
-                    closed: session.closed,
-                    closedReason: session.closedReason,
                 });
             }
         }
@@ -266,10 +237,6 @@ 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");
@@ -279,14 +246,6 @@ 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
@@ -349,9 +308,11 @@ 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, {
@@ -423,16 +384,6 @@ 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
@@ -599,9 +550,6 @@ 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)
@@ -646,13 +594,7 @@ class TriggerChatTransport {
         catch {
             return false;
         }
-        // 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;
-        }
+        state.skipToTurnComplete = true;
         const activeStream = this.activeStreams.get(chatId);
         if (activeStream) {
             activeStream.abort();
@@ -671,28 +613,15 @@ 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). 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`.
+     * `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`.
      */
-    sendAction = async (chatId, action, options) => {
+    sendAction = async (chatId, action) => {
         if (this.coordinator) {
             if (this.coordinator.isReadOnly(chatId)) {
                 throw new Error("This chat is active in another tab");
@@ -704,9 +633,7 @@ class TriggerChatTransport {
             chatId,
             trigger: "action",
             action,
-            metadata: this.defaultMetadata || options?.metadata
-                ? { ...(this.defaultMetadata ?? {}), ...(options?.metadata ?? {}) }
-                : undefined,
+            metadata: this.defaultMetadata ?? undefined,
         };
         const body = this.serializeInputChunk({ kind: "message", payload: wirePayload });
         const partId = crypto.randomUUID();
@@ -721,14 +648,16 @@ 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, options?.abortSignal, chatId, {
+        return this.subscribeToSessionStream(state, undefined, chatId, {
             sinceInSeq: inSeq,
             sendStopOnAbort: true,
         });
@@ -743,42 +672,14 @@ class TriggerChatTransport {
         return this.toPersisted(state);
     };
     setSession(chatId, session) {
-        this.sessions.set(chatId, this.applyPendingResumeCursor(chatId, {
+        this.sessions.set(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;
     }
@@ -849,22 +750,6 @@ 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
     // -------------------------------------------------------------------------
@@ -912,42 +797,7 @@ 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;
@@ -982,7 +832,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 = this.applyPendingResumeCursor(chatId, { publicAccessToken: token });
+        const state = { publicAccessToken: token };
         this.sessions.set(chatId, state);
         this.notifySessionChange(chatId, state);
         return state;
@@ -991,23 +841,15 @@ 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, pendingVersion } = await this.resolveStartSession({
+        const { publicAccessToken } = await this.resolveStartSession({
             taskId: this.taskId,
             chatId,
             clientData: (this.defaultMetadata ?? {}),
         });
-        if (pendingVersion) {
-            this.emitEvent({
-                type: "run-pending-version",
-                chatId,
-                timestamp: Date.now(),
-                source: "start",
-            });
-        }
-        const state = this.applyPendingResumeCursor(chatId, {
+        const state = {
             publicAccessToken,
             isStreaming: false,
-        });
+        };
         this.sessions.set(chatId, state);
         this.notifySessionChange(chatId, state);
         return state;
@@ -1020,33 +862,6 @@ 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);
     }
@@ -1068,65 +883,24 @@ 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 attempt(state.publicAccessToken);
+            return await op(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 attempt(state.publicAccessToken);
+                return await op(state.publicAccessToken);
             }
             if (!isAuthError(err))
                 throw err;
@@ -1137,7 +911,7 @@ class TriggerChatTransport {
         state.publicAccessToken = fresh;
         this.notifySessionChange(chatId, state);
         try {
-            return await attempt(fresh);
+            return await op(fresh);
         }
         catch (err) {
             if (!isSessionNotFoundError(err))
@@ -1147,7 +921,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 attempt(state.publicAccessToken);
+        return await op(state.publicAccessToken);
     }
     /**
      * Repair a stale/phantom hydrated session. The cached state pointed at a
@@ -1163,19 +937,11 @@ 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, pendingVersion } = await this.resolveStartSession({
+        const { publicAccessToken } = 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;
@@ -1199,13 +965,8 @@ class TriggerChatTransport {
             : internalAbort.signal;
         if (abortSignal) {
             abortSignal.addEventListener("abort", () => {
-                // 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) {
+                if (options?.sendStopOnAbort !== false) {
                     state.skipToTurnComplete = true;
-                    state.supersededInputSeq = state.activeInputSeq;
                     this.appendInputChunk(chatId, state.publicAccessToken, this.serializeInputChunk({ kind: "stop" })).catch(() => { });
                 }
                 internalAbort.abort();
@@ -1265,7 +1026,26 @@ class TriggerChatTransport {
                     })()
                     : () => { };
                 const sseCtx = { endpoint: "out", chatId };
-                const sseFetchClient = this.sseFetchClient(sseCtx);
+                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;
                 let sawFirstChunk = false;
                 let sinceInSeq = options?.sinceInSeq;
                 const connectSseOnce = async (token) => {
@@ -1313,16 +1093,36 @@ 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 < ai_shared_js_1.MAX_EOF_RESUBSCRIBES)) &&
+                    while ((this.watchMode || (state.isStreaming && eofResubscribes < MAX_EOF_RESUBSCRIBES)) &&
                         !currentSubscription?.sessionSettled &&
                         !combinedSignal.aborted) {
                         eofResubscribes++;
-                        await (0, ai_shared_js_1.waitBeforeEofResubscribe)(eofResubscribes, combinedSignal);
+                        // 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);
+                        });
                         if (combinedSignal.aborted)
                             break;
                         const opened = await openWithAuthRetry();
@@ -1446,41 +1246,11 @@ class TriggerChatTransport {
                                 continue;
                             }
                         }
-                        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.");
+                        if (state.skipToTurnComplete) {
+                            if (controlValue === v3_1.TRIGGER_CONTROL_SUBTYPE.TURN_COMPLETE) {
+                                state.skipToTurnComplete = false;
                             }
+                            continue;
                         }
                         if (controlValue === v3_1.TRIGGER_CONTROL_SUBTYPE.UPGRADE_REQUIRED) {
                             // Server has already triggered the new run via
@@ -1489,26 +1259,6 @@ 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.
@@ -1519,11 +1269,6 @@ 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) {