@trigger.dev/sdk 0.0.0-prerelease-20260302145933 → 0.0.0-prerelease-20260305142821

package/dist/esm/v3/chat-react.d.ts

@@ -0,0 +1,45 @@
+import { TriggerChatTransport, type TriggerChatTransportOptions } from "./chat.js";
+import type { AnyTask, TaskIdentifier } from "@trigger.dev/core/v3";
+/**
+ * Options for `useTriggerChatTransport`, with a type-safe `task` field.
+ *
+ * Pass a task type parameter to get compile-time validation of the task ID:
+ * ```ts
+ * useTriggerChatTransport<typeof myTask>({ task: "my-task", ... })
+ * ```
+ */
+export type UseTriggerChatTransportOptions<TTask extends AnyTask = AnyTask> = Omit<TriggerChatTransportOptions, "task"> & {
+    /** The task ID. Strongly typed when a task type parameter is provided. */
+    task: TaskIdentifier<TTask>;
+};
+/**
+ * React hook that creates and memoizes a `TriggerChatTransport` instance.
+ *
+ * The transport is created once on first render and reused for the lifetime
+ * of the component. This avoids the need for `useMemo` and ensures the
+ * transport's internal session state (run IDs, lastEventId, etc.)
+ * is preserved across re-renders.
+ *
+ * For dynamic access tokens, pass a function — it will be called on each
+ * request without needing to recreate the transport.
+ *
+ * The `onSessionChange` callback is kept in a ref so the transport always
+ * calls the latest version without needing to be recreated.
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from "@ai-sdk/react";
+ * import { useTriggerChatTransport } from "@trigger.dev/sdk/chat/react";
+ * import type { chat } from "@/trigger/chat";
+ *
+ * function Chat() {
+ *   const transport = useTriggerChatTransport<typeof chat>({
+ *     task: "ai-chat",
+ *     accessToken: () => fetchToken(),
+ *   });
+ *
+ *   const { messages, sendMessage } = useChat({ transport });
+ * }
+ * ```
+ */
+export declare function useTriggerChatTransport<TTask extends AnyTask = AnyTask>(options: UseTriggerChatTransportOptions<TTask>): TriggerChatTransport;

package/dist/esm/v3/chat-react.js

@@ -0,0 +1,68 @@
+"use client";
+/**
+ * @module @trigger.dev/sdk/chat/react
+ *
+ * React hooks for AI SDK chat transport integration.
+ * Use alongside `@trigger.dev/sdk/chat` for a type-safe, ergonomic DX.
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from "@ai-sdk/react";
+ * import { useTriggerChatTransport } from "@trigger.dev/sdk/chat/react";
+ * import type { chat } from "@/trigger/chat";
+ *
+ * function Chat() {
+ *   const transport = useTriggerChatTransport<typeof chat>({
+ *     task: "ai-chat",
+ *     accessToken: () => fetchToken(),
+ *   });
+ *
+ *   const { messages, sendMessage } = useChat({ transport });
+ * }
+ * ```
+ */
+import { useEffect, useRef } from "react";
+import { TriggerChatTransport, } from "./chat.js";
+/**
+ * React hook that creates and memoizes a `TriggerChatTransport` instance.
+ *
+ * The transport is created once on first render and reused for the lifetime
+ * of the component. This avoids the need for `useMemo` and ensures the
+ * transport's internal session state (run IDs, lastEventId, etc.)
+ * is preserved across re-renders.
+ *
+ * For dynamic access tokens, pass a function — it will be called on each
+ * request without needing to recreate the transport.
+ *
+ * The `onSessionChange` callback is kept in a ref so the transport always
+ * calls the latest version without needing to be recreated.
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from "@ai-sdk/react";
+ * import { useTriggerChatTransport } from "@trigger.dev/sdk/chat/react";
+ * import type { chat } from "@/trigger/chat";
+ *
+ * function Chat() {
+ *   const transport = useTriggerChatTransport<typeof chat>({
+ *     task: "ai-chat",
+ *     accessToken: () => fetchToken(),
+ *   });
+ *
+ *   const { messages, sendMessage } = useChat({ transport });
+ * }
+ * ```
+ */
+export function useTriggerChatTransport(options) {
+    const ref = useRef(null);
+    if (ref.current === null) {
+        ref.current = new TriggerChatTransport(options);
+    }
+    // Keep onSessionChange up to date without recreating the transport
+    const { onSessionChange } = options;
+    useEffect(() => {
+        ref.current?.setOnSessionChange(onSessionChange);
+    }, [onSessionChange]);
+    return ref.current;
+}
+//# sourceMappingURL=chat-react.js.map

