@trigger.dev/sdk 4.5.5 → 4.5.7

package/dist/esm/v3/ai.js

@@ -5606,31 +5606,117 @@ function createStopSignal() {
  * The `TriggerChatTransport` intercepts this to close the ReadableStream
  * for the current turn. Call after piping the response stream.
  *
+ * Returns two resume cursors for the turn boundary, both saveable from the
+ * task instead of round-tripping them back from the client:
+ * - `lastEventId` — the turn-complete control record's seq_num on
+ *   `session.out`; where the next turn's output stream resumes.
+ * - `sessionInEventId` — the committed-consume cursor on `session.in` as of
+ *   this turn-complete, letting a raw loop correlate the boundary with the
+ *   exact input record it acknowledged. Trigger owns input-cursor recovery,
+ *   so this is for correlation / out-of-sync detection, not required.
+ *
+ * Either is `undefined` when the corresponding cursor isn't available.
+ *
  * @example
  * ```ts
  * await chat.pipe(result);
- * await chat.writeTurnComplete();
+ * const { lastEventId, sessionInEventId } = await chat.writeTurnComplete();
+ * await db.chats.update(chatId, { lastEventId, sessionInEventId });
  * ```
  */
 async function chatWriteTurnComplete(options) {
-    await writeTurnCompleteChunk(undefined, options?.publicAccessToken);
+    const result = await writeTurnCompleteChunk(undefined, options?.publicAccessToken);
+    // Same cursor written to the `session-in-event-id` header inside
+    // `writeTurnCompleteChunk`; surfaced here so the caller can persist it.
+    const inCursor = getChatSession().in.lastDispatchedSeqNum();
+    return {
+        lastEventId: result?.lastEventId,
+        ...(inCursor !== undefined ? { sessionInEventId: String(inCursor) } : {}),
+    };
+}
+/**
+ * Pass every chunk through untouched while recording it in `buffer`. Handles
+ * both the `AsyncIterable` and `ReadableStream` shapes `toUIMessageStream()`
+ * can return, and propagates a source error to the consumer after buffering
+ * whatever streamed first. See {@link pipeChatAndCapture} for why.
+ */
+async function* tapUIMessageChunks(source, buffer) {
+    if (isReadableStream(source)) {
+        const reader = source.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer.push(value);
+                yield value;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    else {
+        for await (const chunk of source) {
+            buffer.push(chunk);
+            yield chunk;
+        }
+    }
+}
+/**
+ * Reconstruct a partial assistant `UIMessage` from the raw chunks that
+ * streamed before a failure — the fallback for {@link pipeChatAndCapture}
+ * when a transport error abandons the stream before `onFinish` runs. Uses the
+ * same `readUIMessageStream` reducer as the boot-time replay path. Returns
+ * `undefined` if there's nothing to assemble or the reducer throws.
+ */
+async function assemblePartialFromChunks(chunks) {
+    const relevant = chunks.filter((c) => {
+        const type = c.type;
+        return typeof type === "string" && !type.startsWith("trigger:");
+    });
+    if (relevant.length === 0)
+        return undefined;
+    try {
+        const stream = new ReadableStream({
+            start(controller) {
+                for (const chunk of relevant)
+                    controller.enqueue(chunk);
+                controller.close();
+            },
+        });
+        let last;
+        for await (const message of readUIMessageStream({ stream })) {
+            last = message;
+        }
+        return last;
+    }
+    catch {
+        return undefined;
+    }
 }
 /**
  * Pipe a `StreamTextResult` (or similar) to the chat stream and capture
  * the assistant's response message via `onFinish`.
  *
  * Combines `toUIMessageStream()` + `onFinish` callback + `chat.pipe()`.
- * Returns the captured `UIMessage`, or `undefined` if capture failed.
+ * Never throws on a stopped or failed stream: it returns a
+ * {@link PipeAndCaptureResult} whose `message` holds any partial output
+ * captured before the stop/failure, alongside a typed `status` (and `error`
+ * on failure). Save the partial after a stop or error without separate
+ * capture logic.
  *
  * @example
  * ```ts
  * const result = streamText({ model, messages, abortSignal: signal });
- * const response = await chat.pipeAndCapture(result, { signal });
- * if (response) conversation.addResponse(response);
+ * const { message, status, error } = await chat.pipeAndCapture(result, { signal });
+ * if (message) conversation.addResponse(message);
+ * if (status === "error") logger.error("turn failed", { error });
  * ```
  */
 async function pipeChatAndCapture(source, options) {
     let captured;
+    let capturedFinishReason;
     let resolveOnFinish;
     const onFinishPromise = new Promise((r) => {
         resolveOnFinish = r;
@@ -5648,17 +5734,57 @@ async function pipeChatAndCapture(source, options) {
         // the frontend replaces the partial message — wiping the
         // pre-injection text from the UI and the captured response.
         generateMessageId: resolvedOptions.generateMessageId ?? generateMessageId,
-        onFinish: ({ responseMessage }) => {
+        onFinish: ({ responseMessage, finishReason, }) => {
             captured = responseMessage;
+            capturedFinishReason = finishReason;
             resolveOnFinish();
         },
     });
-    await pipeChat(uiStream, {
-        signal: options?.signal,
-        spanName: options?.spanName ?? "stream response",
-    });
-    await onFinishPromise;
-    return captured;
+    // Buffer chunks as they flow to the pipe so a transport failure that
+    // abandons the UI stream before `onFinish` fires — the one termination path
+    // that skips `onFinish` — can still reconstruct the partial. This retains
+    // chunk references only; the reassembly runs solely in the failure fallback
+    // below, so the happy path pays nothing extra.
+    const bufferedChunks = [];
+    const tappedStream = tapUIMessageChunks(uiStream, bufferedChunks);
+    let status = "complete";
+    let error;
+    try {
+        await pipeChat(tappedStream, {
+            signal: options?.signal,
+            spanName: options?.spanName ?? "stream response",
+        });
+        // The pipe can drain cleanly on a stop — the source stream just ends
+        // early — so classify by the signal rather than relying on a throw.
+        if (options?.signal?.aborted) {
+            status = "aborted";
+        }
+    }
+    catch (err) {
+        if ((err instanceof Error && err.name === "AbortError") || options?.signal?.aborted) {
+            status = "aborted";
+        }
+        else {
+            status = "error";
+            error = err;
+        }
+    }
+    // `onFinish` fires even on abort, carrying the partial — but a hard stop can
+    // prevent it from firing at all, so race it against a timeout to avoid
+    // hanging the caller. Mirrors chat.agent's capture path.
+    await Promise.race([onFinishPromise, new Promise((r) => setTimeout(r, 2_000))]);
+    // A transport failure can abandon the UI stream before `onFinish` fires, so
+    // reconstruct the partial from the buffered chunks rather than losing output
+    // that already streamed. Only runs when `onFinish` produced nothing.
+    if (!captured && bufferedChunks.length > 0) {
+        captured = await assemblePartialFromChunks(bufferedChunks);
+    }
+    return {
+        message: captured,
+        status,
+        finishReason: capturedFinishReason,
+        ...(error !== undefined ? { error } : {}),
+    };
 }
 /**
  * Accumulates conversation messages across turns.
@@ -5673,8 +5799,8 @@ async function pipeChatAndCapture(source, options) {
  * for (let turn = 0; turn < 100; turn++) {
  *   const messages = await conversation.addIncoming(payload.messages, payload.trigger, turn);
  *   const result = streamText({ model, messages });
- *   const response = await chat.pipeAndCapture(result);
- *   if (response) await conversation.addResponse(response);
+ *   const { message } = await chat.pipeAndCapture(result);
+ *   if (message) await conversation.addResponse(message);
  * }
  * ```
  */
@@ -6168,7 +6294,7 @@ function createChatSession(payload, options) {
                             }
                             let response;
                             try {
-                                response = await pipeChatAndCapture(source, {
+                                const captured = await pipeChatAndCapture(source, {
                                     signal: combinedSignal,
                                     // On a non-final handover turn, thread the spliced partial so a
                                     // resumed tool round's tool-output chunks merge into the
@@ -6177,20 +6303,18 @@ function createChatSession(payload, options) {
                                     // fresh response into the prior assistant message).
                                     ...(handoverThisTurn ? { originalMessages: accumulator.uiMessages } : {}),
                                 });
-                            }
-                            catch (error) {
-                                if (error instanceof Error && error.name === "AbortError") {
-                                    if (runSignal.aborted) {
-                                        // Full cancel — don't accumulate
-                                        sessionMsgSub.off();
-                                        await chatWriteTurnComplete();
-                                        return undefined;
-                                    }
-                                    // Stop — fall through to accumulate partial response
+                                if (runSignal.aborted) {
+                                    // Full cancel — don't accumulate
+                                    sessionMsgSub.off();
+                                    await chatWriteTurnComplete();
+                                    return undefined;
                                 }
-                                else {
-                                    throw error;
+                                // Surface a genuine stream failure to the caller. A user stop
+                                // (status "aborted") falls through so the partial is accumulated.
+                                if (captured.status === "error") {
+                                    throw captured.error;
                                 }
+                                response = captured.message;
                             }
                             finally {
                                 // Detach at stream end (like the agent loop): the steering queue