@trigger.dev/sdk 0.0.0-prerelease-20260304181730 → 0.0.0-prerelease-20260305183215

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

@@ -51,14 +51,14 @@ export { CHAT_MESSAGES_STREAM_ID, CHAT_STOP_STREAM_ID };
  *
  * - `messages` contains model-ready messages (converted via `convertToModelMessages`) —
  *   pass these directly to `streamText`.
- * - `uiMessages` contains the raw `UIMessage[]` from the frontend.
  * - `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 = {
     /** Model-ready messages — pass directly to `streamText({ messages })`. */
     messages: ModelMessage[];
-    /** Raw UI messages from the frontend. */
-    uiMessages: UIMessage[];
     /** The unique identifier for the chat session */
     chatId: string;
     /**
@@ -167,6 +167,72 @@ declare function pipeChat(source: UIMessageStreamable | AsyncIterable<unknown> |
  * emits a control chunk and suspends via `messagesInput.wait()`. The frontend
  * transport resumes the same run by sending the next message via input streams.
  */
+/**
+ * Event passed to the `onChatStart` callback.
+ */
+export type ChatStartEvent = {
+    /** 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: unknown;
+    /** 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;
+};
+/**
+ * Event passed to the `onTurnStart` callback.
+ */
+export type TurnStartEvent = {
+    /** 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: UIMessage[];
+    /** 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;
+};
+/**
+ * Event passed to the `onTurnComplete` callback.
+ */
+export type TurnCompleteEvent = {
+    /** 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: UIMessage[];
+    /**
+     * 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: UIMessage[];
+    /** The assistant's response for this turn (undefined if `pipeChat` was used manually). */
+    responseMessage: UIMessage | 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;
+};
 export type ChatTaskOptions<TIdentifier extends string> = Omit<TaskOptions<TIdentifier, ChatTaskWirePayload, unknown>, "run"> & {
     /**
      * The run function for the chat task.
@@ -178,6 +244,48 @@ export type ChatTaskOptions<TIdentifier extends string> = Omit<TaskOptions<TIden
      * the stream is automatically piped to the frontend.
      */
     run: (payload: ChatTaskRunPayload) => Promise<unknown>;
+    /**
+     * 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 ({ chatId, messages, clientData }) => {
+     *   await db.chat.create({ data: { id: chatId, userId: clientData.userId } });
+     * }
+     * ```
+     */
+    onChatStart?: (event: ChatStartEvent) => 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 ({ chatId, uiMessages }) => {
+     *   await db.chat.update({ where: { id: chatId }, data: { messages: uiMessages } });
+     * }
+     * ```
+     */
+    onTurnStart?: (event: TurnStartEvent) => Promise<void> | void;
+    /**
+     * Called after each turn completes (after the response is captured, before waiting
+     * for the next message). Also fires on the final turn.
+     *
+     * Use this to persist the conversation to your database after each assistant response.
+     *
+     * @example
+     * ```ts
+     * onTurnComplete: async ({ chatId, messages }) => {
+     *   await db.chat.update({ where: { id: chatId }, data: { messages } });
+     * }
+     * ```
+     */
+    onTurnComplete?: (event: TurnCompleteEvent) => 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
@@ -204,6 +312,16 @@ export type ChatTaskOptions<TIdentifier extends string> = Omit<TaskOptions<TIden
      * @default 30
      */
     warmTimeoutInSeconds?: 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;
 };
 /**
  * Creates a Trigger.dev task pre-configured for AI SDK chat.
@@ -234,27 +352,57 @@ export type ChatTaskOptions<TIdentifier extends string> = Omit<TaskOptions<TIden
  */
 declare function chatTask<TIdentifier extends string>(options: ChatTaskOptions<TIdentifier>): Task<TIdentifier, ChatTaskWirePayload, unknown>;
 /**
- * Namespace for AI SDK chat integration.
+ * 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
- * import { chat } from "@trigger.dev/sdk/ai";
+ * 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.
  *
- * // Define a chat task
- * export const myChat = chat.task({
- *   id: "my-chat",
- *   run: async ({ messages, signal }) => {
- *     return streamText({ model, messages, abortSignal: signal });
- *   },
- * });
+ * @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 warm timeout for subsequent turns in the current run.
  *
- * // Pipe a stream manually (from inside a task)
- * await chat.pipe(streamTextResult);
+ * The warm 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.
  *
- * // Create an access token (from a server action)
- * const token = await chat.createAccessToken("my-chat");
+ * @param seconds - Number of seconds to stay warm (0 to suspend immediately)
+ *
+ * @example
+ * ```ts
+ * run: async ({ messages, signal }) => {
+ *   chat.setWarmTimeoutInSeconds(60);
+ *   return streamText({ model, messages, abortSignal: signal });
+ * }
  * ```
  */
+declare function setWarmTimeoutInSeconds(seconds: number): void;
 export declare const chat: {
     /** Create a chat task. See {@link chatTask}. */
     task: typeof chatTask;
@@ -262,4 +410,10 @@ export declare const chat: {
     pipe: typeof pipeChat;
     /** 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 warm timeout at runtime. See {@link setWarmTimeoutInSeconds}. */
+    setWarmTimeoutInSeconds: typeof setWarmTimeoutInSeconds;
 };

package/dist/commonjs/v3/ai.js

@@ -79,7 +79,7 @@ exports.ai = {
  * ```
  */
 function createChatAccessToken(taskId) {
-    return auth_js_1.auth.createTriggerPublicToken(taskId, { multipleUse: true });
+    return auth_js_1.auth.createTriggerPublicToken(taskId, { expirationTime: "24h" });
 }
 // ---------------------------------------------------------------------------
 // Chat transport helpers — backend side
