@trigger.dev/sdk 0.0.0-chat-prerelease-20260419173457 → 0.0.0-chat-prerelease-20260501122331

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

@@ -0,0 +1,28 @@
+export type BashSkillInput = {
+    /** Absolute path to the skill's root (used as `cwd`). */
+    skillPath: string;
+    /** The bash command to run. */
+    command: string;
+    /** Optional abort signal forwarded to `spawn()`. */
+    abortSignal?: AbortSignal;
+};
+export type BashSkillResult = {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+} | {
+    error: string;
+};
+export type ReadFileInSkillInput = {
+    /** Absolute path to the skill's root — the relative path must resolve inside it. */
+    skillPath: string;
+    /** Relative path the tool caller supplied. */
+    relativePath: string;
+};
+export type ReadFileInSkillResult = {
+    content: string;
+} | {
+    error: string;
+};
+export declare function readFileInSkill({ skillPath, relativePath, }: ReadFileInSkillInput): Promise<ReadFileInSkillResult>;
+export declare function runBashInSkill({ skillPath, command, abortSignal, }: BashSkillInput): Promise<BashSkillResult>;

package/dist/commonjs/v3/agentSkillsRuntime.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileInSkill = readFileInSkill;
+exports.runBashInSkill = runBashInSkill;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs/promises"));
+const nodePath = __importStar(require("node:path"));
+/**
+ * Server-only runtime for the auto-injected skill tools
+ * (`loadSkill` / `readFile` / `bash`) that `chat.agent({ skills })`
+ * wires up. Split off from `./ai.ts` so the chat-agent surface in
+ * `@trigger.dev/sdk/ai` stays importable from client bundles —
+ * Next.js + Webpack reject top-level `node:*` imports anywhere in a
+ * client graph, even when a consumer only pulls in types.
+ *
+ * The SDK's `ai.ts` loads this module via a computed-string dynamic
+ * import inside each tool's `execute` — webpack treats the
+ * expression as an unknown dependency and skips static tracing, so
+ * the node-only symbols here never surface in a client build. The
+ * module resolves fine at runtime on a server worker because the
+ * relative path (`./agentSkillsRuntime.js`) lands next to `ai.js` in
+ * the emitted dist.
+ *
+ * Public subpath: `@trigger.dev/sdk/ai/skills-runtime`. Customers
+ * who want to eagerly bundle the runtime server-side (e.g. warming
+ * it on worker bootstrap) can import from there.
+ */
+const DEFAULT_BASH_OUTPUT_BYTES = 64 * 1024;
+const DEFAULT_READ_FILE_BYTES = 1024 * 1024;
+function truncate(s, limit) {
+    if (s.length <= limit)
+        return s;
+    return s.slice(0, limit) + `\n…[truncated ${s.length - limit} bytes]`;
+}
+/**
+ * Path-traversal guard: confirm `relative` resolves inside `root`.
+ * Throws if it escapes via `..` or an absolute prefix. Returns the
+ * absolute resolved path.
+ */
+function safeJoinInside(root, relative) {
+    if (nodePath.isAbsolute(relative)) {
+        throw new Error(`Path must be relative to the skill directory: ${relative}`);
+    }
+    const resolved = nodePath.resolve(root, relative);
+    const normalized = nodePath.resolve(root) + nodePath.sep;
+    if (resolved !== nodePath.resolve(root) && !resolved.startsWith(normalized)) {
+        throw new Error(`Path escapes the skill directory: ${relative}`);
+    }
+    return resolved;
+}
+async function readFileInSkill({ skillPath, relativePath, }) {
+    let absolute;
+    try {
+        absolute = safeJoinInside(skillPath, relativePath);
+    }
+    catch (err) {
+        return { error: err.message };
+    }
+    try {
+        const content = await fs.readFile(absolute, "utf8");
+        return { content: truncate(content, DEFAULT_READ_FILE_BYTES) };
+    }
+    catch (err) {
+        return { error: err.message };
+    }
+}
+async function runBashInSkill({ skillPath, command, abortSignal, }) {
+    return new Promise((resolvePromise) => {
+        let child;
+        try {
+            child = (0, node_child_process_1.spawn)("bash", ["-c", command], {
+                cwd: skillPath,
+                signal: abortSignal,
+            });
+        }
+        catch (err) {
+            resolvePromise({ error: err.message });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.once("close", (code) => {
+            resolvePromise({
+                exitCode: code,
+                stdout: truncate(stdout, DEFAULT_BASH_OUTPUT_BYTES),
+                stderr: truncate(stderr, DEFAULT_BASH_OUTPUT_BYTES),
+            });
+        });
+        child.once("error", (err) => {
+            resolvePromise({ error: err.message });
+        });
+    });
+}
+//# sourceMappingURL=agentSkillsRuntime.js.map

package/dist/commonjs/v3/agentSkillsRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentSkillsRuntime.js","sourceRoot":"","sources":["../../../src/v3/agentSkillsRuntime.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,104 @@
+/**
+ * Browser-safe primitives shared between `@trigger.dev/sdk/ai` (server) and
+ * `@trigger.dev/sdk/chat` / `@trigger.dev/sdk/chat/react` (client).
+ *
+ * This module exists to keep `ai.ts` reachable only from the server graph.
+ * `ai.ts` weighs in at ~7000 lines and statically imports the agent-skills
+ * runtime (which uses `node:child_process` / `node:fs/promises`). When a
+ * browser bundle imports a runtime value from `ai.ts` — historically the
+ * `PENDING_MESSAGE_INJECTED_TYPE` constant in `chat-react.ts` — the bundler
+ * traces `ai.ts`'s entire module graph into the client chunk and hits the
+ * `node:` builtins, which Turbopack rejects outright (and webpack flags as
+ * a "Critical dependency" warning).
+ *
+ * Anything in this file MUST stay free of `node:*` imports and free of any
+ * import from `ai.ts`.
+ */
+import type { Task, AnyTask } from "@trigger.dev/core/v3";
+import type { UIMessage } from "ai";
+/**
+ * Message-part `type` value for the pending-message data part the agent
+ * injects when a follow-up message arrives mid-turn.
+ */
+export declare const PENDING_MESSAGE_INJECTED_TYPE: "data-pending-message-injected";
+/**
+ * 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 friendlyId of the Session primitive backing this chat. The
+     * transport opens (or lazy-creates) the session with
+     * `externalId = chatId` on first message, then sends this friendlyId
+     * through to the run so the agent can attach to `.in` / `.out`
+     * without needing to round-trip through the control plane again.
+     * Optional for backward-compat while the migration is in flight;
+     * required once the legacy run-scoped stream path is removed.
+     */
+    sessionId?: string;
+    /**
+     * Client-side `chat.store` value sent by the transport. Applied at turn
+     * start before `run()` fires, overwriting any in-memory store value on the
+     * agent (last-write-wins).
+     *
+     * The transport queues this via `setStore` / `applyStorePatch` and flushes
+     * it with the next `sendMessage`. On the agent you typically don't read
+     * this directly — it's applied into `chat.store` transparently.
+     */
+    incomingStore?: unknown;
+};
+/**
+ * One chunk on the chat input stream. `kind` discriminates the variants —
+ * a single ordered stream now carries all the signals the old three-stream
+ * split did (`chat-messages`, `chat-stop`, plus action messages piggybacked
+ * on `chat-messages`).
+ */
+export type ChatInputChunk<TMessage extends UIMessage = UIMessage, TMetadata = unknown> = {
+    kind: "message";
+    /**
+     * Full wire payload for a new user message or regeneration. Mirrors
+     * what the legacy `chat-messages` input stream carried.
+     */
+    payload: ChatTaskWirePayload<TMessage, TMetadata>;
+} | {
+    kind: "stop";
+    /** Optional human-readable reason. Maps to the legacy `chat-stop` record. */
+    message?: string;
+};
+/**
+ * Extracts the client-data (`metadata`) type from a chat task.
+ *
+ * @example
+ * ```ts
+ * import type { InferChatClientData } from "@trigger.dev/sdk/ai";
+ * import type { myChat } from "@/trigger/chat";
+ *
+ * type MyClientData = InferChatClientData<typeof myChat>;
+ * ```
+ */
+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;

