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

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

@@ -2104,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().
@@ -1592,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 {
@@ -1605,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)
@@ -1650,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,
@@ -1711,6 +1797,7 @@ function chatAgent(options) {
                                                     type: "data-compaction",
                                                     id: compactionId,
                                                     data: { status: "complete", totalTokens: turnUsage.totalTokens },
+                                                    transient: true,
                                                 });
                                             },
                                         });
@@ -1784,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.
@@ -2791,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 = [];
@@ -2887,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") {
@@ -2955,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() {
@@ -3257,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}. */