@trigger.dev/sdk 0.0.0-chat-prerelease-20260507122230 → 0.0.0-chat-prerelease-20260517214402

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

@@ -1,13 +1,12 @@
-import { AnyTask, type RealtimeDefinedInputStream, type RealtimeDefinedStream, Task, type inferSchemaIn, type inferSchemaOut, type TaskIdentifier, type TaskOptions, type TaskSchema, type TaskRunContext, type TaskWithSchema } from "@trigger.dev/core/v3";
+import { AnyTask, Task, type inferSchemaIn, type inferSchemaOut, type TaskIdentifier, type TaskOptions, type TaskSchema, type TaskRunContext, type TaskWithSchema } from "@trigger.dev/core/v3";
 import type { FinishReason, ModelMessage, ToolSet, UIMessage, UIMessageChunk, UIMessageStreamOptions, LanguageModelUsage } from "ai";
 import { Tool, ToolCallOptions } from "ai";
 import { locals } from "./locals.js";
 import type { ResolvedPrompt } from "./prompt.js";
-import type { ResolvedSkill } from "./skill.js";
-import { type SessionTriggerConfig } from "@trigger.dev/core/v3";
+import type { TriggerChatTaskParams, TriggerChatTaskResult } from "./chat.js";
 /** Re-export for typing `ctx` in `chat.agent` hooks without importing `@trigger.dev/core`. */
 export type { TaskRunContext } from "@trigger.dev/core/v3";