@@ -93,28 +93,6 @@ exports.CHAT_STREAM_KEY = chat_constants_js_1.CHAT_STREAM_KEY;
 // Input streams for bidirectional chat communication
 const messagesInput = streams_js_1.streams.input({ id: chat_constants_js_1.CHAT_MESSAGES_STREAM_ID });
 const stopInput = streams_js_1.streams.input({ id: chat_constants_js_1.CHAT_STOP_STREAM_ID });
-/**
- * Strips provider-specific IDs from message parts so that partial/stopped
- * assistant responses don't cause 404s when sent back to the provider
- * (e.g. OpenAI Responses API message IDs).
- * @internal
- */
-function sanitizeMessages(messages) {
-    return messages.map((msg) => {
-        if (msg.role !== "assistant" || !msg.parts)
-            return msg;
-        return {
-            ...msg,
-            parts: msg.parts.map((part) => {
-                // Strip provider-specific metadata (e.g. OpenAI Responses API itemId)
-                // and streaming state from assistant message parts. These cause 404s
-                // when partial/stopped responses are sent back to the provider.
-                const { providerMetadata, state, id, ...rest } = part;
-                return rest;
-            }),
-        };
-    });
-}
 /**
  * Tracks how many times `pipeChat` has been called in the current `chatTask` run.
  * Used to prevent double-piping when a user both calls `pipeChat()` manually
@@ -228,7 +206,7 @@ async function pipeChat(source, options) {
  * ```
  */
 function chatTask(options) {
-    const { run: userRun, maxTurns = 100, turnTimeout = "1h", warmTimeoutInSeconds = 30, ...restOptions } = options;
+    const { run: userRun, onChatStart, onTurnStart, onTurnComplete, maxTurns = 100, turnTimeout = "1h", warmTimeoutInSeconds = 30, chatAccessTokenTTL = "1h", ...restOptions } = options;
     return (0, shared_js_1.createTask)({
         ...restOptions,
         run: async (payload, { signal: runSignal }) => {
@@ -238,6 +216,13 @@ function chatTask(options) {
                 activeSpan.setAttribute("gen_ai.conversation.id", payload.chatId);
             }
             let currentWirePayload = payload;
+            // Accumulated model messages across turns. Turn 1 initialises from the
+            // full history the frontend sends; subsequent turns append only the new
+            // user message(s) and the captured assistant response.
+            let accumulatedMessages = [];
+            // Accumulated UI messages for persistence. Mirrors the model accumulator
+            // but in frontend-friendly UIMessage format (with parts, id, etc.).
+            let accumulatedUIMessages = [];
             // Mutable reference to the current turn's stop controller so the
             // stop input stream listener (registered once) can abort the right turn.
             let currentStopController;
@@ -287,23 +272,114 @@ function chatTask(options) {
                         const msgSub = messagesInput.on((msg) => {
                             pendingMessages.push(msg);
                         });
-                        // Convert wire payload to user-facing payload
-                        const sanitized = sanitizeMessages(uiMessages);
-                        const modelMessages = await (0, ai_1.convertToModelMessages)(sanitized);
+                        // Convert the incoming UIMessages to model messages and update the accumulator.
+                        // Turn 1: full history from the frontend → replaces the accumulator.
+                        // Turn 2+: only the new message(s) → appended to the accumulator.
+                        const incomingModelMessages = await (0, ai_1.convertToModelMessages)(uiMessages);
+                        // Track new messages for this turn (user input + assistant response).
+                        const turnNewModelMessages = [];
+                        const turnNewUIMessages = [];
+                        if (turn === 0) {
+                            accumulatedMessages = incomingModelMessages;
+                            accumulatedUIMessages = [...uiMessages];
+                            // On first turn, the "new" messages are just the last user message
+                            // (the rest is history). We'll add the response after streaming.
+                            if (uiMessages.length > 0) {
+                                turnNewUIMessages.push(uiMessages[uiMessages.length - 1]);
+                                const lastModel = incomingModelMessages[incomingModelMessages.length - 1];
+                                if (lastModel)
+                                    turnNewModelMessages.push(lastModel);
+                            }
+                        }
+                        else if (currentWirePayload.trigger === "regenerate-message") {
+                            // Regenerate: frontend sent full history with last assistant message
+                            // removed. Reset the accumulator to match.
+                            accumulatedMessages = incomingModelMessages;
+                            accumulatedUIMessages = [...uiMessages];
+                            // No new user messages for regenerate — just the response (added below)
+                        }
+                        else {
+                            // Submit: frontend sent only the new user message(s). Append to accumulator.
+                            accumulatedMessages.push(...incomingModelMessages);
+                            accumulatedUIMessages.push(...uiMessages);
+                            turnNewModelMessages.push(...incomingModelMessages);
+                            turnNewUIMessages.push(...uiMessages);
+                        }
+                        // Mint a scoped public access token once per turn, reused for
+                        // onChatStart, onTurnStart, onTurnComplete, and the turn-complete chunk.
+                        const currentRunId = v3_1.taskContext.ctx?.run.id ?? "";
+                        let turnAccessToken = "";
+                        if (currentRunId) {
+                            try {
+                                turnAccessToken = await auth_js_1.auth.createPublicToken({
+                                    scopes: {
+                                        read: { runs: currentRunId },
+                                        write: { inputStreams: currentRunId },
+                                    },
+                                    expirationTime: chatAccessTokenTTL,
+                                });
+                            }
+                            catch {
+                                // Token creation failed
+                            }
+                        }
+                        // Fire onChatStart on the first turn
+                        if (turn === 0 && onChatStart) {
+                            await tracer_js_1.tracer.startActiveSpan("onChatStart()", async () => {
+                                await onChatStart({
+                                    chatId: currentWirePayload.chatId,
+                                    messages: accumulatedMessages,
+                                    clientData: wireMetadata,
+                                    runId: currentRunId,
+                                    chatAccessToken: turnAccessToken,
+                                });
+                            }, {
+                                attributes: {
+                                    [v3_1.SemanticInternalAttributes.STYLE_ICON]: "task-hook-onStart",
+                                    [v3_1.SemanticInternalAttributes.COLLAPSED]: true,
+                                },
+                            });
+                        }
+                        // Fire onTurnStart before running user code — persist messages
+                        // so a mid-stream page refresh still shows the user's message.
+                        if (onTurnStart) {
+                            await tracer_js_1.tracer.startActiveSpan("onTurnStart()", async () => {
+                                await onTurnStart({
+                                    chatId: currentWirePayload.chatId,
+                                    messages: accumulatedMessages,
+                                    uiMessages: accumulatedUIMessages,
+                                    turn,
+                                    runId: currentRunId,
+                                    chatAccessToken: turnAccessToken,
+                                });
+                            }, {
+                                attributes: {
+                                    [v3_1.SemanticInternalAttributes.STYLE_ICON]: "task-hook-onStart",
+                                    [v3_1.SemanticInternalAttributes.COLLAPSED]: true,
+                                },
+                            });
+                        }
+                        // Captured by the onFinish callback below — works even on abort/stop.
+                        let capturedResponseMessage;
                         try {
                             const result = await userRun({
                                 ...restWire,
-                                messages: modelMessages,
-                                uiMessages: sanitized,
+                                messages: accumulatedMessages,
                                 clientData: wireMetadata,
                                 signal: combinedSignal,
                                 cancelSignal,
                                 stopSignal,
                             });
                             // Auto-pipe if the run function returned a StreamTextResult or similar,
-                            // but only if pipeChat() wasn't already called manually during this turn
+                            // but only if pipeChat() wasn't already called manually during this turn.
+                            // We call toUIMessageStream ourselves to attach onFinish for response capture.
                             if (_chatPipeCount === 0 && isUIMessageStreamable(result)) {
-                                await pipeChat(result, { signal: combinedSignal, spanName: "stream response" });
+                                const uiStream = result.toUIMessageStream({
+                                    onFinish: ({ responseMessage }) => {
+                                        capturedResponseMessage = responseMessage;
+                                    },
+                                });
+                                await pipeChat(uiStream, { signal: combinedSignal, spanName: "stream response" });
                             }
                         }
                         catch (error) {
@@ -321,10 +397,60 @@ function chatTask(options) {
                         finally {
                             msgSub.off();
                         }
+                        // Append the assistant's response (partial or complete) to the accumulator.
+                        // The onFinish callback fires even on abort/stop, so partial responses
+                        // from stopped generation are captured correctly.
+                        if (capturedResponseMessage) {
+                            // Ensure the response message has an ID (the stream's onFinish
+                            // may produce a message with an empty ID since IDs are normally
+                            // assigned by the frontend's useChat).
+                            if (!capturedResponseMessage.id) {
+                                capturedResponseMessage = { ...capturedResponseMessage, id: (0, ai_1.generateId)() };
+                            }
+                            accumulatedUIMessages.push(capturedResponseMessage);
+                            turnNewUIMessages.push(capturedResponseMessage);
+                            try {
+                                const responseModelMessages = await (0, ai_1.convertToModelMessages)([
+                                    stripProviderMetadata(capturedResponseMessage),
+                                ]);
+                                accumulatedMessages.push(...responseModelMessages);
+                                turnNewModelMessages.push(...responseModelMessages);
+                            }
+                            catch {
+                                // Conversion failed — skip accumulation for this turn
+                            }
+                        }
+                        // TODO: When the user calls `pipeChat` manually instead of returning a
+                        // StreamTextResult, we don't have access to onFinish. A future iteration
+                        // should let manual-mode users report back response messages for
+                        // accumulation (e.g. via a `chat.addMessages()` helper).
                         if (runSignal.aborted)
                             return "exit";
-                        // Write turn-complete control chunk so frontend closes its stream
-                        await writeTurnCompleteChunk(currentWirePayload.chatId);
+                        // Write turn-complete control chunk so frontend closes its stream.
+                        // Capture the lastEventId from the stream writer for resume support.
+                        const turnCompleteResult = await writeTurnCompleteChunk(currentWirePayload.chatId, turnAccessToken);
+                        // Fire onTurnComplete after response capture
+                        if (onTurnComplete) {
+                            await tracer_js_1.tracer.startActiveSpan("onTurnComplete()", async () => {
+                                await onTurnComplete({
+                                    chatId: currentWirePayload.chatId,
+                                    messages: accumulatedMessages,
+                                    uiMessages: accumulatedUIMessages,
+                                    newMessages: turnNewModelMessages,
+                                    newUIMessages: turnNewUIMessages,
+                                    responseMessage: capturedResponseMessage,
+                                    turn,
+                                    runId: currentRunId,
+                                    chatAccessToken: turnAccessToken,
+                                    lastEventId: turnCompleteResult.lastEventId,
+                                });
+                            }, {
+                                attributes: {
+                                    [v3_1.SemanticInternalAttributes.STYLE_ICON]: "task-hook-onComplete",
+                                    [v3_1.SemanticInternalAttributes.COLLAPSED]: true,
+                                },
+                            });
+                        }
                         // If messages arrived during streaming, use the first one immediately
                         if (pendingMessages.length > 0) {
                             currentWirePayload = pendingMessages[0];
@@ -332,9 +458,10 @@ function chatTask(options) {
                         }
                         // Phase 1: Keep the run warm for quick response to the next message.
                         // The run stays active (using compute) during this window.
-                        if (warmTimeoutInSeconds > 0) {
+                        const effectiveWarmTimeout = metadata_js_1.metadata.get(WARM_TIMEOUT_METADATA_KEY) ?? warmTimeoutInSeconds;
+                        if (effectiveWarmTimeout > 0) {
                             const warm = await messagesInput.once({
-                                timeoutMs: warmTimeoutInSeconds * 1000,
+                                timeoutMs: effectiveWarmTimeout * 1000,
                                 spanName: "waiting (warm)",
                             });
                             if (warm.ok) {
@@ -344,8 +471,9 @@ function chatTask(options) {
                             }
                         }
                         // Phase 2: Suspend the task (frees compute) until the next message arrives
+                        const effectiveTurnTimeout = metadata_js_1.metadata.get(TURN_TIMEOUT_METADATA_KEY) ?? turnTimeout;
                         const next = await messagesInput.wait({
-                            timeout: turnTimeout,
+                            timeout: effectiveTurnTimeout,
                             spanName: "waiting (suspended)",
                         });
                         if (!next.ok) {
@@ -390,6 +518,69 @@ function chatTask(options) {
  * const token = await chat.createAccessToken("my-chat");
  * ```
  */
+// ---------------------------------------------------------------------------
+// Runtime configuration helpers
+// ---------------------------------------------------------------------------
+const TURN_TIMEOUT_METADATA_KEY = "chat.turnTimeout";
+const WARM_TIMEOUT_METADATA_KEY = "chat.warmTimeout";
+/**
+ * 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 });
+ * }
+ * ```
+ */
+function setTurnTimeout(duration) {
+    metadata_js_1.metadata.set(TURN_TIMEOUT_METADATA_KEY, duration);
+}
+/**
+ * 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 });
+ * }
+ * ```
+ */
+function setTurnTimeoutInSeconds(seconds) {
+    metadata_js_1.metadata.set(TURN_TIMEOUT_METADATA_KEY, `${seconds}s`);
+}
+/**
+ * Override the warm timeout for subsequent turns in the current run.
+ *
+ * The warm 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 warm (0 to suspend immediately)
+ *
+ * @example
+ * ```ts
+ * run: async ({ messages, signal }) => {
+ *   chat.setWarmTimeoutInSeconds(60);
+ *   return streamText({ model, messages, abortSignal: signal });
+ * }
+ * ```
+ */
+function setWarmTimeoutInSeconds(seconds) {
+    metadata_js_1.metadata.set(WARM_TIMEOUT_METADATA_KEY, seconds);
+}
 exports.chat = {
     /** Create a chat task. See {@link chatTask}. */
     task: chatTask,
@@ -397,21 +588,30 @@ exports.chat = {
     pipe: pipeChat,
     /** Create a public access token for a chat task. See {@link createChatAccessToken}. */
     createAccessToken: createChatAccessToken,
+    /** Override the turn timeout at runtime (duration string). See {@link setTurnTimeout}. */
+    setTurnTimeout,
+    /** Override the turn timeout at runtime (seconds). See {@link setTurnTimeoutInSeconds}. */
+    setTurnTimeoutInSeconds,
+    /** Override the warm timeout at runtime. See {@link setWarmTimeoutInSeconds}. */
+    setWarmTimeoutInSeconds,
 };
 /**
  * Writes a turn-complete control chunk to the chat output stream.
  * The frontend transport intercepts this to close the ReadableStream for the current turn.
  * @internal
  */
-async function writeTurnCompleteChunk(chatId) {
+async function writeTurnCompleteChunk(chatId, publicAccessToken) {
     const { waitUntilComplete } = streams_js_1.streams.writer(exports.CHAT_STREAM_KEY, {
         spanName: "turn complete",
         collapsed: true,
         execute: ({ write }) => {
-            write({ type: "__trigger_turn_complete" });
+            write({
+                type: "__trigger_turn_complete",
+                ...(publicAccessToken ? { publicAccessToken } : {}),
+            });
         },
     });
-    await waitUntilComplete();
+    return await waitUntilComplete();
 }
 /**
  * Extracts the text content of the last user message from a UIMessage array.
@@ -436,4 +636,35 @@ function extractLastUserMessageText(messages) {
     }
     return undefined;
 }
+/**
+ * Strips ephemeral OpenAI Responses API `itemId` from a UIMessage's parts.
+ *
+ * The OpenAI Responses provider attaches `itemId` to message parts via
+ * `providerMetadata.openai.itemId`. These IDs are ephemeral — sending them
+ * back in a subsequent `streamText` call causes 404s because the provider
+ * can't find the referenced item (especially for stopped/partial responses).
+ *
+ * @internal
+ */
+function stripProviderMetadata(message) {
+    if (!message.parts)
+        return message;
+    return {
+        ...message,
+        parts: message.parts.map((part) => {
+            const openai = part.providerMetadata?.openai;
+            if (!openai?.itemId)
+                return part;
+            const { itemId, ...restOpenai } = openai;
+            const { openai: _, ...restProviders } = part.providerMetadata;
+            return {
+                ...part,
+                providerMetadata: {
+                    ...restProviders,
+                    ...(Object.keys(restOpenai).length > 0 ? { openai: restOpenai } : {}),
+                },
+            };
+        }),
+    };
+}
 //# sourceMappingURL=ai.js.map