@trigger.dev/sdk 0.0.0-prerelease-20260306173130 → 0.0.0-prerelease-20260310150337

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

@@ -1,9 +1,24 @@
 import { AnyTask, Task, type inferSchemaIn, type inferSchemaOut, type TaskIdentifier, type TaskOptions, type TaskSchema, type TaskWithSchema } from "@trigger.dev/core/v3";
-import type { ModelMessage, UIMessage } from "ai";
-import { Tool, ToolCallOptions } from "ai";
+import type { ModelMessage, UIMessage, UIMessageChunk, UIMessageStreamOptions } from "ai";
+import { Tool } from "ai";
 import { locals } from "./locals.js";
 import { CHAT_MESSAGES_STREAM_ID, CHAT_STOP_STREAM_ID } from "./chat-constants.js";
-export type ToolCallExecutionOptions = Omit<ToolCallOptions, "abortSignal">;
+export type ToolCallExecutionOptions = {
+    toolCallId: string;
+    experimental_context?: unknown;
+    /** Chat context — only present when the tool runs inside a chat.task turn. */
+    chatId?: string;
+    turn?: number;
+    continuation?: boolean;
+    clientData?: unknown;
+};
+/** Chat context stored in locals during each chat.task turn for auto-detection. */
+type ChatTurnContext<TClientData = unknown> = {
+    chatId: string;
+    turn: number;
+    continuation: boolean;
+    clientData?: TClientData;
+};
 type ToolResultContent = Array<{
     type: "text";
     text: string;
@@ -18,9 +33,43 @@ export type ToolOptions<TResult> = {
 declare function toolFromTask<TIdentifier extends string, TInput = void, TOutput = unknown>(task: Task<TIdentifier, TInput, TOutput>, options?: ToolOptions<TOutput>): Tool<TInput, TOutput>;
 declare function toolFromTask<TIdentifier extends string, TTaskSchema extends TaskSchema | undefined = undefined, TOutput = unknown>(task: TaskWithSchema<TIdentifier, TTaskSchema, TOutput>, options?: ToolOptions<TOutput>): Tool<inferSchemaIn<TTaskSchema>, TOutput>;
 declare function getToolOptionsFromMetadata(): ToolCallExecutionOptions | undefined;
+/**
+ * Get the current tool call ID from inside a subtask invoked via `ai.tool()`.
+ * Returns `undefined` if not running as a tool subtask.
+ */
+declare function getToolCallId(): string | undefined;
+/**
+ * Get the chat context from inside a subtask invoked via `ai.tool()` within a `chat.task`.
+ * Pass `typeof yourChatTask` as the type parameter to get typed `clientData`.
+ * Returns `undefined` if the parent is not a chat task.
+ *
+ * @example
+ * ```ts
+ * const ctx = ai.chatContext<typeof myChat>();
+ * // ctx?.clientData is typed based on myChat's clientDataSchema
+ * ```
+ */
+declare function getToolChatContext<TChatTask extends AnyTask = AnyTask>(): ChatTurnContext<InferChatClientData<TChatTask>> | undefined;
+/**
+ * Get the chat context from inside a subtask, throwing if not in a chat context.
+ * Pass `typeof yourChatTask` as the type parameter to get typed `clientData`.
+ *
+ * @example
+ * ```ts
+ * const ctx = ai.chatContextOrThrow<typeof myChat>();
+ * // ctx.chatId, ctx.clientData are guaranteed non-null
+ * ```
+ */
+declare function getToolChatContextOrThrow<TChatTask extends AnyTask = AnyTask>(): ChatTurnContext<InferChatClientData<TChatTask>>;
 export declare const ai: {
     tool: typeof toolFromTask;
     currentToolOptions: typeof getToolOptionsFromMetadata;
+    /** Get the tool call ID from inside a subtask invoked via `ai.tool()`. */
+    toolCallId: typeof getToolCallId;
+    /** Get chat context (chatId, turn, clientData, etc.) from inside a subtask of a `chat.task`. Returns undefined if not in a chat context. */
+    chatContext: typeof getToolChatContext;
+    /** Get chat context or throw if not in a chat context. Pass `typeof yourChatTask` for typed clientData. */
+    chatContextOrThrow: typeof getToolChatContextOrThrow;
 };
 /**
  * Creates a public access token for a chat task.
@@ -47,6 +96,23 @@ declare function createChatAccessToken<TTask extends AnyTask>(taskId: TaskIdenti
  */
 export declare const CHAT_STREAM_KEY = "chat";
 export { CHAT_MESSAGES_STREAM_ID, CHAT_STOP_STREAM_ID };
+/**
+ * The wire payload shape sent by `TriggerChatTransport`.
+ * Uses `metadata` to match the AI SDK's `ChatRequestOptions` field name.
+ */
+export type ChatTaskWirePayload<TMessage extends UIMessage = UIMessage, TMetadata = unknown> = {
+    messages: TMessage[];
+    chatId: string;
+    trigger: "submit-message" | "regenerate-message" | "preload";
+    messageId?: string;
+    metadata?: TMetadata;
+    /** Whether this run is continuing an existing chat whose previous run ended. */
+    continuation?: boolean;
+    /** The run ID of the previous run (only set when `continuation` is true). */
+    previousRunId?: string;
+    /** Override warm timeout for this run (seconds). Set by transport.preload(). */
+    warmTimeoutInSeconds?: number;
+};
 /**
  * The payload shape passed to the `chatTask` run function.
  *
@@ -66,12 +132,19 @@ export type ChatTaskPayload<TClientData = unknown> = {
      * The trigger type:
      * - `"submit-message"`: A new user message
      * - `"regenerate-message"`: Regenerate the last assistant response
+     * - `"preload"`: Run was preloaded before the first message (only on turn 0)
      */
-    trigger: "submit-message" | "regenerate-message";
+    trigger: "submit-message" | "regenerate-message" | "preload";
     /** The ID of the message to regenerate (only for `"regenerate-message"`) */
     messageId?: string;
     /** Custom data from the frontend (passed via `metadata` on `sendMessage()` or the transport). */
     clientData?: TClientData;
+    /** Whether this run is continuing an existing chat (previous run timed out or was cancelled). False for brand new chats. */
+    continuation: boolean;
+    /** The run ID of the previous run (only set when `continuation` is true). */
+    previousRunId?: string;
+    /** Whether this run was preloaded before the first message. */
+    preloaded: boolean;
 };
 /**
  * Abort signals provided to the `chatTask` run function.
@@ -108,6 +181,19 @@ export type PipeChatOptions = {
     /** Override the default span name for this operation. */
     spanName?: string;
 };