package/dist/esm/v3/chat-react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-react.js","sourceRoot":"","sources":["../../../src/v3/chat-react.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,EACL,oBAAoB,GAErB,MAAM,WAAW,CAAC;AAmBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,uBAAuB,CACrC,OAA8C;IAE9C,MAAM,GAAG,GAAG,MAAM,CAA8B,IAAI,CAAC,CAAC;IACtD,IAAI,GAAG,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;QACzB,GAAG,CAAC,OAAO,GAAG,IAAI,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAClD,CAAC;IAED,mEAAmE;IACnE,MAAM,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC;IACpC,SAAS,CAAC,GAAG,EAAE;QACb,GAAG,CAAC,OAAO,EAAE,kBAAkB,CAAC,eAAe,CAAC,CAAC;IACnD,CAAC,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC;IAEtB,OAAO,GAAG,CAAC,OAAO,CAAC;AACrB,CAAC"}

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

@@ -0,0 +1,241 @@
+/**
+ * @module @trigger.dev/sdk/chat
+ *
+ * Browser-safe module for AI SDK chat transport integration.
+ * Use this on the frontend with the AI SDK's `useChat` hook.
+ *
+ * For backend helpers (`chatTask`, `pipeChat`), use `@trigger.dev/sdk/ai` instead.
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from "@ai-sdk/react";
+ * import { TriggerChatTransport } from "@trigger.dev/sdk/chat";
+ *
+ * function Chat({ accessToken }: { accessToken: string }) {
+ *   const { messages, sendMessage, status } = useChat({
+ *     transport: new TriggerChatTransport({
+ *       task: "my-chat-task",
+ *       accessToken,
+ *     }),
+ *   });
+ * }
+ * ```
+ */
+import type { ChatTransport, UIMessage, UIMessageChunk, ChatRequestOptions } from "ai";
+/**
+ * Options for creating a TriggerChatTransport.
+ */
+export type TriggerChatTransportOptions = {
+    /**
+     * The Trigger.dev task ID to trigger for chat completions.
+     * This task should be defined using `chatTask()` from `@trigger.dev/sdk/ai`,
+     * or a regular `task()` that uses `pipeChat()`.
+     */
+    task: string;
+    /**
+     * An access token for authenticating with the Trigger.dev API.
+     *
+     * This must be a token with permission to trigger the task. You can use:
+     * - A **trigger public token** created via `auth.createTriggerPublicToken(taskId)` (recommended for frontend use)
+     * - A **secret API key** (for server-side use only — never expose in the browser)
+     *
+     * Can also be a function that returns a token string (sync or async),
+     * useful for dynamic token refresh or passing a Next.js server action directly.
+     */
+    accessToken: string | (() => string | Promise<string>);
+    /**
+     * Base URL for the Trigger.dev API.
+     * @default "https://api.trigger.dev"
+     */
+    baseURL?: string;
+    /**
+     * The stream key where the task pipes UIMessageChunk data.
+     * When using `chatTask()` or `pipeChat()`, this is handled automatically.
+     * Only set this if you're using a custom stream key.
+     *
+     * @default "chat"
+     */
+    streamKey?: string;
+    /**
+     * Additional headers to include in API requests to Trigger.dev.
+     */
+    headers?: Record<string, string>;
+    /**
+     * The number of seconds to wait for the realtime stream to produce data
+     * before timing out.
+     *
+     * @default 120
+     */
+    streamTimeoutSeconds?: number;
+    /**
+     * Default metadata included in every request payload.
+     * Merged with per-call `metadata` from `sendMessage()` — per-call values
+     * take precedence over transport-level defaults.
+     *
+     * Useful for data that should accompany every message, like a user ID.
+     *
+     * @example
+     * ```ts
+     * new TriggerChatTransport({
+     *   task: "my-chat",
+     *   accessToken,
+     *   metadata: { userId: currentUser.id },
+     * });
+     * ```
+     */
+    metadata?: Record<string, unknown>;
+    /**
+     * Restore active chat sessions from external storage (e.g. localStorage).
+     *
+     * After a page refresh, pass previously persisted sessions here so the
+     * transport can reconnect to existing runs instead of starting new ones.
+     * Use `getSession()` to retrieve session state for persistence.
+     *
+     * @example
+     * ```ts
+     * new TriggerChatTransport({
+     *   task: "my-chat",
+     *   accessToken,
+     *   sessions: {
+     *     "chat-abc": { runId: "run_123", publicAccessToken: "...", lastEventId: "42" },
+     *   },
+     * });
+     * ```
+     */
+    sessions?: Record<string, {
+        runId: string;
+        publicAccessToken: string;
+        lastEventId?: string;
+    }>;
+    /**
+     * Called whenever a chat session's state changes.
+     *
+     * Fires when:
+     * - A new session is created (after triggering a task)
+     * - A turn completes (lastEventId updated)
+     * - A session is removed (run ended or input stream send failed) — `session` will be `null`
+     *
+     * Use this to persist session state for reconnection after page refreshes,
+     * without needing to call `getSession()` manually.
+     *
+     * @example
+     * ```ts
+     * new TriggerChatTransport({
+     *   task: "my-chat",
+     *   accessToken,
+     *   onSessionChange: (chatId, session) => {
+     *     if (session) {
+     *       localStorage.setItem(`session:${chatId}`, JSON.stringify(session));
+     *     } else {
+     *       localStorage.removeItem(`session:${chatId}`);
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    onSessionChange?: (chatId: string, session: {
+        runId: string;
+        publicAccessToken: string;
+        lastEventId?: string;
+    } | null) => void;
+};
+/**
+ * A custom AI SDK `ChatTransport` that runs chat completions as durable Trigger.dev tasks.
+ *
+ * When `sendMessages` is called, the transport:
+ * 1. Triggers a Trigger.dev task (or sends to an existing run via input streams)
+ * 2. Subscribes to the task's realtime stream to receive `UIMessageChunk` data
+ * 3. Returns a `ReadableStream<UIMessageChunk>` that the AI SDK processes natively
+ *
+ * Calling `stop()` from `useChat` sends a stop signal via input streams, which
+ * aborts the current `streamText` call in the task without ending the run.
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from "@ai-sdk/react";
+ * import { TriggerChatTransport } from "@trigger.dev/sdk/chat";
+ *
+ * function Chat({ accessToken }: { accessToken: string }) {
+ *   const { messages, sendMessage, stop, status } = useChat({
+ *     transport: new TriggerChatTransport({
+ *       task: "my-chat-task",
+ *       accessToken,
+ *     }),
+ *   });
+ *
+ *   // stop() sends a stop signal — the task aborts streamText but keeps the run alive
+ * }
+ * ```
+ */
+export declare class TriggerChatTransport implements ChatTransport<UIMessage> {
+    private readonly taskId;
+    private readonly resolveAccessToken;
+    private readonly baseURL;
+    private readonly streamKey;
+    private readonly extraHeaders;
+    private readonly streamTimeoutSeconds;
+    private readonly defaultMetadata;
+    private _onSessionChange;
+    private sessions;
+    constructor(options: TriggerChatTransportOptions);
+    sendMessages: (options: {
+        trigger: "submit-message" | "regenerate-message";
+        chatId: string;
+        messageId: string | undefined;
+        messages: UIMessage[];
+        abortSignal: AbortSignal | undefined;
+    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk>>;
+    reconnectToStream: (options: {
+        chatId: string;
+    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk> | null>;
+    /**
+     * Get the current session state for a chat, suitable for external persistence.
+     *
+     * Returns `undefined` if no active session exists for this chatId.
+     * Persist the returned value to localStorage so it can be restored
+     * after a page refresh via `restoreSession()`.
+     *
+     * @example
+     * ```ts
+     * const session = transport.getSession(chatId);
+     * if (session) {
+     *   localStorage.setItem(`session:${chatId}`, JSON.stringify(session));
+     * }
+     * ```
+     */
+    getSession: (chatId: string) => {
+        runId: string;
+        publicAccessToken: string;
+        lastEventId?: string;
+    } | undefined;
+    /**
+     * Update the `onSessionChange` callback.
+     * Useful for React hooks that need to update the callback without recreating the transport.
+     */
+    setOnSessionChange(callback: ((chatId: string, session: {
+        runId: string;
+        publicAccessToken: string;
+        lastEventId?: string;
+    } | null) => void) | undefined): void;
+    private notifySessionChange;
+    private subscribeToStream;
+}
+/**
+ * Creates a new `TriggerChatTransport` instance.
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from "@ai-sdk/react";
+ * import { createChatTransport } from "@trigger.dev/sdk/chat";
+ *
+ * const transport = createChatTransport({
+ *   task: "my-chat-task",
+ *   accessToken: publicAccessToken,
+ * });
+ *
+ * function Chat() {
+ *   const { messages, sendMessage } = useChat({ transport });
+ * }
+ * ```
+ */
+export declare function createChatTransport(options: TriggerChatTransportOptions): TriggerChatTransport;

package/dist/esm/v3/chat.js

@@ -0,0 +1,338 @@
+/**
+ * @module @trigger.dev/sdk/chat
+ *
+ * Browser-safe module for AI SDK chat transport integration.
+ * Use this on the frontend with the AI SDK's `useChat` hook.
+ *
+ * For backend helpers (`chatTask`, `pipeChat`), use `@trigger.dev/sdk/ai` instead.
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from "@ai-sdk/react";
+ * import { TriggerChatTransport } from "@trigger.dev/sdk/chat";
+ *
+ * function Chat({ accessToken }: { accessToken: string }) {
+ *   const { messages, sendMessage, status } = useChat({
+ *     transport: new TriggerChatTransport({
+ *       task: "my-chat-task",
+ *       accessToken,
+ *     }),
+ *   });
+ * }
+ * ```
+ */
+import { ApiClient, SSEStreamSubscription } from "@trigger.dev/core/v3";
+import { CHAT_MESSAGES_STREAM_ID, CHAT_STOP_STREAM_ID } from "./chat-constants.js";
+const DEFAULT_STREAM_KEY = "chat";
+const DEFAULT_BASE_URL = "https://api.trigger.dev";
+const DEFAULT_STREAM_TIMEOUT_SECONDS = 120;
+/**
+ * A custom AI SDK `ChatTransport` that runs chat completions as durable Trigger.dev tasks.
+ *
+ * When `sendMessages` is called, the transport:
+ * 1. Triggers a Trigger.dev task (or sends to an existing run via input streams)
+ * 2. Subscribes to the task's realtime stream to receive `UIMessageChunk` data
+ * 3. Returns a `ReadableStream<UIMessageChunk>` that the AI SDK processes natively
+ *
+ * Calling `stop()` from `useChat` sends a stop signal via input streams, which
+ * aborts the current `streamText` call in the task without ending the run.
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from "@ai-sdk/react";
+ * import { TriggerChatTransport } from "@trigger.dev/sdk/chat";
+ *
+ * function Chat({ accessToken }: { accessToken: string }) {
+ *   const { messages, sendMessage, stop, status } = useChat({
+ *     transport: new TriggerChatTransport({
+ *       task: "my-chat-task",
+ *       accessToken,
+ *     }),
+ *   });
+ *
+ *   // stop() sends a stop signal — the task aborts streamText but keeps the run alive
+ * }
+ * ```
+ */
+export class TriggerChatTransport {
+    taskId;
+    resolveAccessToken;
+    baseURL;
+    streamKey;
+    extraHeaders;
+    streamTimeoutSeconds;
+    defaultMetadata;
+    _onSessionChange;
+    sessions = new Map();
+    constructor(options) {
+        this.taskId = options.task;
+        this.resolveAccessToken =
+            typeof options.accessToken === "function"
+                ? options.accessToken
+                : () => options.accessToken;
+        this.baseURL = options.baseURL ?? DEFAULT_BASE_URL;
+        this.streamKey = options.streamKey ?? DEFAULT_STREAM_KEY;
+        this.extraHeaders = options.headers ?? {};
+        this.streamTimeoutSeconds = options.streamTimeoutSeconds ?? DEFAULT_STREAM_TIMEOUT_SECONDS;
+        this.defaultMetadata = options.metadata;
+        this._onSessionChange = options.onSessionChange;
+        // Restore sessions from external storage
+        if (options.sessions) {
+            for (const [chatId, session] of Object.entries(options.sessions)) {
+                this.sessions.set(chatId, {
+                    runId: session.runId,
+                    publicAccessToken: session.publicAccessToken,
+                    lastEventId: session.lastEventId,
+                });
+            }
+        }
+    }
+    sendMessages = async (options) => {
+        const { trigger, chatId, messageId, messages, abortSignal, body, metadata } = options;
+        const mergedMetadata = this.defaultMetadata || metadata
+            ? { ...(this.defaultMetadata ?? {}), ...(metadata ?? {}) }
+            : undefined;
+        const payload = {
+            ...(body ?? {}),
+            messages,
+            chatId,
+            trigger,
+            messageId,
+            metadata: mergedMetadata,
+        };
+        const session = this.sessions.get(chatId);
+        // If we have an existing run, send the message via input stream
+        // to resume the conversation in the same run.
+        if (session?.runId) {
+            try {
+                // Keep wire payloads minimal — the backend accumulates the full history.
+                // For submit-message: only send the new user message (always the last one).
+                // For regenerate-message: send full history so the backend can reset its accumulator.
+                const minimalPayload = {
+                    ...payload,
+                    messages: trigger === "submit-message" ? messages.slice(-1) : messages,
+                };
+                const apiClient = new ApiClient(this.baseURL, session.publicAccessToken);
+                await apiClient.sendInputStream(session.runId, CHAT_MESSAGES_STREAM_ID, minimalPayload);
+                return this.subscribeToStream(session.runId, session.publicAccessToken, abortSignal, chatId);
+            }
+            catch {
+                // If sending fails (run died, etc.), fall through to trigger a new run.
+                this.sessions.delete(chatId);
+                this.notifySessionChange(chatId, null);
+            }
+        }
+        // First message or run has ended — trigger a new run
+        const currentToken = await this.resolveAccessToken();
+        const apiClient = new ApiClient(this.baseURL, currentToken);
+        const triggerResponse = await apiClient.triggerTask(this.taskId, {
+            payload,
+            options: {
+                payloadType: "application/json",
+            },
+        });
+        const runId = triggerResponse.id;
+        const publicAccessToken = "publicAccessToken" in triggerResponse
+            ? triggerResponse.publicAccessToken
+            : undefined;
+        const newSession = {
+            runId,
+            publicAccessToken: publicAccessToken ?? currentToken,
+        };
+        this.sessions.set(chatId, newSession);
+        this.notifySessionChange(chatId, newSession);
+        return this.subscribeToStream(runId, publicAccessToken ?? currentToken, abortSignal, chatId);
+    };
+    reconnectToStream = async (options) => {
+        const session = this.sessions.get(options.chatId);
+        if (!session) {
+            return null;
+        }
+        return this.subscribeToStream(session.runId, session.publicAccessToken, undefined, options.chatId);
+    };
+    /**
+     * Get the current session state for a chat, suitable for external persistence.
+     *
+     * Returns `undefined` if no active session exists for this chatId.
+     * Persist the returned value to localStorage so it can be restored
+     * after a page refresh via `restoreSession()`.
+     *
+     * @example
+     * ```ts
+     * const session = transport.getSession(chatId);
+     * if (session) {
+     *   localStorage.setItem(`session:${chatId}`, JSON.stringify(session));
+     * }
+     * ```
+     */
+    getSession = (chatId) => {
+        const session = this.sessions.get(chatId);
+        if (!session)
+            return undefined;
+        return {
+            runId: session.runId,
+            publicAccessToken: session.publicAccessToken,
+            lastEventId: session.lastEventId,
+        };
+    };
+    /**
+     * Update the `onSessionChange` callback.
+     * Useful for React hooks that need to update the callback without recreating the transport.
+     */
+    setOnSessionChange(callback) {
+        this._onSessionChange = callback;
+    }
+    notifySessionChange(chatId, session) {
+        if (!this._onSessionChange)
+            return;
+        if (session) {
+            this._onSessionChange(chatId, {
+                runId: session.runId,
+                publicAccessToken: session.publicAccessToken,
+                lastEventId: session.lastEventId,
+            });
+        }
+        else {
+            this._onSessionChange(chatId, null);
+        }
+    }
+    subscribeToStream(runId, accessToken, abortSignal, chatId) {
+        const headers = {
+            Authorization: `Bearer ${accessToken}`,
+            ...this.extraHeaders,
+        };
+        // When resuming a run, skip past previously-seen events
+        // so we only receive the new turn's response.
+        const session = chatId ? this.sessions.get(chatId) : undefined;
+        // Create an internal AbortController so we can terminate the underlying
+        // fetch connection when we're done reading (e.g. after intercepting the
+        // control chunk). Without this, the SSE connection stays open and leaks.
+        const internalAbort = new AbortController();
+        const combinedSignal = abortSignal
+            ? AbortSignal.any([abortSignal, internalAbort.signal])
+            : internalAbort.signal;
+        // When the caller aborts (user calls stop()), send a stop signal to the
+        // running task via input streams, then close the SSE connection.
+        if (abortSignal) {
+            abortSignal.addEventListener("abort", () => {
+                if (session) {
+                    session.skipToTurnComplete = true;
+                    const api = new ApiClient(this.baseURL, session.publicAccessToken);
+                    api
+                        .sendInputStream(session.runId, CHAT_STOP_STREAM_ID, { stop: true })
+                        .catch(() => { }); // Best-effort
+                }
+                internalAbort.abort();
+            }, { once: true });
+        }
+        const subscription = new SSEStreamSubscription(`${this.baseURL}/realtime/v1/streams/${runId}/${this.streamKey}`, {
+            headers,
+            signal: combinedSignal,
+            timeoutInSeconds: this.streamTimeoutSeconds,
+            lastEventId: session?.lastEventId,
+        });
+        return new ReadableStream({
+            start: async (controller) => {
+                try {
+                    const sseStream = await subscription.subscribe();
+                    const reader = sseStream.getReader();
+                    let chunkCount = 0;
+                    try {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done) {
+                                // Only delete session if the stream ended naturally (not aborted by stop).
+                                // When the user clicks stop, the abort closes the SSE reader which
+                                // returns done=true, but the run is still alive and waiting for
+                                // the next message via input streams.
+                                if (chatId && !combinedSignal.aborted) {
+                                    this.sessions.delete(chatId);
+                                    this.notifySessionChange(chatId, null);
+                                }
+                                controller.close();
+                                return;
+                            }
+                            if (combinedSignal.aborted) {
+                                internalAbort.abort();
+                                await reader.cancel();
+                                controller.close();
+                                return;
+                            }
+                            // Track the last event ID so we can resume from here
+                            if (value.id && session) {
+                                session.lastEventId = value.id;
+                            }
+                            // Guard against heartbeat or malformed SSE events
+                            if (value.chunk != null && typeof value.chunk === "object") {
+                                const chunk = value.chunk;
+                                // After a stop, skip leftover chunks from the stopped turn
+                                // until we see the __trigger_turn_complete marker.
+                                if (session?.skipToTurnComplete) {
+                                    if (chunk.type === "__trigger_turn_complete") {
+                                        session.skipToTurnComplete = false;
+                                        chunkCount = 0;
+                                    }
+                                    continue;
+                                }
+                                if (chunk.type === "__trigger_turn_complete" && chatId) {
+                                    // Notify with updated lastEventId before closing
+                                    if (session) {
+                                        this.notifySessionChange(chatId, session);
+                                    }
+                                    internalAbort.abort();
+                                    try {
+                                        controller.close();
+                                    }
+                                    catch {
+                                        // Controller may already be closed
+                                    }
+                                    return;
+                                }
+                                chunkCount++;
+                                controller.enqueue(chunk);
+                            }
+                        }
+                    }
+                    catch (readError) {
+                        reader.releaseLock();
+                        throw readError;
+                    }
+                }
+                catch (error) {
+                    if (error instanceof Error && error.name === "AbortError") {
+                        try {
+                            controller.close();
+                        }
+                        catch {
+                            // Controller may already be closed
+                        }
+                        return;
+                    }
+                    controller.error(error);
+                }
+            },
+        });
+    }
+}
+/**
+ * Creates a new `TriggerChatTransport` instance.
+ *
+ * @example
+ * ```tsx
+ * import { useChat } from "@ai-sdk/react";
+ * import { createChatTransport } from "@trigger.dev/sdk/chat";
+ *
+ * const transport = createChatTransport({
+ *   task: "my-chat-task",
+ *   accessToken: publicAccessToken,
+ * });
+ *
+ * function Chat() {
+ *   const { messages, sendMessage } = useChat({ transport });
+ * }
+ * ```
+ */
+export function createChatTransport(options) {
+    return new TriggerChatTransport(options);
+}
+//# sourceMappingURL=chat.js.map