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

package/dist/commonjs/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/commonjs/v3/chat-react.js

@@ -0,0 +1,71 @@
+"use client";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTriggerChatTransport = useTriggerChatTransport;
+/**
+ * @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 });
+ * }
+ * ```
+ */
+const react_1 = require("react");
+const chat_js_1 = require("./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 });
+ * }
+ * ```
+ */
+function useTriggerChatTransport(options) {
+    const ref = (0, react_1.useRef)(null);
+    if (ref.current === null) {
+        ref.current = new chat_js_1.TriggerChatTransport(options);
+    }
+    // Keep onSessionChange up to date without recreating the transport
+    const { onSessionChange } = options;
+    (0, react_1.useEffect)(() => {
+        ref.current?.setOnSessionChange(onSessionChange);
+    }, [onSessionChange]);
+    return ref.current;
+}
+//# sourceMappingURL=chat-react.js.map

package/dist/commonjs/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;;;AA8Eb,0DAeC;AA3FD;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,iCAA0C;AAC1C,uCAGmB;AAmBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,SAAgB,uBAAuB,CACrC,OAA8C;IAE9C,MAAM,GAAG,GAAG,IAAA,cAAM,EAA8B,IAAI,CAAC,CAAC;IACtD,IAAI,GAAG,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;QACzB,GAAG,CAAC,OAAO,GAAG,IAAI,8BAAoB,CAAC,OAAO,CAAC,CAAC;IAClD,CAAC;IAED,mEAAmE;IACnE,MAAM,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC;IACpC,IAAA,iBAAS,EAAC,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/commonjs/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;