+/**
+ * Options for customizing the `toUIMessageStream()` call used when piping
+ * `streamText` results to the frontend.
+ *
+ * Set static defaults via `uiMessageStreamOptions` on `chat.task()`, or
+ * override per-turn via `chat.setUIMessageStreamOptions()`.
+ *
+ * `onFinish`, `originalMessages`, and `generateMessageId` are omitted because
+ * they are managed internally for response capture and message accumulation.
+ * Use `streamText`'s `onFinish` for custom finish handling, or drop down to
+ * raw task mode with `chat.pipe()` for full control.
+ */
+export type ChatUIMessageStreamOptions = Omit<UIMessageStreamOptions<UIMessage>, "onFinish" | "originalMessages" | "generateMessageId">;
 /**
  * An object with a `toUIMessageStream()` method (e.g. `StreamTextResult` from `streamText()`).
  */
@@ -168,6 +254,19 @@ declare function pipeChat(source: UIMessageStreamable | AsyncIterable<unknown> |
  * emits a control chunk and suspends via `messagesInput.wait()`. The frontend
  * transport resumes the same run by sending the next message via input streams.
  */
+/**
+ * Event passed to the `onPreload` callback.
+ */
+export type PreloadEvent<TClientData = unknown> = {
+    /** The unique identifier for the chat session. */
+    chatId: string;
+    /** The Trigger.dev run ID for this conversation. */
+    runId: string;
+    /** A scoped access token for this chat run. */
+    chatAccessToken: string;
+    /** Custom data from the frontend. */
+    clientData?: TClientData;
+};
 /**
  * Event passed to the `onChatStart` callback.
  */
@@ -182,6 +281,12 @@ export type ChatStartEvent<TClientData = unknown> = {
     runId: string;
     /** A scoped access token for this chat run. Persist this for frontend reconnection. */
     chatAccessToken: string;
+    /** Whether this run is continuing an existing chat (previous run timed out or was cancelled). False for brand new chats. */
+    continuation: boolean;
+    /** The run ID of the previous run (only set when `continuation` is true). */
+    previousRunId?: string;
+    /** Whether this run was preloaded before the first message. */
+    preloaded: boolean;
 };
 /**
  * Event passed to the `onTurnStart` callback.
@@ -201,6 +306,12 @@ export type TurnStartEvent<TClientData = unknown> = {
     chatAccessToken: string;
     /** Custom data from the frontend. */
     clientData?: TClientData;
+    /** Whether this run is continuing an existing chat (previous run timed out or was cancelled). False for brand new chats. */
+    continuation: boolean;
+    /** The run ID of the previous run (only set when `continuation` is true). */
+    previousRunId?: string;
+    /** Whether this run was preloaded before the first message. */
+    preloaded: boolean;
 };
 /**
  * Event passed to the `onTurnComplete` callback.
@@ -225,8 +336,14 @@ export type TurnCompleteEvent<TClientData = unknown> = {
      * Useful for inserting individual message records instead of overwriting the full history.
      */
     newUIMessages: UIMessage[];
