@trigger.dev/sdk 0.0.0-chat-prerelease-20260413144407 → 0.0.0-chat-prerelease-20260414181032

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

@@ -724,12 +724,18 @@ export type PipeChatOptions = {
  * Set static defaults via `uiMessageStreamOptions` on `chat.agent()`, or
  * override per-turn via `chat.setUIMessageStreamOptions()`.
  *
- * `onFinish`, `originalMessages`, and `generateMessageId` are omitted because
- * they are managed internally for response capture and message accumulation.
+ * `onFinish` is omitted because it is managed internally for response capture.
  * Use `streamText`'s `onFinish` for custom finish handling, or drop down to
  * raw task mode with `chat.pipe()` for full control.
+ *
+ * `originalMessages` is omitted because it is automatically set from the
+ * accumulated conversation history, ensuring message IDs are reused across
+ * turns (e.g. for tool approval continuations).
+ *
+ * `generateMessageId` can be set to control ID generation for response
+ * messages (e.g. UUID-v7). If not set, the AI SDK's default `generateId` is used.
  */
-export type ChatUIMessageStreamOptions<TUIM extends UIMessage = UIMessage> = Omit<UIMessageStreamOptions<TUIM>, "onFinish" | "originalMessages" | "generateMessageId">;
+export type ChatUIMessageStreamOptions<TUIM extends UIMessage = UIMessage> = Omit<UIMessageStreamOptions<TUIM>, "onFinish" | "originalMessages">;
 /**
  * An object with a `toUIMessageStream()` method (e.g. `StreamTextResult` from `streamText()`).
  */
@@ -1285,9 +1291,10 @@ export type ChatAgentOptions<TIdentifier extends string, TClientDataSchema exten
      * 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.
+     * `onFinish` and `originalMessages` are managed internally and cannot be
+     * overridden here. Use `streamText`'s `onFinish` for custom finish
+     * handling. `generateMessageId` can be set to control response message
+     * ID generation (e.g. UUID-v7).
      *
      * @example
      * ```ts
@@ -2097,6 +2104,14 @@ export declare const chat: {
     inject: typeof injectBackgroundContext;
     /** Typed chat output stream for writing custom chunks or piping from subtasks. */
     stream: import("@trigger.dev/core/v3").RealtimeDefinedStream<UIMessageChunk>;
+    /** Write data parts that persist to the response message. See {@link chatResponse}. */
+    response: {
+        /**
+         * Write a single chunk. Non-transient data parts are accumulated into the
+         * response message; everything else is stream-only.
+         */
+        write(part: UIMessageChunk): void;
+    };
     /** 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}. */

package/dist/commonjs/v3/ai.js

@@ -243,6 +243,43 @@ exports.CHAT_STREAM_KEY = chat_constants_js_1.CHAT_STREAM_KEY;
  * ```
  */
 const chatStream = streams_js_1.streams.define({ id: chat_constants_js_1.CHAT_STREAM_KEY });
+// ---------------------------------------------------------------------------
+// chat.response — write data parts that persist to the response message
+// ---------------------------------------------------------------------------
+/**
+ * Write data parts that both stream to the frontend AND persist in
+ * `onTurnComplete`'s `responseMessage` and `uiMessages`.
+ *
+ * Non-transient data chunks (`type` starts with `data-`, no `transient: true`)
+ * are queued for accumulation into the assistant response message.
+ * Transient or non-data chunks are streamed only (same as `chat.stream`).
+ *
+ * @example
+ * ```ts
+ * // Persists to responseMessage.parts
+ * chat.response.write({ type: "data-handover", data: { context: summary } });
+ *
+ * // Transient — streams only, not in responseMessage
+ * chat.response.write({ type: "data-progress", data: { percent: 50 }, transient: true });
+ * ```
+ */
+const chatResponse = {
+    /**
+     * Write a single chunk. Non-transient data parts are accumulated into the
+     * response message; everything else is stream-only.
+     */
+    write(part) {
+        queueResponsePart(part);
+        const { waitUntilComplete } = streams_js_1.streams.writer(exports.CHAT_STREAM_KEY, {
+            spanName: "chat.response.write",
+            collapsed: true,
+            execute: ({ write }) => {
+                write(part);
+            },
+        });
+        waitUntilComplete().catch(() => { });
+    },
+};
 /**
  * Creates a lazy ChatWriter that only opens a realtime stream on first use.
  * Call `flush()` after the callback returns to await stream completion.
@@ -274,6 +311,7 @@ function createLazyChatWriter() {
         writer: {
             write(part) {
                 ensureInitialized();
+                queueResponsePart(part);
                 writeImpl(part);
             },
             merge(stream) {
@@ -400,6 +438,30 @@ const chatPendingMessagesKey = locals_js_1.locals.create("chat.pendingMessages")
 const chatSteeringQueueKey = locals_js_1.locals.create("chat.steeringQueue");
 /** @internal — IDs of messages that were successfully injected via prepareStep */
 const chatInjectedMessageIdsKey = locals_js_1.locals.create("chat.injectedMessageIds");
+/** @internal — non-transient data parts queued via chat.response or writer.write() for accumulation into the response message */
+const chatResponsePartsKey = locals_js_1.locals.create("chat.responseParts");
+/**
+ * Check if a chunk is a non-transient data part that should persist to the response message.
+ * @internal
+ */
+function isNonTransientDataPart(part) {
+    if (typeof part !== "object" || part === null)
+        return false;
+    const p = part;
+    return typeof p.type === "string" && p.type.startsWith("data-") && p.transient !== true;
+}
+/**
+ * Queue a chunk for accumulation into the response message (if it's a non-transient data part).
+ * Called by `chat.response.write()` and `ChatWriter.write()`.
+ * @internal
+ */
+function queueResponsePart(part) {
+    if (!isNonTransientDataPart(part))
+        return;
+    const parts = locals_js_1.locals.get(chatResponsePartsKey) ?? [];
+    parts.push(part);
+    locals_js_1.locals.set(chatResponsePartsKey, parts);
+}
 /**
  * Check that no tool calls are in-flight in a step's content.
  * Used before compaction to avoid losing tool state mid-execution.
@@ -536,6 +598,7 @@ async function chatCompact(messages, steps, options) {
                     type: "data-compaction",
                     id: compactionId,
                     data: { status: "compacting", totalTokens },
+                    transient: true,
                 });
                 // Generate summary
                 summary = await options.summarize(messages);
@@ -576,6 +639,7 @@ async function chatCompact(messages, steps, options) {
                     type: "data-compaction",
                     id: compactionId,
                     data: { status: "complete", totalTokens },
+                    transient: true,
                 });
                 write({ type: "finish-step" });
             },
@@ -1174,6 +1238,7 @@ function chatAgent(options) {
                             locals_js_1.locals.set(chatDeferKey, new Set());
                             locals_js_1.locals.set(chatCompactionStateKey, undefined);
                             locals_js_1.locals.set(chatSteeringQueueKey, []);
+                            locals_js_1.locals.set(chatResponsePartsKey, []);
                             // NOTE: chatBackgroundQueueKey is NOT reset here — messages injected
                             // by deferred work from the previous turn's onTurnComplete need to
                             // survive into the next turn. The queue is drained before run().
@@ -1291,11 +1356,34 @@ function chatAgent(options) {
                                 // 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(...cleanedUIMessages);
-                                turnNewModelMessages.push(...incomingModelMessages);
-                                turnNewUIMessages.push(...cleanedUIMessages);
+                                // Submit: check if any incoming message updates an existing one (by ID).
+                                // This handles tool approval responses, where the frontend resends the
+                                // assistant message with updated tool parts (approval-responded).
+                                // IDs match because we always pass generateMessageId + originalMessages
+                                // to toUIMessageStream, so the backend's start chunk carries the same
+                                // messageId that the frontend uses.
+                                let replaced = false;
+                                for (const incoming of cleanedUIMessages) {
+                                    const idx = accumulatedUIMessages.findIndex((m) => m.id === incoming.id);
+                                    if (idx !== -1) {
+                                        accumulatedUIMessages[idx] = incoming;
+                                        replaced = true;
+                                    }
+                                    else {
+                                        accumulatedUIMessages.push(incoming);
+                                        turnNewUIMessages.push(incoming);
+                                    }
+                                }
+                                if (replaced) {
+                                    // Reconvert all model messages since a replacement changes the structure
+                                    accumulatedMessages = await toModelMessages(accumulatedUIMessages);
+                                }
+                                else {
+                                    accumulatedMessages.push(...incomingModelMessages);
+                                }
+                                if (turnNewUIMessages.length > 0) {
+                                    turnNewModelMessages.push(...(await toModelMessages(turnNewUIMessages)));
+                                }
                             }
                             // Mint a scoped public access token once per turn, reused for
                             // onChatStart, onTurnStart, onTurnComplete, and the turn-complete chunk.
@@ -1408,9 +1496,14 @@ function chatAgent(options) {
                             let onFinishAttached = false;
                             let runResult;
                             try {
-                                // Drain any messages injected by background work (e.g. self-review from previous turn)
+                                // Drain any messages injected by background work (e.g. self-review from previous turn).
+                                // Skip if the last message is a tool message — appending after it would
+                                // prevent streamText from finding pending tool approvals (it checks
+                                // the last message). The queued messages will be picked up by prepareStep
+                                // at the next step boundary instead.
+                                const lastAccumulated = accumulatedMessages[accumulatedMessages.length - 1];
                                 const bgQueue = locals_js_1.locals.get(chatBackgroundQueueKey);
-                                if (bgQueue && bgQueue.length > 0) {
+                                if (bgQueue && bgQueue.length > 0 && lastAccumulated?.role !== "tool") {
                                     accumulatedMessages.push(...bgQueue.splice(0));
                                 }
                                 runResult = await userRun({
@@ -1430,10 +1523,20 @@ function chatAgent(options) {
                                 // Auto-pipe if the run function returned a StreamTextResult or similar,
                                 // but only if pipeChat() wasn't already called manually during this turn.
                                 // We call toUIMessageStream ourselves to attach onFinish for response capture.
+                                // Pass originalMessages so the AI SDK reuses message IDs across turns
+                                // (e.g. for tool approval continuations / HITL flows).
                                 if ((locals_js_1.locals.get(chatPipeCountKey) ?? 0) === 0 && isUIMessageStreamable(runResult)) {
                                     onFinishAttached = true;
+                                    const resolvedOptions = resolveUIMessageStreamOptions();
                                     const uiStream = runResult.toUIMessageStream({
-                                        ...resolveUIMessageStreamOptions(),
+                                        ...resolvedOptions,
+                                        // Pass originalMessages so the AI SDK reuses message IDs across
+                                        // turns (e.g. for tool approval continuations / HITL flows).
+                                        originalMessages: accumulatedUIMessages,
+                                        // Always provide generateMessageId so the start chunk carries a
+                                        // messageId. Without this, the frontend and backend generate IDs
+                                        // independently and they won't match for ID-based dedup.
+                                        generateMessageId: resolvedOptions.generateMessageId ?? ai_1.generateId,
                                         onFinish: ({ responseMessage }) => {
                                             capturedResponseMessage = responseMessage;
                                             resolveOnFinish();
@@ -1554,6 +1657,15 @@ function chatAgent(options) {
                                 if (!capturedResponseMessage.id) {
                                     capturedResponseMessage = { ...capturedResponseMessage, id: (0, ai_1.generateId)() };
                                 }
+                                // Append any non-transient data parts queued via chat.response or writer.write()
+                                const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
+                                if (queuedParts && queuedParts.length > 0) {
+                                    capturedResponseMessage = {
+                                        ...capturedResponseMessage,
+                                        parts: [...capturedResponseMessage.parts, ...queuedParts],
+                                    };
+                                    locals_js_1.locals.set(chatResponsePartsKey, []);
+                                }
                                 accumulatedUIMessages.push(capturedResponseMessage);
                                 turnNewUIMessages.push(capturedResponseMessage);
                                 try {
@@ -1567,10 +1679,21 @@ function chatAgent(options) {
                                     // 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 there's no captured response (manual pipe mode) but there are
+                            // queued data parts, create a minimal response message to hold them.
+                            if (!capturedResponseMessage) {
+                                const remainingParts = locals_js_1.locals.get(chatResponsePartsKey);
+                                if (remainingParts && remainingParts.length > 0) {
+                                    capturedResponseMessage = {
+                                        id: (0, ai_1.generateId)(),
+                                        role: "assistant",
+                                        parts: [...remainingParts],
+                                    };
+                                    locals_js_1.locals.set(chatResponsePartsKey, []);
+                                    accumulatedUIMessages.push(capturedResponseMessage);
+                                    turnNewUIMessages.push(capturedResponseMessage);
+                                }
+                            }
                             if (runSignal.aborted)
                                 return "exit";
                             // Await deferred background work (e.g. DB writes from onTurnStart)
@@ -1612,6 +1735,7 @@ function chatAgent(options) {
                                                     type: "data-compaction",
                                                     id: compactionId,
                                                     data: { status: "compacting", totalTokens: turnUsage.totalTokens },
+                                                    transient: true,
                                                 });
                                                 const summary = await outerCompaction.summarize({
                                                     messages: accumulatedMessages,
@@ -1673,6 +1797,7 @@ function chatAgent(options) {
                                                     type: "data-compaction",
                                                     id: compactionId,
                                                     data: { status: "complete", totalTokens: turnUsage.totalTokens },
+                                                    transient: true,
                                                 });
                                             },
                                         });
@@ -1746,6 +1871,22 @@ function chatAgent(options) {
                                     },
                                 });
                             }
+                            // Drain any late response parts added during onBeforeTurnComplete
+                            const lateParts = locals_js_1.locals.get(chatResponsePartsKey);
+                            if (lateParts && lateParts.length > 0 && capturedResponseMessage) {
+                                const idx = accumulatedUIMessages.findIndex((m) => m.id === capturedResponseMessage.id);
+                                if (idx !== -1) {
+                                    const msg = accumulatedUIMessages[idx];
+                                    accumulatedUIMessages[idx] = {
+                                        ...msg,
+                                        parts: [...(msg.parts ?? []), ...lateParts],
+                                    };
+                                    capturedResponseMessage = accumulatedUIMessages[idx];
+                                    turnCompleteEvent.responseMessage = capturedResponseMessage;
+                                    turnCompleteEvent.uiMessages = accumulatedUIMessages;
+                                }
+                                locals_js_1.locals.set(chatResponsePartsKey, []);
+                            }
                             // Write turn-complete control chunk — closes the frontend stream.
                             const turnCompleteResult = await writeTurnCompleteChunk(currentWirePayload.chatId, turnAccessToken);
                             // Fire onTurnComplete — stream is closed, use for persistence.
@@ -2753,6 +2894,8 @@ function createChatSession(payload, options) {
                     }
                     // Reset stop signal for this turn
                     stop.reset();
+                    // Reset per-turn state
+                    locals_js_1.locals.set(chatResponsePartsKey, []);
                     // Set up steering queue and pending messages config in locals
                     // so toStreamTextOptions() auto-injects prepareStep for steering
                     const turnSteeringQueue = [];
@@ -2849,8 +2992,26 @@ function createChatSession(payload, options) {
                                 const cleaned = stop.signal.aborted && !runSignal.aborted
                                     ? cleanupAbortedParts(response)
                                     : response;
+                                // Append any non-transient data parts queued via chat.response or writer.write()
+                                const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
+                                if (queuedParts && queuedParts.length > 0) {
+                                    cleaned.parts = [...(cleaned.parts ?? []), ...queuedParts];
+                                    locals_js_1.locals.set(chatResponsePartsKey, []);
+                                }
                                 await accumulator.addResponse(cleaned);
                             }
+                            else {
+                                // No response (manual pipe mode) but there are queued data parts
+                                const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
+                                if (queuedParts && queuedParts.length > 0) {
+                                    await accumulator.addResponse({
+                                        id: (0, ai_1.generateId)(),
+                                        role: "assistant",
+                                        parts: queuedParts,
+                                    });
+                                    locals_js_1.locals.set(chatResponsePartsKey, []);
+                                }
+                            }
                             // Capture token usage from the streamText result
                             let turnUsage;
                             if (typeof source.totalUsage?.then === "function") {
@@ -2917,6 +3078,12 @@ function createChatSession(payload, options) {
                             return response;
                         },
                         async addResponse(response) {
+                            // Append any non-transient data parts queued via chat.response or writer.write()
+                            const queuedParts = locals_js_1.locals.get(chatResponsePartsKey);
+                            if (queuedParts && queuedParts.length > 0) {
+                                response = { ...response, parts: [...(response.parts ?? []), ...queuedParts] };
+                                locals_js_1.locals.set(chatResponsePartsKey, []);
+                            }
                             await accumulator.addResponse(response);
                         },
                         async done() {
@@ -3219,6 +3386,8 @@ exports.chat = {
     inject: injectBackgroundContext,
     /** Typed chat output stream for writing custom chunks or piping from subtasks. */
     stream: chatStream,
+    /** Write data parts that persist to the response message. See {@link chatResponse}. */
+    response: chatResponse,
     /** Pre-built input stream for receiving messages from the transport. */
     messages: messagesInput,
     /** Create a managed stop signal wired to the stop input stream. See {@link createStopSignal}. */