-import { type ChatStorePatchOperation } from "@trigger.dev/core/v3/chat-client";
+import { CHAT_MESSAGES_STREAM_ID, CHAT_STOP_STREAM_ID } from "./chat-constants.js";
 export type ToolCallExecutionOptions = {
     toolCallId: string;
     experimental_context?: unknown;
@@ -133,28 +132,12 @@ export declare const ai: {
  */
 declare function createChatAccessToken<TTask extends AnyTask>(taskId: TaskIdentifier<TTask>): Promise<string>;
 /**
- * Listener fired when the store value changes. `operations` is present for
- * `patch()` updates and absent for `set()` (which is a full snapshot).
+ * The default stream key used for chat transport communication.
+ * Both `TriggerChatTransport` (frontend) and `pipeChat`/`chatAgent` (backend)
+ * use this key by default.
  */
-export type ChatStoreChangeListener<TStore = unknown> = (value: TStore, operations?: ChatStorePatchOperation[]) => void;
-/**
- * Replace the entire store value with `value`. Emits a `store-snapshot`
- * chunk on the chat output stream and fires all `onChange` listeners.
- */
-declare function chatStoreSet<TStore = unknown>(value: TStore): void;
-/**
- * Apply RFC 6902 JSON Patch operations to the current store value.
- * Emits a `store-delta` chunk on the chat output stream and fires all
- * `onChange` listeners with the new value and the operations.
- */
-declare function chatStorePatch(operations: ChatStorePatchOperation[]): void;
-/** Get the current store value. Returns `undefined` if no value has been set. */
-declare function chatStoreGet<TStore = unknown>(): TStore | undefined;
-/**
- * Subscribe to store changes for the current run. Returns an
- * unsubscribe function.
- */
-declare function chatStoreOnChange<TStore = unknown>(listener: ChatStoreChangeListener<TStore>): () => void;
+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`).
@@ -180,8 +163,25 @@ export type ChatWriter = {
     /** Merge another stream's chunks into the chat stream. */
     merge(stream: ReadableStream<UIMessageChunk>): void;
 };
-import type { ChatTaskWirePayload } from "./ai-shared.js";
-export type { ChatTaskWirePayload, ChatInputChunk } from "./ai-shared.js";
+/**
+ * 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" | "close" | "action";
+    messageId?: string;
+    metadata?: TMetadata;
+    /** Custom action payload when `trigger` is `"action"`. Validated against `actionSchema` on the backend. */
+    action?: unknown;
+    /** 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 `chatAgent` run function.
  *
@@ -218,14 +218,6 @@ export type ChatTaskPayload<TClientData = unknown> = {
     previousRunId?: string;
     /** Whether this run was preloaded before the first message. */
     preloaded: boolean;
-    /**
-     * The friendlyId of the Session primitive backing this chat. Use with
-     * `sessions.open(sessionId)` when you need direct access to the session's
-     * `.in` / `.out` channels outside the hooks the agent already wires for
-     * you. Undefined only for legacy transports that predate the sessions
-     * migration.
-     */
-    sessionId?: string;
 };
 /**
  * Abort signals provided to the `chatAgent` run function.
@@ -263,28 +255,6 @@ export type ChatTurnUsage = LanguageModelUsage;
  * and converts to `ModelMessage[]` internally.
  */
 declare function setChatMessages<TUIM extends UIMessage = UIMessage>(uiMessages: TUIM[]): void;
-/**
- * A tool call surfaced by `chat.history.getPendingToolCalls()` /
- * `getResolvedToolCalls()`. Identifies the call by its `toolCallId` plus
- * the `messageId` of the assistant message that hosts it, so callers can
- * locate the part precisely without re-walking the chain.
- */
-export type ChatToolCallRef = {
-    toolCallId: string;
-    toolName: string;
-    messageId: string;
-};
-/**
- * A new tool result surfaced by `chat.history.extractNewToolResults()`.
- * `errorText` is set iff the part is in `output-error` state; otherwise
- * `output` carries the resolved value.
- */
-export type ChatNewToolResult = {
-    toolCallId: string;
-    toolName: string;
-    output: unknown;
-    errorText?: string;
-};
 /** State stored in locals during prepareStep compaction. */
 interface CompactionState {
     summary: string;
@@ -463,7 +433,7 @@ export type PendingMessagesOptions<TUIM extends UIMessage = UIMessage> = {
  * between tool-call steps. The frontend can match on this to render
  * injection points inline in the assistant response.
  */
-export { PENDING_MESSAGE_INJECTED_TYPE } from "./ai-shared.js";
+export declare const PENDING_MESSAGE_INJECTED_TYPE: "data-pending-message-injected";
 /**
  * Event passed to the `prepareMessages` hook.
  */
@@ -703,21 +673,6 @@ declare function setChatPrompt(resolved: ResolvedPrompt | string): void;
  * Read the stored prompt. Throws if `chat.prompt.set()` has not been called.
  */
 declare function getChatPrompt(): ChatPromptValue;
-/**
- * Store resolved skills for the current run. Call from any hook
- * (`onPreload`, `onChatStart`, `onTurnStart`) or `run()`.
- */
-declare function setChatSkills(skills: ResolvedSkill[]): void;
-/** Read the stored skills. Returns `undefined` if none set. */
-declare function getChatSkills(): ResolvedSkill[] | undefined;
-/**
- * Build the three tools we auto-inject into `streamText` when skills are
- * set: `loadSkill`, `readFile`, `bash`. Scoped per-skill by name.
- *
- * Exported so callers can use the same tools outside the auto-wired path
- * (e.g. in a `chat.createSession` loop with custom streamText).
- */
-export declare function buildSkillTools(skills: ResolvedSkill[]): Record<string, Tool>;
 /**
  * Options for {@link toStreamTextOptions}.
  */
@@ -736,16 +691,6 @@ export type ToStreamTextOptionsOptions = {
     registry?: {
         languageModel(modelId: string): unknown;
     };
-    /**
-     * User-defined tools to merge alongside the auto-injected skill tools
-     * (`loadSkill`, `readFile`, `bash`). User tools win on name conflicts.
-     *
-     * If you don't pass `tools` here and skills are set, the returned options
-     * will include just the skill tools — spread after any `tools` you pass
-     * directly to `streamText` and they'll be replaced. Easiest: pass all
-     * your tools here.
-     */
-    tools?: Record<string, Tool>;
 };
 /**
  * Returns an options object ready to spread into `streamText()`.
@@ -920,37 +865,6 @@ export type HydrateMessagesEvent<TClientData = unknown, TUIM extends UIMessage =
     /** The ID of the previous run (if continuation). */
     previousRunId?: string;
 };
-/**
- * Event passed to the `hydrateStore` callback.
- *
- * Called at turn start — before `run()` fires and before any incoming store
- * from the wire payload is applied. Return the authoritative store value
- * for this turn; it becomes the initial value `chat.store.get()` sees.
- */
-export type HydrateStoreEvent<TClientData = unknown, TStore = unknown> = {
-    /** The unique identifier for the chat session. */
-    chatId: string;
-    /** The turn number (0-indexed). */
-    turn: number;
-    /** The trigger type for this turn. */
-    trigger: "submit-message" | "regenerate-message" | "action" | "preload";
-    /**
-     * The in-memory store value from the previous turn of this run
-     * (`undefined` on turn 0 and after continuations).
-     */
-    previousStore: TStore | undefined;
-    /**
-     * The store value the transport sent with this turn, if any.
-     * Usually set by client-side `setStore` / `applyStorePatch`.
-     */
-    incomingStore: TStore | undefined;
-    /** Parsed client data from the transport metadata. */
-    clientData?: TClientData;
-    /** Whether this run is continuing from a previous run. */
-    continuation: boolean;
-    /** The ID of the previous run (if continuation). */
-    previousRunId?: string;
-};
 /**
  * Event passed to the `onValidateMessages` callback.
  */
@@ -1210,18 +1124,13 @@ export type ChatAgentOptions<TIdentifier extends string, TClientDataSchema exten
     /**
      * Called when the frontend sends a custom action via `transport.sendAction()`.
      *
-     * Actions are not turns. They fire `hydrateMessages` (if configured) and
-     * `onAction` only — no `onTurnStart` / `prepareMessages` /
-     * `onBeforeTurnComplete` / `onTurnComplete`, no `run()`. Use
-     * `chat.history.*` inside `onAction` to mutate state.
-     *
-     * To produce a model response from an action, return a
-     * `StreamTextResult` (auto-piped), `string`, or `UIMessage`. Returning
-     * `void` or nothing is the side-effect-only default.
+     * Fires after message hydration (if set) but before `onTurnStart` and `run()`.
+     * Use `chat.history.*` to modify the conversation state — the LLM will respond
+     * to the modified state.
      */
     onAction?: (event: ActionEvent<[
         TActionSchema
-    ] extends [TaskSchema] ? inferSchemaOut<TActionSchema> : unknown, inferSchemaOut<TClientDataSchema>, TUIMessage>) => Promise<unknown> | unknown;
+    ] extends [TaskSchema] ? inferSchemaOut<TActionSchema> : unknown, inferSchemaOut<TClientDataSchema>, TUIMessage>) => Promise<void> | void;
     /**
      * The run function for the chat task.
      *
@@ -1323,43 +1232,6 @@ export type ChatAgentOptions<TIdentifier extends string, TClientDataSchema exten
      * ```
      */
     hydrateMessages?: (event: HydrateMessagesEvent<inferSchemaOut<TClientDataSchema>, TUIMessage>) => TUIMessage[] | Promise<TUIMessage[]>;
-    /**
-     * Load the `chat.store` value for this turn from your backend.
-     *
-     * The store lives in memory on the agent instance for the lifetime of
-     * the run. After a continuation (idle timeout, `chat.requestUpgrade`,
-     * max turns), a new run starts with an empty store — this hook lets
-     * you restore it from your own persistence layer.
-     *
-     * Runs at turn start, before `run()` fires. The returned value replaces
-     * the in-memory store and is emitted as a `store-snapshot` chunk so the
-     * frontend sees the initial value.
-     *
-     * If both `hydrateStore` and `incomingStore` (from the wire payload) are
-     * present, `incomingStore` wins — it represents the client's latest
-     * local state and follows AG-UI's last-write-wins policy.
-     *
-     * @example
-     * ```ts
-     * chat.agent({
-     *   id: "my-chat",
-     *   hydrateStore: async ({ chatId, previousRunId }) => {
-     *     return db.chatStore.findUnique({ where: { chatId } })?.value;
-     *   },
-     *   onTurnComplete: async ({ chatId }) => {
-     *     await db.chatStore.upsert({
-     *       where: { chatId },
-     *       update: { value: chat.store.get() },
-     *       create: { chatId, value: chat.store.get() },
-     *     });
-     *   },
-     *   run: async ({ messages, signal }) => {
-     *     return streamText({ model: openai("gpt-4o"), messages, abortSignal: signal });
-     *   },
-     * });
-     * ```
-     */
-    hydrateStore?: (event: HydrateStoreEvent<inferSchemaOut<TClientDataSchema>>) => unknown | Promise<unknown>;
     /**
      * Called at the start of every turn, after message accumulation and `onChatStart` (turn 0),
      * but before the `run` function executes.
@@ -2309,58 +2181,32 @@ declare function chatLocal<T extends Record<string, unknown>>(options: {
  * // { model?: string; userId: string }
  * ```
  */
-import type { InferChatClientData } from "./ai-shared.js";
-export type { InferChatClientData, InferChatUIMessage } from "./ai-shared.js";
-/**
- * Options for {@link createChatStartSessionAction}.
- */
-export type CreateChatStartSessionActionOptions = {
-    /** TTL for the session-scoped public access token. @default "1h" */
-    tokenTTL?: string | number | Date;
-    /**
-     * Default trigger config used when starting a new session for a chat.
-     * Per-call `params.triggerConfig` shallow-merges on top.
-     */
-    triggerConfig?: Partial<SessionTriggerConfig>;
-};
+export type InferChatClientData<TTask extends AnyTask> = TTask extends Task<string, ChatTaskWirePayload<any, infer TMetadata>, any> ? TMetadata : unknown;
 /**
- * Params for the function returned by {@link createChatStartSessionAction}.
+ * 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 ChatStartSessionParams = {
-    /** Conversation id (mapped to the Session's `externalId`). */
-    chatId: string;
-    /**
-     * Per-call trigger config. Shallow-merged over the action's default
-     * `triggerConfig`. `basePayload` is the customer's wire payload (for
-     * `chat.agent`: anything beyond `chatId`/`messages`/`trigger`/`metadata`,
-     * which the runtime injects automatically).
-     */
-    triggerConfig?: Partial<SessionTriggerConfig>;
-    /** Pass-through metadata folded into the session row. */
-    metadata?: Record<string, unknown>;
-};
+export type InferChatUIMessage<TTask extends AnyTask> = TTask extends Task<string, ChatTaskWirePayload<infer TUIM extends UIMessage, any>, any> ? TUIM : UIMessage;
 /**
- * Result from {@link createChatStartSessionAction}'s returned function.
+ * Options for {@link createChatTriggerAction}.
  */
-export type ChatStartSessionResult = {
-    /**
-     * Session-scoped public access token (`read:sessions:{chatId} +
-     * write:sessions:{chatId}`). Pass this to the browser; the transport
-     * uses it to call `.in/append`, `.out`, `end-and-continue`.
-     */
-    publicAccessToken: string;
-    /** Friendly id of the run triggered alongside session create. */
-    runId: string;
-    /** Session friendlyId — informational. */
-    sessionId: string;
+export type CreateChatTriggerActionOptions = {
+    /** TTL for the run-scoped public access token. @default "1h" */
+    tokenTTL?: string | number | Date;
 };
 /**
- * Creates a server-side helper that starts (or resumes) a Session for a
- * given chatId — atomically creating the row, triggering the first run,
- * and returning a session-scoped PAT for the browser to use.
+ * Creates a function that triggers a chat task and returns a run-scoped session.
  *
- * Wrap in a Next.js server action (or any server-side handler) so the
- * customer's secret key never crosses to the browser.
+ * Wrap the returned function in a Next.js server action (or any server-side handler)
+ * to keep task triggering on the server. The function calls `tasks.trigger()` with
+ * the secret key and mints a run-scoped PAT for stream subscription + input stream writes.
  *
  * @example
  * ```ts
@@ -2368,23 +2214,18 @@ export type ChatStartSessionResult = {
  * "use server";
  * import { chat } from "@trigger.dev/sdk/ai";
  *
- * export const startChatSession = chat.createStartSessionAction("my-chat", {
- *   triggerConfig: { machine: "small-1x" },
- * });
+ * export const triggerChat = chat.createTriggerAction("my-chat");
  * ```
  *
- * Then in the browser:
+ * Then pass it to the transport:
  * ```tsx
  * const transport = useTriggerChatTransport({
  *   task: "my-chat",
- *   accessToken: async ({ chatId }) => {
- *     const { publicAccessToken } = await startChatSession({ chatId });
- *     return publicAccessToken;
- *   },
+ *   triggerTask: triggerChat,
  * });
  * ```
  */
-declare function createChatStartSessionAction(taskId: string, options?: CreateChatStartSessionActionOptions): (params: ChatStartSessionParams) => Promise<ChatStartSessionResult>;
+declare function createChatTriggerAction(taskId: string, options?: CreateChatTriggerActionOptions): (params: TriggerChatTaskParams) => Promise<TriggerChatTaskResult>;
 export declare const chat: {
     /** Create a chat agent. See {@link chatAgent}. */
     agent: typeof chatAgent;
@@ -2394,8 +2235,8 @@ export declare const chat: {
     withUIMessage: typeof withUIMessage;
     /** Create a chat task with a fixed client data schema. See {@link withClientData}. */
     withClientData: typeof withClientData;
-    /** Create a server-side helper for starting (or resuming) a Session for a chatId. See {@link createChatStartSessionAction}. */
-    createStartSessionAction: typeof createChatStartSessionAction;
+    /** Create a server-side trigger action helper. See {@link createChatTriggerAction}. */
+    createTriggerAction: typeof createChatTriggerAction;
     /** Pipe a stream to the chat transport. See {@link pipeChat}. */
     pipe: typeof pipeChat;
     /** Create a per-run typed local. See {@link chatLocal}. */
@@ -2423,7 +2264,7 @@ export declare const chat: {
     /** 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: RealtimeDefinedStream<UIMessageChunk>;
+    stream: import("@trigger.dev/core/v3").RealtimeDefinedStream<UIMessageChunk>;
     /** Write data parts that persist to the response message. See {@link chatResponse}. */
     response: {
         /**
@@ -2432,36 +2273,8 @@ export declare const chat: {
          */
         write(part: UIMessageChunk): void;
     };
-    /**
-     * Typed, bidirectional shared data slot for the chat.
-     *
-     * Use from `chat.agent` hooks and `run()` to share state with the client.
-     * Setting emits a `store-snapshot` chunk; patching emits `store-delta`.
-     * The value persists across turns within the same run, and can be
-     * restored after continuations via the `hydrateStore` config option.
-     *
-     * ```ts
-     * chat.store.set({ plan: ["research", "draft", "review"] });
-     * chat.store.patch([{ op: "replace", path: "/status", value: "done" }]);
-     * const current = chat.store.get();
-     * const off = chat.store.onChange((value, ops) => { ... });
-     * ```
-     */
-    store: {
-        /** Replace the store value. Emits a `store-snapshot` chunk. */
-        set: typeof chatStoreSet;
-        /**
-         * Apply RFC 6902 JSON Patch operations to the current value.
-         * Emits a `store-delta` chunk.
-         */
-        patch: typeof chatStorePatch;
-        /** Read the current store value. Returns `undefined` if never set. */
-        get: typeof chatStoreGet;
-        /** Subscribe to store changes. Returns an unsubscribe function. */
-        onChange: typeof chatStoreOnChange;
-    };
     /** Pre-built input stream for receiving messages from the transport. */
-    messages: RealtimeDefinedInputStream<ChatTaskWirePayload>;
+    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}. */
@@ -2481,20 +2294,6 @@ export declare const chat: {
     prompt: typeof getChatPrompt & {
         set: typeof setChatPrompt;
     };
-    /**
-     * Store and retrieve resolved agent skills for the current run.
-     *
-     * - `chat.skills.set([...])` — store an array of `ResolvedSkill`s
-     * - `chat.skills()` — read the stored skills (returns undefined if none)
-     *
-     * Skills set here are automatically injected into `streamText` by
-     * `chat.toStreamTextOptions()`: skill descriptions land in the system
-     * prompt and `loadSkill` / `readFile` / `bash` tools are added to the
-     * tool set.
-     */
-    skills: typeof getChatSkills & {
-        set: typeof setChatSkills;
-    };
     /**
      * Returns an options object ready to spread into `streamText()`.
      * Reads the stored prompt and returns `{ system, experimental_telemetry, ...config }`.
@@ -2515,40 +2314,6 @@ export declare const chat: {
     history: {
         /** Read the current accumulated UI messages (copy). */
         all(): UIMessage[];
-        /**
-         * Read the current chain as an ordered `UIMessage[]`. Alias for `all()` —
-         * use this when working alongside parent-aware APIs (TRI-9120) where
-         * "chain" disambiguates from "graph".
-         */
-        getChain(): UIMessage[];
-        /**
-         * Find a message by id. Returns `undefined` if no message with that id
-         * is present in the current chain.
-         */
-        findMessage(messageId: string): UIMessage | undefined;
-        /**
-         * Tool calls on the leaf assistant message still waiting on an answer
-         * (`input-available` state). Use this to gate fresh user turns during
-         * HITL flows: if `getPendingToolCalls().length > 0`, an `addToolOutput`
-         * is expected before any new user message.
-         *
-         * Returns `[]` if there is no assistant message yet, or if the leaf
-         * assistant has no pending tool calls.
-         */
-        getPendingToolCalls(): ChatToolCallRef[];
-        /**
-         * Tool calls across the chain with a final result (`output-available`
-         * or `output-error`). Use this to dedup re-saves when the AI SDK
-         * resends an assistant message with progressively more answered parts.
-         */
-        getResolvedToolCalls(): ChatToolCallRef[];
-        /**
-         * Pure helper: returns the tool parts in `message` whose results are
-         * not already represented in the current chain. Use this when
-         * persisting tool results to your own store: each call surfaces only
-         * the *new* answers, so writes stay idempotent across re-streams.
-         */
-        extractNewToolResults(message: UIMessage): ChatNewToolResult[];
         /** Replace all accumulated messages. Same as `chat.setMessages()`. */
         set(messages: UIMessage[]): void;
         /** Remove a specific message by ID. */
@@ -2568,10 +2333,4 @@ export declare const chat: {
     compact: typeof chatCompact;
     /** Read the current compaction state (summary + base message count). */
     getCompactionState: typeof getCompactionState;
-    /**
-     * The friendlyId (`session_*`) of the backing Session for the current chat.agent run.
-     * Useful for persisting alongside `runId` so reloads can resume the same session.
-     * Throws if called outside a chat.agent `run()` or hook.
-     */
-    readonly sessionId: string;
 };