-    /** The assistant's response for this turn (undefined if `pipeChat` was used manually). */
+    /** The assistant's response for this turn, with aborted parts cleaned up when `stopped` is true. Undefined if `pipeChat` was used manually. */
     responseMessage: UIMessage | undefined;
+    /**
+     * The raw assistant response before abort cleanup. Includes incomplete tool parts
+     * (`input-available`, `partial-call`) and streaming reasoning/text parts.
+     * Use this if you need custom cleanup logic. Same as `responseMessage` when not stopped.
+     */
+    rawResponseMessage: UIMessage | undefined;
     /** The turn number (0-indexed). */
     turn: number;
     /** The Trigger.dev run ID for this conversation. */
@@ -237,6 +354,14 @@ export type TurnCompleteEvent<TClientData = unknown> = {
     lastEventId?: string;
     /** Custom data from the frontend. */
     clientData?: TClientData;
+    /** Whether the user stopped generation during this turn. */
+    stopped: boolean;
+    /** Whether this run is continuing an existing chat (previous run timed out or was cancelled). False for brand new chats. */
+    continuation: boolean;
+    /** The run ID of the previous run (only set when `continuation` is true). */
+    previousRunId?: string;
+    /** Whether this run was preloaded before the first message. */
+    preloaded: boolean;
 };
 export type ChatTaskOptions<TIdentifier extends string, TClientDataSchema extends TaskSchema | undefined = undefined> = Omit<TaskOptions<TIdentifier, ChatTaskWirePayload, unknown>, "run"> & {
     /**
@@ -268,6 +393,21 @@ export type ChatTaskOptions<TIdentifier extends string, TClientDataSchema extend
      * the stream is automatically piped to the frontend.
      */
     run: (payload: ChatTaskRunPayload<inferSchemaOut<TClientDataSchema>>) => Promise<unknown>;
+    /**
+     * Called when a preloaded run starts, before the first message arrives.
+     *
+     * Use this to initialize state, create DB records, and load context early —
+     * so everything is ready when the user's first message comes through.
+     *
+     * @example
+     * ```ts
+     * onPreload: async ({ chatId, clientData }) => {
+     *   await db.chat.create({ data: { id: chatId } });
+     *   userContext.init(await loadUser(clientData.userId));
+     * }
+     * ```
+     */
+    onPreload?: (event: PreloadEvent<inferSchemaOut<TClientDataSchema>>) => Promise<void> | void;
     /**
      * Called on the first turn (turn 0) of a new run, before the `run` function executes.
      *
@@ -346,6 +486,52 @@ export type ChatTaskOptions<TIdentifier extends string, TClientDataSchema extend
      * @default "1h"
      */
     chatAccessTokenTTL?: string;
+    /**
+     * How long (in seconds) to keep the run warm after `onPreload` fires,
+     * waiting for the first message before suspending.
+     *
+     * Only applies to preloaded runs (triggered via `transport.preload()`).
+     *
+     * @default Same as `warmTimeoutInSeconds`
+     */
+    preloadWarmTimeoutInSeconds?: number;
+    /**
+     * How long to wait (suspended) for the first message after a preloaded run starts.
+     * If no message arrives within this time, the run ends.
+     *
+     * Only applies to preloaded runs.
+     *
+     * @default Same as `turnTimeout`
+     */
+    preloadTimeout?: string;
+    /**
+     * Default options for `toUIMessageStream()` when auto-piping or using
+     * `turn.complete()` / `chat.pipeAndCapture()`.
+     *
+     * Controls how the `StreamTextResult` is converted to a `UIMessageChunk`
+     * stream — error handling, reasoning/source visibility, metadata, etc.
+     *
+     * Can be overridden per-turn by calling `chat.setUIMessageStreamOptions()`
+     * inside `run()` or lifecycle hooks. Per-turn values are merged on top
+     * of these defaults (per-turn wins on conflicts).
+     *
+     * `onFinish`, `originalMessages`, and `generateMessageId` are managed
+     * internally and cannot be overridden here. Use `streamText`'s `onFinish`
+     * for custom finish handling, or drop to raw task mode for full control.
+     *
+     * @example
+     * ```ts
+     * chat.task({
+     *   id: "my-chat",
+     *   uiMessageStreamOptions: {
+     *     sendReasoning: true,
+     *     onError: (error) => error instanceof Error ? error.message : "An error occurred.",
+     *   },
+     *   run: async ({ messages, signal }) => { ... },
+     * });
+     * ```
+     */
+    uiMessageStreamOptions?: ChatUIMessageStreamOptions;
 };
 /**
  * Creates a Trigger.dev task pre-configured for AI SDK chat.
@@ -427,6 +613,259 @@ declare function setTurnTimeoutInSeconds(seconds: number): void;
  * ```
  */
 declare function setWarmTimeoutInSeconds(seconds: number): void;