package/dist/commonjs/v3/ai-shared.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Browser-safe primitives shared between `@trigger.dev/sdk/ai` (server) and
+ * `@trigger.dev/sdk/chat` / `@trigger.dev/sdk/chat/react` (client).
+ *
+ * This module exists to keep `ai.ts` reachable only from the server graph.
+ * `ai.ts` weighs in at ~7000 lines and statically imports the agent-skills
+ * runtime (which uses `node:child_process` / `node:fs/promises`). When a
+ * browser bundle imports a runtime value from `ai.ts` — historically the
+ * `PENDING_MESSAGE_INJECTED_TYPE` constant in `chat-react.ts` — the bundler
+ * traces `ai.ts`'s entire module graph into the client chunk and hits the
+ * `node:` builtins, which Turbopack rejects outright (and webpack flags as
+ * a "Critical dependency" warning).
+ *
+ * Anything in this file MUST stay free of `node:*` imports and free of any
+ * import from `ai.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PENDING_MESSAGE_INJECTED_TYPE = void 0;
+/**
+ * Message-part `type` value for the pending-message data part the agent
+ * injects when a follow-up message arrives mid-turn.
+ */
+exports.PENDING_MESSAGE_INJECTED_TYPE = "data-pending-message-injected";
+//# sourceMappingURL=ai-shared.js.map

package/dist/commonjs/v3/ai-shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-shared.js","sourceRoot":"","sources":["../../../src/v3/ai-shared.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAKH;;;GAGG;AACU,QAAA,6BAA6B,GAAG,+BAAwC,CAAC"}

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

@@ -1,13 +1,12 @@
-import { AnyTask, Task, type inferSchemaIn, type inferSchemaOut, type TaskIdentifier, type TaskOptions, type TaskSchema, type TaskRunContext, type TaskWithSchema } from "@trigger.dev/core/v3";
+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 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 { TriggerChatTaskParams, TriggerChatTaskResult } from "./chat.js";
+import { type SessionTriggerConfig } from "@trigger.dev/core/v3";
 /** Re-export for typing `ctx` in `chat.agent` 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";
 import { type ChatStorePatchOperation } from "@trigger.dev/core/v3/chat-client";
 export type ToolCallExecutionOptions = {
     toolCallId: string;
@@ -133,13 +132,6 @@ export declare const ai: {
  * ```
  */
 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`/`chatAgent` (backend)
- * use this key by default.
- */
-export declare const CHAT_STREAM_KEY = "chat";
-export { CHAT_MESSAGES_STREAM_ID, CHAT_STOP_STREAM_ID };
 /**
  * Listener fired when the store value changes. `operations` is present for
  * `patch()` updates and absent for `set()` (which is a full snapshot).
@@ -188,35 +180,8 @@ export type ChatWriter = {
     /** 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" | "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;
-    /**
-     * Client-side `chat.store` value sent by the transport. Applied at turn
-     * start before `run()` fires, overwriting any in-memory store value on the
-     * agent (last-write-wins).
-     *
-     * The transport queues this via `setStore` / `applyStorePatch` and flushes
-     * it with the next `sendMessage`. On the agent you typically don't read
-     * this directly — it's applied into `chat.store` transparently.
-     */
-    incomingStore?: unknown;
-};
+import type { ChatTaskWirePayload } from "./ai-shared.js";
+export type { ChatTaskWirePayload, ChatInputChunk } from "./ai-shared.js";
 /**
  * The payload shape passed to the `chatAgent` run function.
  *
@@ -253,6 +218,14 @@ 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.
@@ -468,7 +441,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 declare const PENDING_MESSAGE_INJECTED_TYPE: "data-pending-message-injected";
+export { PENDING_MESSAGE_INJECTED_TYPE } from "./ai-shared.js";
 /**
  * Event passed to the `prepareMessages` hook.
  */
@@ -2309,32 +2282,58 @@ declare function chatLocal<T extends Record<string, unknown>>(options: {
  * // { model?: string; userId: string }
  * ```
  */
