@trigger.dev/sdk 4.5.15 → 4.6.0

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

@@ -177,6 +177,20 @@ export type ChatTransportSendSource = "submit-message" | "regenerate-message" |
  * stream fails unrecoverably.
  */
 export type ChatTransportEvent = {
+    /**
+     * The chat's run is parked waiting for its deployment (version skew protection). Messages
+     * sent meanwhile are durable and drain when it lands, but nothing answers until then.
+     * Re-emitted on every send while parked; clear the notice on `first-chunk`.
+     */
+    type: "run-pending-version";
+    chatId: string;
+    timestamp: number;
+    /**
+     * Where we learned it: creating the session, a send, the `headStart` POST, or an
+     * upgrade handing over to a deployment that has not landed yet.
+     */
+    source: "start" | "send" | "head-start" | "upgrade";
+} | {
     type: "message-sent";
     chatId: string;
     timestamp: number;
@@ -213,6 +227,14 @@ export type ChatTransportEvent = {
     timestamp: number;
     error: Error;
     status?: number;
+} | {
+    type: "session-closed";
+    chatId: string;
+    timestamp: number;
+    /** The reason supplied to `chat.close()` / `sessions.close()`, if any. */
+    reason?: string;
+    /** How the transport learned: the terminal record, or a refused send. */
+    source: "stream" | "append";
 } | {
     type: "first-chunk";
     chatId: string;
@@ -288,6 +310,11 @@ export type StartSessionParams<TClientData = unknown> = {
 export type StartSessionResult = {
     /** Session-scoped PAT — `read:sessions:{chatId} + write:sessions:{chatId}`. */
     publicAccessToken: string;
+    /**
+     * Pass through `pendingVersion` from `chat.createStartSessionAction` (or `POST
+     * /api/v1/sessions`) and the transport emits `run-pending-version`.
+     */
+    pendingVersion?: boolean;
 };
 /**
  * Public surface of {@link TriggerChatTransport}'s session state. Everything
@@ -301,6 +328,10 @@ export type ChatSessionPersistedState = {
     /** The `.in` append sequence of the last send this client owned; reused as `sinceInSeq` on reconnect. */
     activeInputSeq?: number;
     isStreaming?: boolean;
+    /** Set once the session is closed. Persisted so a reload doesn't retry a dead session. */
+    closed?: boolean;
+    /** The reason the session was closed, when one was given. */
+    closedReason?: string;
 };
 /**
  * Common options for the {@link TriggerChatTransport}.
@@ -493,10 +524,10 @@ export type TriggerChatTransportOptions<TClientData = unknown> = {
  */
 export declare class TriggerChatTransport implements ChatTransport<UIMessage> {
     private readonly taskId;
-    private readonly resolveAccessToken;
-    private readonly resolveStartSession;
+    private resolveAccessToken;
+    private resolveStartSession;
     private readonly resolveBaseURLFn;
-    private readonly fetchOverride;
+    private fetchOverride;
     private readonly extraHeaders;
     private readonly streamTimeoutSeconds;
     private defaultMetadata;
@@ -506,6 +537,7 @@ export declare class TriggerChatTransport implements ChatTransport<UIMessage> {
     private _onSessionChange;
     private _onEvent;
     private sessions;
+    private pendingResumeCursors;
     private activeStreams;
     private pendingStarts;
     private lastTurnSends;
@@ -579,16 +611,35 @@ export declare class TriggerChatTransport implements ChatTransport<UIMessage> {
      */
     stopGeneration: (chatId: string) => Promise<boolean>;
     /**
-     * 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`.
+     * 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.
      */
-    sendAction: (chatId: string, action: unknown) => Promise<ReadableStream<UIMessageChunk>>;
+    clearSupersedeGate: (chatId: string) => void;
+    /**
+     * 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`.
+     */
+    sendAction: (chatId: string, action: unknown, options?: {
+        abortSignal?: AbortSignal;
+        metadata?: Record<string, unknown>;
+    }) => Promise<ReadableStream<UIMessageChunk>>;
     getSession: (chatId: string) => ChatSessionPersistedState | undefined;
     setSession(chatId: string, session: ChatSessionPersistedState): void;
+    /**
+     * 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: string, lastEventId: string) => void;
+    private applyPendingResumeCursor;
     setOnSessionChange(callback: ((chatId: string, session: ChatSessionPersistedState | null) => void) | undefined): void;
     /** Update the `onEvent` callback without recreating the transport. */
     setOnEvent(callback: ((event: ChatTransportEvent) => void) | undefined): void;
@@ -606,6 +657,16 @@ export declare class TriggerChatTransport implements ChatTransport<UIMessage> {
      * transport see the latest value the next time they fire.
      */
     setClientData(clientData: Record<string, unknown> | undefined): void;
+    /**
+     * 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: (params: AccessTokenParams) => string | Promise<string>): void;
+    setStartSession(startSession: ((params: StartSessionParams<Record<string, unknown>>) => Promise<StartSessionResult>) | undefined): void;
+    setFetch(fetchOverride: ChatFetchOverride | undefined): void;
     isReadOnly(chatId: string): boolean;
     hasClaim(chatId: string): boolean;
     addReadOnlyListener(fn: (chatId: string, isReadOnly: boolean) => void): void;
@@ -616,6 +677,20 @@ export declare class TriggerChatTransport implements ChatTransport<UIMessage> {
     dispose(): void;
     private serializeInputChunk;
     private toPersisted;
+    /**
+     * Flip a session to closed and tell listeners once. Terminal: sends and
+     * reconnects stop from here on, and there is no reopening.
+     */
+    private markSessionClosed;
+    /**
+     * 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: string) => "open" | "closed";
+    /** The reason the session was closed, when one was given. */
+    sessionClosedReason: (chatId: string) => string | undefined;
     private notifySessionChange;
     /**
      * Resolves the session state for a chatId, starting the session if
@@ -631,6 +706,13 @@ export declare class TriggerChatTransport implements ChatTransport<UIMessage> {
      * via `accessToken` and retry once. Surfaces non-auth errors as-is.
      */
     private resolveBaseURL;
+    /**
+     * `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.
+     */
+    private sseFetchClient;
     private doFetch;
     private appendInputChunk;
     private callWithAuthRetry;