+/**
+ * Override the `toUIMessageStream()` options for the current turn.
+ *
+ * These options control how the `StreamTextResult` is converted to a
+ * `UIMessageChunk` stream — error handling, reasoning/source visibility,
+ * message metadata, etc.
+ *
+ * Per-turn options are merged on top of the static `uiMessageStreamOptions`
+ * set on `chat.task()`. Per-turn values win on conflicts.
+ *
+ * @example
+ * ```ts
+ * run: async ({ messages, signal }) => {
+ *   chat.setUIMessageStreamOptions({
+ *     sendReasoning: true,
+ *     onError: (error) => error instanceof Error ? error.message : "An error occurred.",
+ *   });
+ *   return streamText({ model, messages, abortSignal: signal });
+ * }
+ * ```
+ */
+declare function setUIMessageStreamOptions(options: ChatUIMessageStreamOptions): void;
+/**
+ * Check whether the user stopped generation during the current turn.
+ *
+ * Works from **anywhere** inside a `chat.task` run — including inside
+ * `streamText`'s `onFinish` callback — without needing to thread the
+ * `stopSignal` through closures.
+ *
+ * This is especially useful when the AI SDK's `isAborted` flag is unreliable
+ * (e.g. when using `createUIMessageStream` + `writer.merge()`).
+ *
+ * @example
+ * ```ts
+ * onFinish: ({ isAborted }) => {
+ *   const wasStopped = isAborted || chat.isStopped();
+ *   if (wasStopped) {
+ *     // handle stop
+ *   }
+ * }
+ * ```
+ */
+declare function isStopped(): boolean;
+/**
+ * Register a promise that runs in the background during the current turn.
+ *
+ * Use this to move non-blocking work (DB writes, analytics, etc.) out of
+ * the critical path. The promise runs in parallel with streaming and is
+ * awaited (with a 5 s timeout) before `onTurnComplete` fires.
+ *
+ * @example
+ * ```ts
+ * onTurnStart: async ({ chatId, uiMessages }) => {
+ *   // Persist messages without blocking the LLM call
+ *   chat.defer(db.chat.update({ where: { id: chatId }, data: { messages: uiMessages } }));
+ * },
+ * ```
+ */
+declare function chatDefer(promise: Promise<unknown>): void;
+/**
+ * Clean up a UIMessage that was captured during an aborted/stopped turn.
+ *
+ * When generation is stopped mid-stream, the captured message may contain:
+ * - Tool parts stuck in incomplete states (`partial-call`, `input-available`,
+ *   `input-streaming`) that cause permanent UI spinners
+ * - Reasoning parts with `state: "streaming"` instead of `"done"`
+ * - Text parts with `state: "streaming"` instead of `"done"`
+ *
+ * This function returns a cleaned copy with:
+ * - Incomplete tool parts removed entirely
+ * - Reasoning and text parts marked as `"done"`
+ *
+ * `chat.task` calls this automatically when stop is detected before passing
+ * the response to `onTurnComplete`. Use this manually when calling `pipeChat`
+ * directly and capturing response messages yourself.
+ *
+ * @example
+ * ```ts
+ * onTurnComplete: async ({ responseMessage, stopped }) => {
+ *   // Already cleaned automatically by chat.task — but if you captured
+ *   // your own message via pipeChat, clean it manually:
+ *   const cleaned = chat.cleanupAbortedParts(myMessage);
+ *   await db.messages.save(cleaned);
+ * }
+ * ```
+ */
+declare function cleanupAbortedParts(message: UIMessage): UIMessage;
+/**
+ * Create a managed stop signal wired to the chat stop input stream.
+ *
+ * Call once at the start of your run. Use `signal` as the abort signal for
+ * `streamText`. Call `reset()` at the start of each turn to get a fresh
+ * per-turn signal. Call `cleanup()` when the run ends.
+ *
+ * @example
+ * ```ts
+ * const stop = chat.createStopSignal();
+ * for (let turn = 0; turn < 100; turn++) {
+ *   stop.reset();
+ *   const result = streamText({ model, messages, abortSignal: stop.signal });
+ *   await chat.pipe(result);
+ *   // ...
+ * }
+ * stop.cleanup();
+ * ```
+ */
+declare function createStopSignal(): {
+    readonly signal: AbortSignal;
+    reset: () => void;
+    cleanup: () => void;
+};
+/**
+ * Signal the frontend that the current turn is complete.
+ *
+ * The `TriggerChatTransport` intercepts this to close the ReadableStream
+ * for the current turn. Call after piping the response stream.
+ *
+ * @example
+ * ```ts
+ * await chat.pipe(result);
+ * await chat.writeTurnComplete();
+ * ```
+ */
+declare function chatWriteTurnComplete(options?: {
+    publicAccessToken?: string;
+}): Promise<void>;
+/**
+ * Pipe a `StreamTextResult` (or similar) to the chat stream and capture
+ * the assistant's response message via `onFinish`.
+ *
+ * Combines `toUIMessageStream()` + `onFinish` callback + `chat.pipe()`.
+ * Returns the captured `UIMessage`, or `undefined` if capture failed.
+ *
+ * @example
+ * ```ts
+ * const result = streamText({ model, messages, abortSignal: signal });
+ * const response = await chat.pipeAndCapture(result, { signal });
+ * if (response) conversation.addResponse(response);
+ * ```
+ */
+declare function pipeChatAndCapture(source: UIMessageStreamable, options?: {
+    signal?: AbortSignal;
+    spanName?: string;
+}): Promise<UIMessage | undefined>;
+/**
+ * Accumulates conversation messages across turns.
+ *
+ * Handles the transport protocol: turn 0 sends full history (replace),
+ * subsequent turns send only new messages (append), regenerate sends
+ * full history minus last assistant message (replace).
+ *
+ * @example
+ * ```ts
+ * const conversation = new chat.MessageAccumulator();
+ * for (let turn = 0; turn < 100; turn++) {
+ *   const messages = await conversation.addIncoming(payload.messages, payload.trigger, turn);
+ *   const result = streamText({ model, messages });
+ *   const response = await chat.pipeAndCapture(result);
+ *   if (response) await conversation.addResponse(response);
+ * }
+ * ```
+ */
+declare class ChatMessageAccumulator {
+    modelMessages: ModelMessage[];
+    uiMessages: UIMessage[];
+    /**
+     * Add incoming messages from the transport payload.
+     * Returns the full accumulated model messages for `streamText`.
+     */
+    addIncoming(messages: UIMessage[], trigger: string, turn: number): Promise<ModelMessage[]>;
+    /**
+     * Add the assistant's response to the accumulator.
+     * Call after `pipeAndCapture` with the captured response.
+     */
+    addResponse(response: UIMessage): Promise<void>;
+}
+export type ChatSessionOptions = {
+    /** Run-level cancel signal (from task context). */
+    signal: AbortSignal;
+    /** Seconds to stay warm between turns before suspending. @default 30 */
+    warmTimeoutInSeconds?: number;
+    /** Duration string for suspend timeout. @default "1h" */
+    timeout?: string;
+    /** Max turns before ending. @default 100 */
+    maxTurns?: number;
+};
+export type ChatTurn = {
+    /** Turn number (0-indexed). */
+    number: number;
+    /** Chat session ID. */
+    chatId: string;
+    /** What triggered this turn. */
+    trigger: string;
+    /** Client data from the transport (`metadata` field on the wire payload). */
+    clientData: unknown;
+    /** Full accumulated model messages — pass directly to `streamText`. */
+    messages: ModelMessage[];
+    /** Full accumulated UI messages — use for persistence. */
+    uiMessages: UIMessage[];
+    /** Combined stop+cancel AbortSignal (fresh each turn). */
+    signal: AbortSignal;
+    /** Whether the user stopped generation this turn. */
+    readonly stopped: boolean;
+    /** Whether this is a continuation run. */
+    continuation: boolean;
+    /**
+     * Easy path: pipe stream, capture response, accumulate it,
+     * clean up aborted parts if stopped, and write turn-complete chunk.
+     */
+    complete(source: UIMessageStreamable): Promise<UIMessage | undefined>;
+    /**
+     * Manual path: just write turn-complete chunk.
+     * Use when you've already piped and accumulated manually.
+     */
+    done(): Promise<void>;
+    /**
+     * Add the response to the accumulator manually.
+     * Use with `chat.pipeAndCapture` when you need control between pipe and done.
+     */
+    addResponse(response: UIMessage): Promise<void>;
+};
+/**
+ * Create a chat session that yields turns as an async iterator.
+ *
+ * Handles: preload wait, stop signals, message accumulation, turn-complete
+ * signaling, and warm/suspend between turns. You control: initialization,
+ * model/tool selection, persistence, and any custom per-turn logic.
+ *
+ * @example
+ * ```ts
+ * import { task } from "@trigger.dev/sdk";
+ * import { chat, type ChatTaskWirePayload } from "@trigger.dev/sdk/ai";
+ * import { streamText } from "ai";
+ * import { openai } from "@ai-sdk/openai";
+ *
+ * export const myChat = task({
+ *   id: "my-chat",
+ *   run: async (payload: ChatTaskWirePayload, { signal }) => {
+ *     const session = chat.createSession(payload, { signal });
+ *
+ *     for await (const turn of session) {
+ *       const result = streamText({
+ *         model: openai("gpt-4o"),
+ *         messages: turn.messages,
+ *         abortSignal: turn.signal,
+ *       });
+ *       await turn.complete(result);
+ *     }
+ *   },
+ * });
+ * ```
+ */
+declare function createChatSession(payload: ChatTaskWirePayload, options: ChatSessionOptions): AsyncIterable<ChatTurn>;
 /**
  * A Proxy-backed, run-scoped data object that appears as `T` to users.
  * Includes helper methods for initialization, dirty tracking, and serialization.
@@ -451,12 +890,16 @@ export type ChatLocal<T extends Record<string, unknown>> = T & {
  *
  * Multiple locals can coexist — each gets its own isolated run-scoped storage.
  *
+ * The `id` is required and must be unique across all `chat.local()` calls in
+ * your project. It's used to serialize values into subtask metadata so that
+ * `ai.tool()` subtasks can auto-hydrate parent locals (read-only).
+ *
  * @example
  * ```ts
  * import { chat } from "@trigger.dev/sdk/ai";
  *
- * const userPrefs = chat.local<{ theme: string; language: string }>();
- * const gameState = chat.local<{ score: number; streak: number }>();
+ * const userPrefs = chat.local<{ theme: string; language: string }>({ id: "userPrefs" });
+ * const gameState = chat.local<{ score: number; streak: number }>({ id: "gameState" });
  *
  * export const myChat = chat.task({
  *   id: "my-chat",
@@ -480,7 +923,9 @@ export type ChatLocal<T extends Record<string, unknown>> = T & {
  * });
  * ```
  */
