@trigger.dev/sdk 0.0.0-prerelease-20260327224514 → 0.0.0-prerelease-20260331093145

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

@@ -1,27 +1,6 @@
-import { AnyTask, Task, type inferSchemaIn, type inferSchemaOut, type TaskIdentifier, type TaskOptions, type TaskSchema, type TaskRunContext, type TaskWithSchema } from "@trigger.dev/core/v3";
-import type { ModelMessage, ToolSet, UIMessage, UIMessageChunk, UIMessageStreamOptions, LanguageModelUsage } from "ai";
+import { Task, type inferSchemaIn, type TaskSchema, type TaskWithSchema } from "@trigger.dev/core/v3";
 import { Tool, ToolCallOptions } from "ai";
-import { locals } from "./locals.js";
-import type { ResolvedPrompt } from "./prompt.js";
-/** Re-export for typing `ctx` in `chat.task` hooks without importing `@trigger.dev/core`. */
-export type { TaskRunContext } from "@trigger.dev/core/v3";
-import { CHAT_MESSAGES_STREAM_ID, CHAT_STOP_STREAM_ID } from "./chat-constants.js";
-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;
-};
+export type ToolCallExecutionOptions = Omit<ToolCallOptions, "abortSignal">;
 type ToolResultContent = Array<{
     type: "text";
     text: string;
@@ -33,1783 +12,11 @@ type ToolResultContent = Array<{
 export type ToolOptions<TResult> = {
     experimental_toToolResultContent?: (result: TResult) => ToolResultContent;
 };
-/** Satisfies AI SDK `ToolSet` index signature alongside concrete `Tool` input/output types. */
-type ToolSetCompatible<T extends Tool<any, any>> = T & NonNullable<ToolSet[string]>;
-/**
- * Returns an `execute` function for the AI SDK `tool()` helper (or any compatible tool definition).
- * Preferred API for task-backed tools: the same Trigger wiring as the deprecated `ai.tool()`
- * (`triggerAndSubscribe`, tool-call metadata, chat context, `chat.local` serialization) without
- * building the tool object. You supply `description`, `inputSchema`, and any AI-SDK-only options
- * (e.g. `experimental_toToolResultContent`) on `tool()` yourself.
- *
- * @example
- * ```ts
- * import { tool } from "ai";
- * import { z } from "zod";
- * import { ai } from "@trigger.dev/sdk/ai";
- * import { myTask } from "./trigger/myTask";
- *
- * export const myTool = tool({
- *   description: myTask.description ?? "",
- *   inputSchema: z.object({ id: z.string() }),
- *   execute: ai.toolExecute(myTask),
- * });
- * ```
- */
-declare function toolExecute<TIdentifier extends string, TInput = void, TOutput = unknown>(task: Task<TIdentifier, TInput, TOutput>): (input: TInput, toolOpts: ToolCallOptions) => Promise<TOutput>;
-declare function toolExecute<TIdentifier extends string, TTaskSchema extends TaskSchema | undefined = undefined, TOutput = unknown>(task: TaskWithSchema<TIdentifier, TTaskSchema, TOutput>): (input: inferSchemaIn<TTaskSchema>, toolOpts: ToolCallOptions) => Promise<TOutput>;
-/**
- * @deprecated Use `tool()` from the `ai` package with `execute: ai.toolExecute(task)` instead.
- * This helper may be removed in a future major release.
- */
-declare function toolFromTask<TIdentifier extends string, TInput = void, TOutput = unknown>(task: Task<TIdentifier, TInput, TOutput>, options?: ToolOptions<TOutput>): ToolSetCompatible<Tool<TInput, TOutput>>;
-/** @deprecated Use `tool()` from `ai` with `execute: ai.toolExecute(task)`. */
-declare function toolFromTask<TIdentifier extends string, TTaskSchema extends TaskSchema | undefined = undefined, TOutput = unknown>(task: TaskWithSchema<TIdentifier, TTaskSchema, TOutput>, options?: ToolOptions<TOutput>): ToolSetCompatible<Tool<inferSchemaIn<TTaskSchema>, TOutput>>;
+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.toolExecute()` (or legacy `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.toolExecute()` (or legacy `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: {
-    /**
-     * @deprecated Use `tool()` from the `ai` package with `execute: ai.toolExecute(task)` instead.
-     */
     tool: typeof toolFromTask;
-    /**
-     * Preferred: return value for the `execute` field of AI SDK `tool()`. Keeps Trigger subtask and
-     * metadata behavior without coupling to a specific `ai` version’s `Tool` / `ToolSet` types.
-     */
-    toolExecute: typeof toolExecute;
     currentToolOptions: typeof getToolOptionsFromMetadata;
-    /** Get the tool call ID from inside a subtask invoked via `ai.toolExecute()` (or legacy `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.
- *
- * This is a convenience helper that creates a multi-use trigger public token
- * scoped to the given task. Use it in a server action to provide the frontend
- * `TriggerChatTransport` with an `accessToken`.
- *
- * @example
- * ```ts
- * // actions.ts
- * "use server";
- * import { chat } from "@trigger.dev/sdk/ai";
- * import type { myChat } from "@/trigger/chat";
- *
- * export const getChatToken = () => chat.createAccessToken<typeof myChat>("my-chat");
- * ```
- */
-declare function createChatAccessToken<TTask extends AnyTask>(taskId: TaskIdentifier<TTask>): Promise<string>;
-/**
- * The default stream key used for chat transport communication.
- * Both `TriggerChatTransport` (frontend) and `pipeChat`/`chatTask` (backend)
- * use this key by default.
- */
-export declare const CHAT_STREAM_KEY = "chat";
-export { CHAT_MESSAGES_STREAM_ID, CHAT_STOP_STREAM_ID };
-/**
- * A stream writer passed to chat lifecycle callbacks (`onPreload`, `onChatStart`,
- * `onTurnStart`, `onTurnComplete`, `onCompacted`).
- *
- * Write custom `UIMessageChunk` parts (e.g. `data-*` parts) directly to the chat
- * stream without the ceremony of `chat.stream.writer({ execute })`.
- *
- * The writer is lazy — no stream overhead if you don't call `write()` or `merge()`.
- *
- * @example
- * ```ts
- * onTurnStart: async ({ writer }) => {
- *   writer.write({ type: "data-status", data: { loading: true } });
- * },
- * onTurnComplete: async ({ writer, uiMessages }) => {
- *   writer.write({ type: "data-analytics", data: { messageCount: uiMessages.length } });
- * },
- * ```
- */
-export type ChatWriter = {
-    /** Write a single UIMessageChunk to the chat stream. */
-    write(part: UIMessageChunk): void;
-    /** Merge another stream's chunks into the chat stream. */
-    merge(stream: ReadableStream<UIMessageChunk>): void;
-};
-/**
- * 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 idle timeout for this run (seconds). Set by transport.preload(). */
-    idleTimeoutInSeconds?: number;
-};
-/**
- * The payload shape passed to the `chatTask` run function.
- *
- * - `messages` contains model-ready messages (converted via `convertToModelMessages`) —
- *   pass these directly to `streamText`.
- * - `clientData` contains custom data from the frontend (the `metadata` field from `sendMessage()`).
- *
- * The backend accumulates the full conversation history across turns, so the frontend
- * only needs to send new messages after the first turn.
- */
-export type ChatTaskPayload<TClientData = unknown> = {
-    /** Model-ready messages — pass directly to `streamText({ messages })`. */
-    messages: ModelMessage[];
-    /** The unique identifier for the chat session */
-    chatId: string;
-    /**
-     * 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" | "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.
- */
-export type ChatTaskSignals = {
-    /** Combined signal — fires on run cancel OR stop generation. Pass to `streamText`. */
-    signal: AbortSignal;
-    /** Fires only when the run is cancelled, expired, or exceeds maxDuration. */
-    cancelSignal: AbortSignal;
-    /** Fires only when the frontend stops generation for this turn (per-turn, reset each turn). */
-    stopSignal: AbortSignal;
-};
-/**
- * The full payload passed to a `chatTask` run function.
- * Extends `ChatTaskPayload` (the wire payload) with abort signals.
- */
-export type ChatTaskRunPayload<TClientData = unknown> = ChatTaskPayload<TClientData> & ChatTaskSignals & {
-    /**
-     * Task run context — same object as the `ctx` passed to a standard `task({ run })` handler’s second argument.
-     * Use for tags, metadata, parent run links, or any API that needs the full run record.
-     */
-    ctx: TaskRunContext;
-    /** Token usage from the previous turn. Undefined on turn 0. */
-    previousTurnUsage?: LanguageModelUsage;
-    /** Cumulative token usage across all completed turns so far. */
-    totalUsage: LanguageModelUsage;
-};
-/** Convenience re-export of the AI SDK's `LanguageModelUsage` type. */
-export type ChatTurnUsage = LanguageModelUsage;
-/**
- * Replace the accumulated conversation messages for the current run.
- *
- * Call from `onTurnStart` to compact before `run()` executes, or from
- * `onTurnComplete` to compact before the next turn. Takes `UIMessage[]`
- * and converts to `ModelMessage[]` internally.
- */
-declare function setChatMessages<TUIM extends UIMessage = UIMessage>(uiMessages: TUIM[]): void;
-/** State stored in locals during prepareStep compaction. */
-interface CompactionState {
-    summary: string;
-    baseResponseMessageCount: number;
-}
-/**
- * Event passed to `summarize` callbacks.
- */
-export type SummarizeEvent = {
-    /** The current model messages to summarize. */
-    messages: ModelMessage[];
-    /** Full usage object from the triggering step/turn. */
-    usage?: LanguageModelUsage;
-    /** Cumulative token usage across all completed turns. Present in chat.task contexts. */
-    totalUsage?: LanguageModelUsage;
-    /** The chat session ID (if running inside a chat.task). */
-    chatId?: string;
-    /** The current turn number (0-indexed, if inside a chat.task). */
-    turn?: number;
-    /** Custom data from the frontend (if inside a chat.task). */
-    clientData?: unknown;
-    /**
-     * Where compaction is running:
-     * - `"inner"` — between tool-call steps (prepareStep)
-     * - `"outer"` — between turns
-     */
-    source?: "inner" | "outer";
-    /** The step number (0-indexed). Only present when `source` is `"inner"`. */
-    stepNumber?: number;
-};
-/**
- * Event passed to `compactUIMessages` and `compactModelMessages` callbacks.
- */
-export type CompactMessagesEvent<TUIM extends UIMessage = UIMessage> = {
-    /** The generated summary text. */
-    summary: string;
-    /** The current UI messages (full conversation). */
-    uiMessages: TUIM[];
-    /** The current model messages (full conversation). */
-    modelMessages: ModelMessage[];
-    /** The chat session ID. */
-    chatId: string;
-    /** The current turn number (0-indexed). */
-    turn: number;
-    /** Custom data from the frontend. */
-    clientData?: unknown;
-    /**
-     * Where compaction is running:
-     * - `"inner"` — between tool-call steps (prepareStep)
-     * - `"outer"` — between turns
-     */
-    source: "inner" | "outer";
-};
-/**
- * Options for the `compaction` field on `chat.task()`.
- *
- * Handles compaction automatically in both the inner loop (prepareStep, between
- * tool-call steps) and the outer loop (between turns, for single-step responses
- * where prepareStep never fires).
- */
-export type ChatTaskCompactionOptions<TUIM extends UIMessage = UIMessage> = {
-    /** Decide whether to compact. Return true to trigger compaction. */
-    shouldCompact: (event: ShouldCompactEvent) => boolean | Promise<boolean>;
-    /** Generate a summary from the current messages. Return the summary text. */
-    summarize: (event: SummarizeEvent) => Promise<string>;
-    /**
-     * Transform UI messages after compaction (what gets persisted and displayed).
-     * Default: preserve all UI messages unchanged.
-     *
-     * @example
-     * ```ts
-     * // Flatten to summary
-     * compactUIMessages: ({ summary }) => [{
-     *   id: generateId(), role: "assistant",
-     *   parts: [{ type: "text", text: `[Summary]\n\n${summary}` }],
-     * }],
-     *
-     * // Summary + keep last 4 messages
-     * compactUIMessages: ({ uiMessages, summary }) => [
-     *   { id: generateId(), role: "assistant",
-     *     parts: [{ type: "text", text: `[Summary]\n\n${summary}` }] },
-     *   ...uiMessages.slice(-4),
-     * ],
-     * ```
-     */
-    compactUIMessages?: (event: CompactMessagesEvent<TUIM>) => TUIM[] | Promise<TUIM[]>;
-    /**
-     * Transform model messages after compaction (what gets sent to the LLM).
-     * Default: replace all with a single summary message.
-     *
-     * @example
-     * ```ts
-     * // Summary + keep last 2 model messages
-     * compactModelMessages: ({ modelMessages, summary }) => [
-     *   { role: "user", content: summary },
-     *   ...modelMessages.slice(-2),
-     * ],
-     * ```
-     */
-    compactModelMessages?: (event: CompactMessagesEvent<TUIM>) => ModelMessage[] | Promise<ModelMessage[]>;
-};
-/**
- * Event passed to `shouldInject` and `prepareMessages` callbacks.
- */
-export type PendingMessagesBatchEvent<TUIM extends UIMessage = UIMessage> = {
-    /** All pending UI messages that arrived during streaming (batch). */
-    messages: TUIM[];
-    /** Current model messages in the conversation. */
-    modelMessages: ModelMessage[];
-    /** Completed steps so far. */
-    steps: CompactionStep[];
-    /** Current step number (0-indexed). */
-    stepNumber: number;
-    /** Chat session ID. */
-    chatId: string;
-    /** Current turn number (0-indexed). */
-    turn: number;
-    /** Custom data from the frontend. */
-    clientData?: unknown;
-};
-/**
- * Event passed to `onReceived` callback (per-message, as they arrive).
- */
-export type PendingMessageReceivedEvent<TUIM extends UIMessage = UIMessage> = {
-    /** The UI message that arrived during streaming. */
-    message: TUIM;
-    /** Chat session ID. */
-    chatId: string;
-    /** Current turn number (0-indexed). */
-    turn: number;
-};
-/**
- * Event passed to `onInjected` callback (batch, after injection).
- */
-export type PendingMessagesInjectedEvent<TUIM extends UIMessage = UIMessage> = {
-    /** All UI messages that were injected. */
-    messages: TUIM[];
-    /** The model messages that were injected. */
-    injectedModelMessages: ModelMessage[];
-    /** Chat session ID. */
-    chatId: string;
-    /** Current turn number (0-indexed). */
-    turn: number;
-    /** Step number where injection occurred. */
-    stepNumber: number;
-};
-/**
- * Options for the `pendingMessages` field on `chat.task()`, `chat.createSession()`,
- * or `ChatMessageAccumulator`.
- *
- * Configures how messages that arrive during streaming are handled. When
- * `shouldInject` is provided and returns `true`, the full batch of pending
- * messages is injected between tool-call steps via `prepareStep`.
- * Otherwise, messages queue for the next turn.
- */
-export type PendingMessagesOptions<TUIM extends UIMessage = UIMessage> = {
-    /**
-     * Decide whether to inject pending messages between tool-call steps.
-     * Called once per step boundary with the full batch of pending messages.
-     * If absent, no injection happens — messages only queue for the next turn.
-     */
-    shouldInject?: (event: PendingMessagesBatchEvent<TUIM>) => boolean | Promise<boolean>;
-    /**
-     * Transform the batch of pending messages before injection.
-     * Return the model messages to inject.
-     * Default: convert each UI message via `convertToModelMessages`.
-     */
-    prepare?: (event: PendingMessagesBatchEvent<TUIM>) => ModelMessage[] | Promise<ModelMessage[]>;
-    /** Called when a message arrives during streaming (per-message). */
-    onReceived?: (event: PendingMessageReceivedEvent<TUIM>) => void | Promise<void>;
-    /** Called after a batch of messages is injected via `prepareStep`. */
-    onInjected?: (event: PendingMessagesInjectedEvent<TUIM>) => void | Promise<void>;
-};
-/**
- * The data part type used to signal that pending messages were injected
- * between tool-call steps. The frontend can match on this to render
- * injection points inline in the assistant response.
- */
-export declare const PENDING_MESSAGE_INJECTED_TYPE: "data-pending-message-injected";
-/**
- * Event passed to the `prepareMessages` hook.
- */
-export type PrepareMessagesEvent<TClientData = unknown> = {
-    /** The messages to transform. Return the transformed array. */
-    messages: ModelMessage[];
-    /** Why messages are being prepared. */
-    reason: "run" | "compaction-rebuild" | "compaction-result";
-    /** The chat session ID. */
-    chatId: string;
-    /** The current turn number (0-indexed). */
-    turn: number;
-    /** Custom data from the frontend. */
-    clientData?: TClientData;
-};
-/**
- * Data shape for `data-compaction` stream chunks emitted during compaction.
- * Use to type the `data` field when rendering compaction parts in the frontend.
- */
-export type CompactionChunkData = {
-    status: "compacting" | "complete";
-    totalTokens: number | undefined;
-};
-/**
- * Event passed to the `onCompacted` callback.
- */
-export type CompactedEvent = {
-    /** Task run context — same as `task` lifecycle hooks and `chat.task` `run({ ctx })`. */
-    ctx: TaskRunContext;
-    /** The generated summary text. */
-    summary: string;
-    /** The messages that were compacted (pre-compaction). */
-    messages: ModelMessage[];
-    /** Number of messages before compaction. */
-    messageCount: number;
-    /** Token usage from the step that triggered compaction. */
-    usage: LanguageModelUsage;
-    /** Total token count that triggered compaction. */
-    totalTokens: number | undefined;
-    /** Input token count from the triggering step. */
-    inputTokens: number | undefined;
-    /** Output token count from the triggering step. */
-    outputTokens: number | undefined;
-    /** The step number where compaction occurred (0-indexed). */
-    stepNumber: number;
-    /** The chat session ID (if running inside a chat.task). */
-    chatId?: string;
-    /** The current turn number (if running inside a chat.task). */
-    turn?: number;
-    /** Stream writer — write custom `UIMessageChunk` parts to the chat stream. Lazy: no overhead if unused. */
-    writer: ChatWriter;
-};
-/**
- * Event passed to `shouldCompact` callbacks.
- */
-export type ShouldCompactEvent = {
-    /** The current model messages (full conversation). */
-    messages: ModelMessage[];
-    /** Total token count from the triggering step/turn. */
-    totalTokens: number | undefined;
-    /** Input token count from the triggering step/turn. */
-    inputTokens: number | undefined;
-    /** Output token count from the triggering step/turn. */
-    outputTokens: number | undefined;
-    /** Full usage object from the triggering step/turn. */
-    usage?: LanguageModelUsage;
-    /** Cumulative token usage across all completed turns. Present in chat.task contexts. */
-    totalUsage?: LanguageModelUsage;
-    /** The chat session ID (if running inside a chat.task). */
-    chatId?: string;
-    /** The current turn number (0-indexed, if inside a chat.task). */
-    turn?: number;
-    /** Custom data from the frontend (if inside a chat.task). */
-    clientData?: unknown;
-    /**
-     * Where this check is running:
-     * - `"inner"` — between tool-call steps (prepareStep)
-     * - `"outer"` — between turns (after response, before onBeforeTurnComplete)
-     */
-    source?: "inner" | "outer";
-    /** The step number (0-indexed). Only present when `source` is `"inner"`. */
-    stepNumber?: number;
-    /** The steps array from prepareStep. Only present when `source` is `"inner"`. */
-    steps?: CompactionStep[];
-};
-/**
- * Options for `chat.compaction()` — the high-level prepareStep factory.
- */
-export type CompactionOptions = {
-    /** Generate a summary from the current messages. Return the summary text. */
-    summarize: (messages: ModelMessage[]) => Promise<string>;
-    /** Token threshold — compact when totalTokens exceeds this. Ignored if `shouldCompact` is provided. */
-    threshold?: number;
-    /** Custom compaction trigger. When provided, used instead of `threshold`. */
-    shouldCompact?: (event: ShouldCompactEvent) => boolean | Promise<boolean>;
-};
-/** A step object as received in prepareStep's `steps` array. */
-export type CompactionStep = {
-    usage: LanguageModelUsage;
-    finishReason: string;
-    content: Array<{
-        type: string;
-        toolCallId?: string;
-    }>;
-    response: {
-        messages: Array<any>;
-    };
-};
-/**
- * Result of `chat.compact()`. Discriminated union so you can inspect
- * what happened, but also directly compatible with prepareStep's return type.
- *
- * - `"skipped"` — no compaction needed (first step, boundary unsafe, or under threshold). Return `undefined` to prepareStep.
- * - `"rebuilt"` — previous compaction exists, messages rebuilt from summary + new response messages.
- * - `"compacted"` — compaction just happened, includes the generated summary.
- */
-export type CompactResult = {
-    type: "skipped";
-} | {
-    type: "rebuilt";
-    messages: ModelMessage[];
-} | {
-    type: "compacted";
-    messages: ModelMessage[];
-    summary: string;
-};
-/**
- * Options for `chat.compact()` — the low-level compaction function.
- */
-export type CompactOptions = {
-    /** Generate a summary from the current messages. Return the summary text. */
-    summarize: (messages: ModelMessage[]) => Promise<string>;
-    /** Token threshold — compact when totalTokens exceeds this. Ignored if `shouldCompact` is provided. */
-    threshold?: number;
-    /** Custom compaction trigger. When provided, used instead of `threshold`. */
-    shouldCompact?: (event: ShouldCompactEvent) => boolean | Promise<boolean>;
-};
-/**
- * Read the current compaction state. Returns the summary and base message count
- * if compaction has occurred in this turn, or `undefined` if not.
- *
- * Use in a custom `prepareStep` to rebuild from a previous compaction:
- * ```ts
- * const state = chat.getCompactionState();
- * if (state) {
- *   return { messages: [{ role: "user", content: state.summary }, ...newMsgs] };
- * }
- * ```
- */
-declare function getCompactionState(): CompactionState | undefined;
-/**
- * Low-level compaction for use inside a custom `prepareStep`.
- *
- * Handles the full decision tree: first step, already-compacted rebuild,
- * boundary safety, threshold check, summarization, stream chunks, state
- * storage, and accumulator update.
- *
- * Returns a `CompactResult` — inspect `result.type` to see what happened,
- * or convert to a prepareStep return with `result.type === "skipped" ? undefined : result`.
- *
- * @example
- * ```ts
- * prepareStep: async ({ messages, steps }) => {
- *   // your custom logic here...
- *   const result = await chat.compact(messages, steps, {
- *     threshold: 80_000,
- *     summarize: async (msgs) => generateText({ model, messages: msgs }).then(r => r.text),
- *   });
- *   if (result.type === "compacted") {
- *     logger.info("Compacted!", { summary: result.summary });
- *   }
- *   return result.type === "skipped" ? undefined : result;
- * },
- * ```
- */
-declare function chatCompact(messages: ModelMessage[], steps: CompactionStep[], options: CompactOptions): Promise<CompactResult>;
-/**
- * Returns a `prepareStep` function that handles context compaction automatically.
- *
- * Monitors token usage between tool-call steps. When `totalTokens` exceeds
- * the threshold, generates a summary via `summarize()`, replaces the message
- * history, and emits `data-compaction` stream chunks for the frontend.
- *
- * @example
- * ```ts
- * return streamText({
- *   ...chat.toStreamTextOptions({ registry }),
- *   messages: chat.addCacheBreaks(messages),
- *   prepareStep: chat.compactionStep({
- *     threshold: 80_000,
- *     summarize: async (messages) => {
- *       return generateText({ model, messages: [...messages, { role: "user", content: "Summarize." }] })
- *         .then((r) => r.text);
- *     },
- *   }),
- *   tools: { ... },
- * });
- * ```
- */
-declare function chatCompactionStep(options: CompactionOptions): (args: {
-    messages: ModelMessage[];
-    steps: CompactionStep[];
-}) => Promise<{
-    messages: ModelMessage[];
-} | undefined>;
-/**
- * Checks whether it's safe to compact the message history. Returns `false`
- * if any tool calls are in-flight (incomplete tool invocations without results).
- *
- * Call before `chat.setMessages()` to avoid corrupting tool-call state.
- */
-declare function isCompactionSafe(messages: UIMessage[]): boolean;
-/**
- * A resolved prompt stored via `chat.prompt.set()`. Either a full `ResolvedPrompt`
- * from `prompts.define().resolve()`, or a lightweight wrapper around a plain string.
- */
-export type ChatPromptValue = ResolvedPrompt | {
-    text: string;
-    model: undefined;
-    config: undefined;
-    promptId: string;
-    version: number;
-    labels: string[];
-    toAISDKTelemetry: (additionalMetadata?: Record<string, string>) => {
-        experimental_telemetry: {
-            isEnabled: true;
-            metadata: Record<string, string>;
-        };
-    };
-};
-/**
- * Store a resolved prompt (or plain string) for the current run.
- * Call from any hook (`onPreload`, `onChatStart`, `onTurnStart`) or `run()`.
- */
-declare function setChatPrompt(resolved: ResolvedPrompt | string): void;
-/**
- * Read the stored prompt. Throws if `chat.prompt.set()` has not been called.
- */
-declare function getChatPrompt(): ChatPromptValue;
-/**
- * Options for {@link toStreamTextOptions}.
- */
-export type ToStreamTextOptionsOptions = {
-    /** Additional telemetry metadata merged into `experimental_telemetry.metadata`. */
-    telemetry?: Record<string, string>;
-    /**
-     * An AI SDK provider registry (from `createProviderRegistry`) or any object
-     * with a `languageModel(id)` method. When provided and the stored prompt has
-     * a `model` string, the resolved `LanguageModel` is included in the returned
-     * options so `streamText` uses it directly.
-     *
-     * The model string should use the `"provider:model-id"` format
-     * (e.g. `"openai:gpt-4o"`, `"anthropic:claude-sonnet-4-6"`).
-     */
-    registry?: {
-        languageModel(modelId: string): unknown;
-    };
-};
-/**
- * Returns an options object ready to spread into `streamText()`.
- *
- * Includes `system`, `experimental_telemetry`, and any config fields
- * (temperature, maxTokens, etc.) from the stored prompt.
- *
- * When a `registry` is provided and the prompt has a `model` string,
- * the resolved `LanguageModel` is included as `model`.
- *
- * If no prompt has been set, returns `{}` (no-op spread).
- */
-declare function toStreamTextOptions(options?: ToStreamTextOptionsOptions): Record<string, unknown>;
-/**
- * Options for `pipeChat`.
- */
-export type PipeChatOptions = {
-    /**
-     * Override the stream key. Must match the `streamKey` on `TriggerChatTransport`.
-     * @default "chat"
-     */
-    streamKey?: string;
-    /** An AbortSignal to cancel the stream. */
-    signal?: AbortSignal;
-    /**
-     * The target run ID to pipe to.
-     * @default "self" (current run)
-     */
-    target?: string;
-    /** 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<TUIM extends UIMessage = UIMessage> = Omit<UIMessageStreamOptions<TUIM>, "onFinish" | "originalMessages" | "generateMessageId">;
-/**
- * An object with a `toUIMessageStream()` method (e.g. `StreamTextResult` from `streamText()`).
- */
-type UIMessageStreamable = {
-    toUIMessageStream: (...args: any[]) => AsyncIterable<unknown> | ReadableStream<unknown>;
-};
-/**
- * Pipes a chat stream to the realtime stream, making it available to the
- * `TriggerChatTransport` on the frontend.
- *
- * Accepts:
- * - A `StreamTextResult` from `streamText()` (has `.toUIMessageStream()`)
- * - An `AsyncIterable` of `UIMessageChunk`s
- * - A `ReadableStream` of `UIMessageChunk`s
- *
- * Must be called from inside a Trigger.dev task's `run` function.
- *
- * @example
- * ```ts
- * import { task } from "@trigger.dev/sdk";
- * import { chat, type ChatTaskPayload } from "@trigger.dev/sdk/ai";
- * import { streamText, convertToModelMessages } from "ai";
- *
- * export const myChatTask = task({
- *   id: "my-chat-task",
- *   run: async (payload: ChatTaskPayload) => {
- *     const result = streamText({
- *       model: openai("gpt-4o"),
- *       messages: payload.messages,
- *     });
- *
- *     await chat.pipe(result);
- *   },
- * });
- * ```
- *
- * @example
- * ```ts
- * // Works from anywhere inside a task — even deep in your agent code
- * async function runAgentLoop(messages: CoreMessage[]) {
- *   const result = streamText({ model, messages });
- *   await chat.pipe(result);
- * }
- * ```
- */
-declare function pipeChat(source: UIMessageStreamable | AsyncIterable<unknown> | ReadableStream<unknown>, options?: PipeChatOptions): Promise<void>;
-/**
- * Options for defining a chat task.
- *
- * Extends the standard `TaskOptions` but pre-types the payload as `ChatTaskPayload`
- * and overrides `run` to accept `ChatTaskRunPayload` (with abort signals).
- *
- * **Auto-piping:** If the `run` function returns a value with `.toUIMessageStream()`
- * (like a `StreamTextResult`), the stream is automatically piped to the frontend.
- *
- * **Single-run mode:** By default, the task uses input streams so that the
- * entire conversation lives inside one run. After each AI response, the task
- * 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> = {
-    /** Task run context — same as `task({ run })` second-argument `ctx`. */
-    ctx: TaskRunContext;
-    /** 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;
-    /** Stream writer — write custom `UIMessageChunk` parts to the chat stream. Lazy: no overhead if unused. */
-    writer: ChatWriter;
-};
-/**
- * Event passed to the `onChatStart` callback.
- */
-export type ChatStartEvent<TClientData = unknown> = {
-    /** Task run context — same as `task({ run })` second-argument `ctx`. */
-    ctx: TaskRunContext;
-    /** The unique identifier for the chat session. */
-    chatId: string;
-    /** The initial model-ready messages for this conversation. */
-    messages: ModelMessage[];
-    /** Custom data from the frontend (passed via `metadata` on `sendMessage()` or the transport). */
-    clientData: TClientData;
-    /** The Trigger.dev run ID for this conversation. */
-    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;
-    /** Stream writer — write custom `UIMessageChunk` parts to the chat stream. Lazy: no overhead if unused. */
-    writer: ChatWriter;
-};
-/**
- * Event passed to the `onTurnStart` callback.
- */
-export type TurnStartEvent<TClientData = unknown, TUIM extends UIMessage = UIMessage> = {
-    /** Task run context — same as `task({ run })` second-argument `ctx`. */
-    ctx: TaskRunContext;
-    /** The unique identifier for the chat session. */
-    chatId: string;
-    /** The accumulated model-ready messages (all turns so far, including new user message). */
-    messages: ModelMessage[];
-    /** The accumulated UI messages (all turns so far, including new user message). */
-    uiMessages: TUIM[];
-    /** The turn number (0-indexed). */
-    turn: number;
-    /** 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;
-    /** 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;
-    /** Token usage from the previous turn. Undefined on turn 0. */
-    previousTurnUsage?: LanguageModelUsage;
-    /** Cumulative token usage across all completed turns so far. */
-    totalUsage: LanguageModelUsage;
-    /** Stream writer — write custom `UIMessageChunk` parts to the chat stream. Lazy: no overhead if unused. */
-    writer: ChatWriter;
-};
-/**
- * Event passed to the `onTurnComplete` callback.
- */
-export type TurnCompleteEvent<TClientData = unknown, TUIM extends UIMessage = UIMessage> = {
-    /** Task run context — same as `task({ run })` second-argument `ctx`. */
-    ctx: TaskRunContext;
-    /** The unique identifier for the chat session. */
-    chatId: string;
-    /** The full accumulated conversation in model format (all turns so far). */
-    messages: ModelMessage[];
-    /**
-     * The full accumulated conversation in UI format (all turns so far).
-     * This is the format expected by `useChat` — store this for persistence.
-     */
-    uiMessages: TUIM[];
-    /**
-     * Only the new model messages from this turn (user message(s) + assistant response).
-     * Useful for appending to an existing conversation record.
-     */
-    newMessages: ModelMessage[];
-    /**
-     * Only the new UI messages from this turn (user message(s) + assistant response).
-     * Useful for inserting individual message records instead of overwriting the full history.
-     */
-    newUIMessages: TUIM[];
-    /** The assistant's response for this turn, with aborted parts cleaned up when `stopped` is true. Undefined if `pipeChat` was used manually. */
-    responseMessage: TUIM | 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: TUIM | undefined;
-    /** The turn number (0-indexed). */
-    turn: number;
-    /** The Trigger.dev run ID for this conversation. */
-    runId: string;
-    /** A fresh scoped access token for this chat run (renewed each turn). Persist this for frontend reconnection. */
-    chatAccessToken: string;
-    /** The last event ID from the stream writer. Use this with `resume: true` to avoid replaying events after refresh. */
-    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;
-    /** Token usage for this turn. Undefined if usage couldn't be captured (e.g. manual pipeChat). */
-    usage?: LanguageModelUsage;
-    /** Cumulative token usage across all turns in this run (including this turn). */
-    totalUsage: LanguageModelUsage;
-};
-/**
- * Event passed to the `onBeforeTurnComplete` callback.
- * Same as `TurnCompleteEvent` but includes a `writer` since the stream is still open.
- */
-export type BeforeTurnCompleteEvent<TClientData = unknown, TUIM extends UIMessage = UIMessage> = TurnCompleteEvent<TClientData, TUIM> & {
-    /** Stream writer — write custom `UIMessageChunk` parts to the chat stream. Lazy: no overhead if unused. */
-    writer: ChatWriter;
-};
-export type ChatTaskOptions<TIdentifier extends string, TClientDataSchema extends TaskSchema | undefined = undefined, TUIMessage extends UIMessage = UIMessage> = Omit<TaskOptions<TIdentifier, ChatTaskWirePayload<TUIMessage, inferSchemaIn<TClientDataSchema>>, unknown>, "run"> & {
-    /**
-     * Schema for validating `clientData` from the frontend.
-     * Accepts Zod, ArkType, Valibot, or any supported schema library.
-     * When provided, `clientData` is parsed and typed in all hooks and `run`.
-     *
-     * @example
-     * ```ts
-     * import { z } from "zod";
-     *
-     * chat.task({
-     *   id: "my-chat",
-     *   clientDataSchema: z.object({ model: z.string().optional(), userId: z.string() }),
-     *   run: async ({ messages, clientData, ctx, signal }) => {
-     *     // clientData is typed as { model?: string; userId: string }
-     *     // ctx is the same TaskRunContext as in task({ run: (payload, { ctx }) => ... })
-     *   },
-     * });
-     * ```
-     */
-    clientDataSchema?: TClientDataSchema;
-    /**
-     * The run function for the chat task.
-     *
-     * Receives a `ChatTaskRunPayload` with the conversation messages, chat session ID,
-     * trigger type, task `ctx` (same as `task({ run })`’s second argument), and abort signals
-     * (`signal`, `cancelSignal`, `stopSignal`).
-     *
-     * **Auto-piping:** If this function returns a value with `.toUIMessageStream()`,
-     * 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 ({ ctx, 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.
-     *
-     * Use this to create the chat record in your database when a new conversation starts.
-     *
-     * @example
-     * ```ts
-     * onChatStart: async ({ ctx, chatId, messages, clientData }) => {
-     *   await db.chat.create({ data: { id: chatId, userId: clientData.userId } });
-     * }
-     * ```
-     */
-    onChatStart?: (event: ChatStartEvent<inferSchemaOut<TClientDataSchema>>) => Promise<void> | void;
-    /**
-     * Called at the start of every turn, after message accumulation and `onChatStart` (turn 0),
-     * but before the `run` function executes.
-     *
-     * Use this to persist messages before streaming begins, so a mid-stream page refresh
-     * still shows the user's message.
-     *
-     * @example
-     * ```ts
-     * onTurnStart: async ({ ctx, chatId, uiMessages }) => {
-     *   await db.chat.update({ where: { id: chatId }, data: { messages: uiMessages } });
-     * }
-     * ```
-     */
-    onTurnStart?: (event: TurnStartEvent<inferSchemaOut<TClientDataSchema>, TUIMessage>) => Promise<void> | void;
-    /**
-     * Called after the response is captured but before the stream closes.
-     * The stream is still open, so you can write custom chunks to the frontend
-     * (e.g. compaction progress). Use this for compaction, post-processing,
-     * or any work where the user should see real-time status updates.
-     *
-     * @example
-     * ```ts
-     * onBeforeTurnComplete: async ({ ctx, writer, usage }) => {
-     *   if (usage?.inputTokens && usage.inputTokens > 5000) {
-     *     writer.write({ type: "data-compaction", id: generateId(), data: { status: "compacting" } });
-     *     // ... compact messages ...
-     *     chat.setMessages(compactedMessages);
-     *     writer.write({ type: "data-compaction", id: generateId(), data: { status: "complete" } });
-     *   }
-     * }
-     * ```
-     */
-    onBeforeTurnComplete?: (event: BeforeTurnCompleteEvent<inferSchemaOut<TClientDataSchema>, TUIMessage>) => Promise<void> | void;
-    /**
-     * Called when conversation compaction occurs (via `chat.compact()` or
-     * `chat.compactionStep()`). Use for logging, billing, or persisting the summary.
-     *
-     * @example
-     * ```ts
-     * onCompacted: async ({ ctx, summary, totalTokens, chatId }) => {
-     *   logger.info("Compacted", { totalTokens, chatId });
-     *   await db.compactionLog.create({ data: { chatId, summary } });
-     * }
-     * ```
-     */
-    onCompacted?: (event: CompactedEvent) => Promise<void> | void;
-    /**
-     * Automatic context compaction. When provided, compaction runs automatically
-     * in both the inner loop (prepareStep, between tool-call steps) and the
-     * outer loop (between turns, for single-step responses where prepareStep
-     * never fires).
-     *
-     * The `shouldCompact` callback decides when to compact, and `summarize`
-     * generates the summary. The prepareStep is auto-injected into
-     * `chat.toStreamTextOptions()` — if you provide your own `prepareStep`
-     * after spreading, it overrides the auto-injected one.
-     *
-     * @example
-     * ```ts
-     * chat.task({
-     *   id: "my-chat",
-     *   compaction: {
-     *     shouldCompact: ({ totalTokens }) => (totalTokens ?? 0) > 80_000,
-     *     summarize: async (messages) =>
-     *       generateText({ model, messages: [...messages, { role: "user", content: "Summarize." }] })
-     *         .then((r) => r.text),
-     *   },
-     *   run: async ({ messages, signal }) => {
-     *     return streamText({ ...chat.toStreamTextOptions({ registry }), messages });
-     *   },
-     * });
-     * ```
-     */
-    compaction?: ChatTaskCompactionOptions<TUIMessage>;
-    /**
-     * Configure how messages that arrive during streaming are handled.
-     *
-     * By default, messages queue for the next turn. When `shouldInject` is provided
-     * and returns `true`, messages are injected between tool-call steps via
-     * `prepareStep` — allowing users to steer the agent mid-execution.
-     *
-     * @example
-     * ```ts
-     * pendingMessages: {
-     *   shouldInject: ({ steps }) => steps.length > 0,
-     *   onReceived: ({ message }) => logger.info("Steering message received"),
-     * },
-     * ```
-     */
-    pendingMessages?: PendingMessagesOptions<TUIMessage>;
-    /**
-     * Called after each assistant response completes. Use to persist the
-     * conversation to your database after each assistant response.
-     *
-     * @example
-     * ```ts
-     * onTurnComplete: async ({ ctx, chatId, messages }) => {
-     *   await db.chat.update({ where: { id: chatId }, data: { messages } });
-     * }
-     * ```
-     */
-    onTurnComplete?: (event: TurnCompleteEvent<inferSchemaOut<TClientDataSchema>, TUIMessage>) => Promise<void> | void;
-    /**
-     * Maximum number of conversational turns (message round-trips) a single run
-     * will handle before ending. After this many turns the run completes
-     * normally and the next message will start a fresh run.
-     *
-     * @default 100
-     */
-    maxTurns?: number;
-    /**
-     * How long to wait for the next message before timing out and ending the run.
-     * Accepts any duration string (e.g. `"1h"`, `"30m"`).
-     *
-     * @default "1h"
-     */
-    turnTimeout?: string;
-    /**
-     * How long (in seconds) the run stays idle (active, using compute) after each
-     * turn, waiting for the next message. During this window responses are instant.
-     * After this timeout the run suspends (frees compute) and waits via
-     * `inputStream.wait()`.
-     *
-     * Set to `0` to suspend immediately after each turn.
-     *
-     * @default 30
-     */
-    idleTimeoutInSeconds?: number;
-    /**
-     * How long the `chatAccessToken` (scoped to this run) remains valid.
-     * A fresh token is minted after each turn, so this only needs to cover
-     * the gap between turns.
-     *
-     * Accepts a duration string (e.g. `"1h"`, `"30m"`, `"2h"`).
-     *
-     * @default "1h"
-     */
-    chatAccessTokenTTL?: string;
-    /**
-     * How long (in seconds) the run stays idle after `onPreload` fires,
-     * waiting for the first message before suspending.
-     *
-     * Only applies to preloaded runs (triggered via `transport.preload()`).
-     *
-     * @default Same as `idleTimeoutInSeconds`
-     */
-    preloadIdleTimeoutInSeconds?: 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;
-    /**
-     * Transform model messages before they're used anywhere — in `run()`,
-     * in compaction rebuilds, and in compaction results.
-     *
-     * Define once, applied everywhere. Use for Anthropic cache breaks,
-     * injecting system context, stripping PII, etc.
-     *
-     * @example
-     * ```ts
-     * prepareMessages: async ({ messages, reason }) => {
-     *   // Add Anthropic cache breaks to the last message
-     *   if (messages.length === 0) return messages;
-     *   const last = messages[messages.length - 1];
-     *   return [...messages.slice(0, -1), {
-     *     ...last,
-     *     providerOptions: { ...last.providerOptions, anthropic: { cacheControl: { type: "ephemeral" } } },
-     *   }];
-     * }
-     * ```
-     */
-    prepareMessages?: (event: PrepareMessagesEvent<inferSchemaOut<TClientDataSchema>>) => ModelMessage[] | Promise<ModelMessage[]>;
-    /**
-     * 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<TUIMessage>;
-};
-/**
- * Creates a Trigger.dev task pre-configured for AI SDK chat.
- *
- * - **Pre-types the payload** as `ChatTaskRunPayload` — includes abort signals
- * - **Auto-pipes the stream** if `run` returns a `StreamTextResult`
- * - **Multi-turn**: keeps the conversation in a single run using input streams
- * - **Stop support**: frontend can stop generation mid-stream via the stop input stream
- * - For complex flows, use `pipeChat()` from anywhere inside your task code
- *
- * @example
- * ```ts
- * import { chat } from "@trigger.dev/sdk/ai";
- * import { streamText, convertToModelMessages } from "ai";
- * import { openai } from "@ai-sdk/openai";
- *
- * export const myChat = chat.task({
- *   id: "my-chat",
- *   run: async ({ messages, signal }) => {
- *     return streamText({
- *       model: openai("gpt-4o"),
- *       messages, // already converted via convertToModelMessages
- *       abortSignal: signal,
- *     });
- *   },
- * });
- * ```
- */
-declare function chatTask<TIdentifier extends string, TClientDataSchema extends TaskSchema | undefined = undefined, TUIMessage extends UIMessage = UIMessage>(options: ChatTaskOptions<TIdentifier, TClientDataSchema, TUIMessage>): Task<TIdentifier, ChatTaskWirePayload<TUIMessage, inferSchemaIn<TClientDataSchema>>, unknown>;
-/**
- * Optional config for {@link chat.withUIMessage}. `streamOptions` become default
- * static `toUIMessageStream()` settings; inner `chat.task({ uiMessageStreamOptions })`
- * shallow-merges on top (task wins on conflicts).
- */
-export type ChatWithUIMessageConfig<TUIM extends UIMessage = UIMessage> = {
-    streamOptions?: ChatUIMessageStreamOptions<TUIM>;
-};
-/**
- * Fix the UI message type for a chat task (AI SDK `UIMessage` generics) while
- * keeping `id` and `clientDataSchema` inference on the inner {@link chat.task} call.
- *
- * @example
- * ```ts
- * type AgentUiMessage = UIMessage<unknown, UIDataTypes, UITools>;
- *
- * export const myChat = chat.withUIMessage<AgentUiMessage>({
- *   streamOptions: { sendReasoning: true },
- * }).task({
- *   id: "my-chat",
- *   run: async ({ messages, signal }) => { ... },
- * });
- * ```
- */
-declare function withUIMessage<TUIM extends UIMessage = UIMessage>(config?: ChatWithUIMessageConfig<TUIM>): {
-    task: <TIdentifier extends string, TClientDataSchema extends TaskSchema | undefined = undefined>(options: ChatTaskOptions<TIdentifier, TClientDataSchema, TUIM>) => Task<TIdentifier, ChatTaskWirePayload<TUIM, inferSchemaIn<TClientDataSchema>>, unknown>;
-};
-/**
- * Override the turn timeout for subsequent turns in the current run.
- *
- * The turn timeout controls how long the run stays suspended (freeing compute)
- * waiting for the next user message. When it expires, the run completes
- * gracefully and the next message starts a fresh run.
- *
- * Call from inside a `chatTask` run function to adjust based on context.
- *
- * @param duration - A duration string (e.g. `"5m"`, `"1h"`, `"30s"`)
- *
- * @example
- * ```ts
- * run: async ({ messages, signal }) => {
- *   chat.setTurnTimeout("2h");
- *   return streamText({ model, messages, abortSignal: signal });
- * }
- * ```
- */
-declare function setTurnTimeout(duration: string): void;
-/**
- * Override the turn timeout in seconds for subsequent turns in the current run.
- *
- * @param seconds - Number of seconds to wait for the next message before ending the run
- *
- * @example
- * ```ts
- * run: async ({ messages, signal }) => {
- *   chat.setTurnTimeoutInSeconds(3600); // 1 hour
- *   return streamText({ model, messages, abortSignal: signal });
- * }
- * ```
- */
-declare function setTurnTimeoutInSeconds(seconds: number): void;
-/**
- * Override the idle timeout for subsequent turns in the current run.
- *
- * The idle timeout controls how long the run stays active (using compute)
- * after each turn, waiting for the next message. During this window,
- * responses are instant. After it expires, the run suspends.
- *
- * @param seconds - Number of seconds to stay idle (0 to suspend immediately)
- *
- * @example
- * ```ts
- * run: async ({ messages, signal }) => {
- *   chat.setIdleTimeoutInSeconds(60);
- *   return streamText({ model, messages, abortSignal: signal });
- * }
- * ```
- */
-declare function setIdleTimeoutInSeconds(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<UIMessage>): 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;
-/**
- * Queue model messages for injection at the next `prepareStep` boundary.
- *
- * Use this to inject context from background work into the agent's conversation.
- * Messages are appended to the model messages before the next LLM inference call.
- *
- * Combine with `chat.defer()` to run background analysis and inject results:
- *
- * @example
- * ```ts
- * onTurnComplete: async ({ messages }) => {
- *   chat.defer((async () => {
- *     const review = await generateObject({
- *       model: openai("gpt-4o-mini"),
- *       messages: [...messages, { role: "user", content: "Review the last response." }],
- *       schema: z.object({ suggestions: z.array(z.string()) }),
- *     });
- *     if (review.object.suggestions.length > 0) {
- *       chat.inject([{
- *         role: "system",
- *         content: `Improvements for next response:\n${review.object.suggestions.join("\n")}`,
- *       }]);
- *     }
- *   })());
- * },
- * ```
- */
-declare function injectBackgroundContext(messages: ModelMessage[]): 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<TUIM extends UIMessage>(message: TUIM): TUIM;
-/**
- * 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[];
-    private _compaction?;
-    private _pendingMessages?;
-    private _steeringQueue;
-    constructor(options?: {
-        compaction?: ChatTaskCompactionOptions;
-        pendingMessages?: PendingMessagesOptions;
-    });
-    /**
-     * 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.
-     */
-    /**
-     * Replace all accumulated messages (for compaction).
-     * Converts UIMessages to ModelMessages internally.
-     */
-    setMessages(uiMessages: UIMessage[]): Promise<void>;
-    addResponse(response: UIMessage): Promise<void>;
-    /**
-     * Queue a message for injection via `prepareStep`. Call from a
-     * `messagesInput.on()` listener when a message arrives during streaming.
-     */
-    steer(message: UIMessage, modelMessages?: ModelMessage[]): void;
-    /**
-     * Queue a message for injection, converting to model messages automatically.
-     */
-    steerAsync(message: UIMessage): Promise<void>;
-    /**
-     * Get and clear unconsumed steering messages.
-     */
-    drainSteering(): UIMessage[];
-    /**
-     * Returns a `prepareStep` function that handles both compaction and
-     * pending message injection. Pass to `streamText({ prepareStep: conversation.prepareStep() })`.
-     */
-    prepareStep(): ((args: {
-        messages: ModelMessage[];
-        steps: CompactionStep[];
-    }) => Promise<{
-        messages: ModelMessage[];
-    } | undefined>) | undefined;
-    /**
-     * Run outer-loop compaction if needed. Call after adding the response
-     * and capturing usage. Applies `compactModelMessages` and `compactUIMessages`
-     * callbacks if configured.
-     *
-     * @returns `true` if compaction was performed, `false` otherwise.
-     */
-    compactIfNeeded(usage: LanguageModelUsage | undefined, context?: {
-        chatId?: string;
-        turn?: number;
-        clientData?: unknown;
-        totalUsage?: LanguageModelUsage;
-    }): Promise<boolean>;
-}
-export type ChatSessionOptions = {
-    /** Run-level cancel signal (from task context). */
-    signal: AbortSignal;
-    /** Seconds to stay idle between turns before suspending. @default 30 */
-    idleTimeoutInSeconds?: number;
-    /** Duration string for suspend timeout. @default "1h" */
-    timeout?: string;
-    /** Max turns before ending. @default 100 */
-    maxTurns?: number;
-    /** Automatic context compaction — same options as `chat.task({ compaction })`. */
-    compaction?: ChatTaskCompactionOptions;
-    /** Configure mid-execution message injection — same options as `chat.task({ pendingMessages })`. */
-    pendingMessages?: PendingMessagesOptions;
-};
-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`. */
-    readonly messages: ModelMessage[];
-    /** Full accumulated UI messages — use for persistence. */
-    readonly 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;
-    /** Token usage from the previous turn. Undefined on turn 0. */
-    previousTurnUsage?: LanguageModelUsage;
-    /** Cumulative token usage across all completed turns so far. */
-    totalUsage: LanguageModelUsage;
-    /**
-     * Replace accumulated messages (for compaction). Takes UIMessages and
-     * converts to ModelMessages internally. After calling this, `turn.messages`
-     * reflects the compacted history.
-     */
-    setMessages(uiMessages: UIMessage[]): Promise<void>;
-    /**
-     * 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>;
-    /**
-     * Returns a `prepareStep` function that handles both compaction and
-     * pending message injection. Pass to `streamText({ prepareStep: turn.prepareStep() })`.
-     * Only needed when not using `chat.toStreamTextOptions()` (which auto-injects it).
-     */
-    prepareStep(): ((args: {
-        messages: ModelMessage[];
-        steps: CompactionStep[];
-    }) => Promise<{
-        messages: ModelMessage[];
-    } | undefined>) | undefined;
-};
-/**
- * Create a chat session that yields turns as an async iterator.
- *
- * Handles: preload wait, stop signals, message accumulation, turn-complete
- * signaling, and idle/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.
- * Internal metadata is stored behind Symbols and invisible to
- * `Object.keys()`, `JSON.stringify()`, and spread.
- */
-export type ChatLocal<T extends Record<string, unknown>> = T & {
-    /** Initialize the local with a value. Call in `onChatStart` or `run()`. */
-    init(value: T): void;
-    /** Returns `true` if any property was set since the last check. Resets the dirty flag. */
-    hasChanged(): boolean;
-    /** Returns a plain object copy of the current value. Useful for persistence. */
-    get(): T;
-    readonly [CHAT_LOCAL_KEY]: ReturnType<typeof locals.create<T>>;
-    readonly [CHAT_LOCAL_DIRTY_KEY]: ReturnType<typeof locals.create<boolean>>;
-};
-/**
- * Creates a per-run typed data object accessible from anywhere during task execution.
- *
- * Declare at module level, then initialize inside a lifecycle hook (e.g. `onChatStart`)
- * using `chat.initLocal()`. Properties are accessible directly via the Proxy.
- *
- * 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.toolExecute()` (or legacy `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 }>({ id: "userPrefs" });
- * const gameState = chat.local<{ score: number; streak: number }>({ id: "gameState" });
- *
- * export const myChat = chat.task({
- *   id: "my-chat",
- *   onChatStart: async ({ clientData }) => {
- *     const prefs = await db.prefs.findUnique({ where: { userId: clientData.userId } });
- *     userPrefs.init(prefs ?? { theme: "dark", language: "en" });
- *     gameState.init({ score: 0, streak: 0 });
- *   },
- *   onTurnComplete: async ({ chatId }) => {
- *     if (gameState.hasChanged()) {
- *       await db.save({ where: { chatId }, data: gameState.get() });
- *     }
- *   },
- *   run: async ({ messages }) => {
- *     gameState.score++;
- *     return streamText({
- *       system: `User prefers ${userPrefs.theme} theme. Score: ${gameState.score}`,
- *       messages,
- *     });
- *   },
- * });
- * ```
- */
-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.
- *
- * @example
- * ```ts
- * import type { InferChatClientData } from "@trigger.dev/sdk/ai";
- * import type { myChat } from "@/trigger/chat";
- *
- * type MyClientData = InferChatClientData<typeof myChat>;
- * // { model?: string; userId: string }
- * ```
- */
-export type InferChatClientData<TTask extends AnyTask> = TTask extends Task<string, ChatTaskWirePayload<any, infer TMetadata>, any> ? TMetadata : unknown;
-/**
- * Extracts the UI message type from a chat task (wire payload `messages` items).
- *
- * @example
- * ```ts
- * import type { InferChatUIMessage } from "@trigger.dev/sdk/ai";
- * import type { myChat } from "@/trigger/chat";
- *
- * type Msg = InferChatUIMessage<typeof myChat>;
- * ```
- */
-export type InferChatUIMessage<TTask extends AnyTask> = TTask extends Task<string, ChatTaskWirePayload<infer TUIM extends UIMessage, any>, any> ? TUIM : UIMessage;
-export declare const chat: {
-    /** Create a chat task. See {@link chatTask}. */
-    task: typeof chatTask;
-    /** Create a chat task with a fixed {@link UIMessage} subtype and optional default stream options. See {@link withUIMessage}. */
-    withUIMessage: typeof withUIMessage;
-    /** Pipe a stream to the chat transport. See {@link pipeChat}. */
-    pipe: typeof pipeChat;
-    /** Create a per-run typed local. See {@link chatLocal}. */
-    local: typeof chatLocal;
-    /** Create a public access token for a chat task. See {@link createChatAccessToken}. */
-    createAccessToken: typeof createChatAccessToken;
-    /** Override the turn timeout at runtime (duration string). See {@link setTurnTimeout}. */
-    setTurnTimeout: typeof setTurnTimeout;
-    /** Override the turn timeout at runtime (seconds). See {@link setTurnTimeoutInSeconds}. */
-    setTurnTimeoutInSeconds: typeof setTurnTimeoutInSeconds;
-    /** Override the idle timeout at runtime. See {@link setIdleTimeoutInSeconds}. */
-    setIdleTimeoutInSeconds: typeof setIdleTimeoutInSeconds;
-    /** 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;
-    /** Queue model messages for injection at the next `prepareStep` boundary. See {@link injectBackgroundContext}. */
-    inject: typeof injectBackgroundContext;
-    /** 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;
-    /**
-     * Store and retrieve a resolved prompt for the current run.
-     *
-     * - `chat.prompt.set(resolved)` — store a `ResolvedPrompt` or plain string
-     * - `chat.prompt()` — read the stored prompt (throws if not set)
-     */
-    prompt: typeof getChatPrompt & {
-        set: typeof setChatPrompt;
-    };
-    /**
-     * Returns an options object ready to spread into `streamText()`.
-     * Reads the stored prompt and returns `{ system, experimental_telemetry, ...config }`.
-     * Returns `{}` if no prompt has been set.
-     */
-    toStreamTextOptions: typeof toStreamTextOptions;
-    /**
-     * Replace the accumulated conversation messages for compaction.
-     * Call from `onTurnStart` or `onTurnComplete`. Takes `UIMessage[]` and
-     * converts to `ModelMessage[]` internally.
-     */
-    setMessages: typeof setChatMessages;
-    /** Check if it's safe to compact messages (no in-flight tool calls). */
-    isCompactionSafe: typeof isCompactionSafe;
-    /** Returns a `prepareStep` function that handles context compaction automatically. */
-    compactionStep: typeof chatCompactionStep;
-    /** Low-level compaction for use inside a custom `prepareStep`. */
-    compact: typeof chatCompact;
-    /** Read the current compaction state (summary + base message count). */
-    getCompactionState: typeof getCompactionState;
 };
+export {};