-export type InferChatClientData<TTask extends AnyTask> = TTask extends Task<string, ChatTaskWirePayload<any, infer TMetadata>, any> ? TMetadata : unknown;
+import type { InferChatClientData } from "./ai-shared.js";
+export type { InferChatClientData, InferChatUIMessage } from "./ai-shared.js";
 /**
- * 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>;
- * ```
+ * Options for {@link createChatStartSessionAction}.
  */
-export type InferChatUIMessage<TTask extends AnyTask> = TTask extends Task<string, ChatTaskWirePayload<infer TUIM extends UIMessage, any>, any> ? TUIM : UIMessage;
+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>;
+};
 /**
- * Options for {@link createChatTriggerAction}.
+ * Params for the function returned by {@link createChatStartSessionAction}.
  */
-export type CreateChatTriggerActionOptions = {
-    /** TTL for the run-scoped public access token. @default "1h" */
-    tokenTTL?: string | number | Date;
+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>;
 };
 /**
- * Creates a function that triggers a chat task and returns a run-scoped session.
+ * Result from {@link createChatStartSessionAction}'s returned function.
+ */
+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;
+};
+/**
+ * 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.
  *
- * 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.
+ * Wrap in a Next.js server action (or any server-side handler) so the
+ * customer's secret key never crosses to the browser.
  *
  * @example
  * ```ts
@@ -2342,18 +2341,23 @@ export type CreateChatTriggerActionOptions = {
  * "use server";
  * import { chat } from "@trigger.dev/sdk/ai";
  *
- * export const triggerChat = chat.createTriggerAction("my-chat");
+ * export const startChatSession = chat.createStartSessionAction("my-chat", {
+ *   triggerConfig: { machine: "small-1x" },
+ * });
  * ```
  *
- * Then pass it to the transport:
+ * Then in the browser:
  * ```tsx
  * const transport = useTriggerChatTransport({
  *   task: "my-chat",
- *   triggerTask: triggerChat,
+ *   accessToken: async ({ chatId }) => {
+ *     const { publicAccessToken } = await startChatSession({ chatId });
+ *     return publicAccessToken;
+ *   },
  * });
  * ```
  */