-declare function chatLocal<T extends Record<string, unknown>>(): ChatLocal<T>;
+declare function chatLocal<T extends Record<string, unknown>>(options: {
+    id: string;
+}): ChatLocal<T>;
 /**
  * Extracts the client data (metadata) type from a chat task.
  * Use this to type the `metadata` option on the transport.
@@ -510,4 +955,26 @@ export declare const chat: {
     setTurnTimeoutInSeconds: typeof setTurnTimeoutInSeconds;
     /** Override the warm timeout at runtime. See {@link setWarmTimeoutInSeconds}. */
     setWarmTimeoutInSeconds: typeof setWarmTimeoutInSeconds;
+    /** Override toUIMessageStream() options for the current turn. See {@link setUIMessageStreamOptions}. */
+    setUIMessageStreamOptions: typeof setUIMessageStreamOptions;
+    /** Check if the current turn was stopped by the user. See {@link isStopped}. */
+    isStopped: typeof isStopped;
+    /** Clean up aborted parts from a UIMessage. See {@link cleanupAbortedParts}. */
+    cleanupAbortedParts: typeof cleanupAbortedParts;
+    /** Register background work that runs in parallel with streaming. See {@link chatDefer}. */
+    defer: typeof chatDefer;
+    /** Typed chat output stream for writing custom chunks or piping from subtasks. */
+    stream: import("@trigger.dev/core/v3").RealtimeDefinedStream<UIMessageChunk>;
+    /** Pre-built input stream for receiving messages from the transport. */
+    messages: import("@trigger.dev/core/v3").RealtimeDefinedInputStream<ChatTaskWirePayload<UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>, unknown>>;
+    /** Create a managed stop signal wired to the stop input stream. See {@link createStopSignal}. */
+    createStopSignal: typeof createStopSignal;
+    /** Signal the frontend that the current turn is complete. See {@link chatWriteTurnComplete}. */
+    writeTurnComplete: typeof chatWriteTurnComplete;
+    /** Pipe a stream and capture the response message. See {@link pipeChatAndCapture}. */
+    pipeAndCapture: typeof pipeChatAndCapture;
+    /** Message accumulator class for raw task chat. See {@link ChatMessageAccumulator}. */
+    MessageAccumulator: typeof ChatMessageAccumulator;
+    /** Create a chat session (async iterator). See {@link createChatSession}. */
+    createSession: typeof createChatSession;
 };