-declare function createChatTriggerAction(taskId: string, options?: CreateChatTriggerActionOptions): (params: TriggerChatTaskParams) => Promise<TriggerChatTaskResult>;
+declare function createChatStartSessionAction(taskId: string, options?: CreateChatStartSessionActionOptions): (params: ChatStartSessionParams) => Promise<ChatStartSessionResult>;
 export declare const chat: {
     /** Create a chat agent. See {@link chatAgent}. */
     agent: typeof chatAgent;
@@ -2363,8 +2367,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 trigger action helper. See {@link createChatTriggerAction}. */
-    createTriggerAction: typeof createChatTriggerAction;
+    /** Create a server-side helper for starting (or resuming) a Session for a chatId. See {@link createChatStartSessionAction}. */
+    createStartSessionAction: typeof createChatStartSessionAction;
     /** Pipe a stream to the chat transport. See {@link pipeChat}. */
     pipe: typeof pipeChat;
     /** Create a per-run typed local. See {@link chatLocal}. */
@@ -2392,7 +2396,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: import("@trigger.dev/core/v3").RealtimeDefinedStream<UIMessageChunk>;
+    stream: RealtimeDefinedStream<UIMessageChunk>;
     /** Write data parts that persist to the response message. See {@link chatResponse}. */
     response: {
         /**
@@ -2430,7 +2434,7 @@ export declare const chat: {
         onChange: typeof chatStoreOnChange;
     };
     /** 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>>;
+    messages: RealtimeDefinedInputStream<ChatTaskWirePayload>;
     /** 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}. */
@@ -2503,4 +2507,10 @@ 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;
 };