@trigger.dev/sdk 4.7.1 → 4.7.3

package/dist/esm/v3/ai.js

@@ -4,10 +4,12 @@ import { accessoryAttributes, apiClientManager, controlSubtype, generateJWT, get
 import { trace } from "@opentelemetry/api";
 import { traceSessionIdle } from "./sessionTracing.js";
 import { waitForChatRouteAfterIdle } from "./chatRouteWait.js";
-import { tool as aiTool, convertToModelMessages, dynamicTool, generateId as generateMessageId, getToolName, isToolUIPart, jsonSchema, readUIMessageStream, streamText as aiStreamText, zodSchema, } from "../imports/ai-runtime.js";
+import { tool as aiTool, convertToModelMessages, dynamicTool, generateId as generateMessageId, getToolName, isToolUIPart, jsonSchema, streamText as aiStreamText, zodSchema, } from "../imports/ai-runtime.js";
 import { createTranscriptShadow, defaultStorage, diffTranscript, fingerprintMessage, parseTranscriptRuntimeState, restoreModelLane, } from "./transcriptStorage.js";
 import { responseAfterCompaction } from "./compactionResponse.js";
+import { withToolResultsInCallOrder } from "./toolResultOrder.js";
 import { ManagedChatResponse, createOrderedChatWriter } from "./managedChatResponse.js";
+import { reduceUIMessageChunks } from "./uiMessageChunks.js";
 import { convertSteeredMessages, retainStepMessages, steeringMarkers, } from "./steeringContext.js";
 let transcriptStorageOverride;
 /**
@@ -196,9 +198,9 @@ export function __setReplaySessionOutTailImplForTests(impl) {
  *   2. Filter out the agent's control chunks (`type: "trigger:*"`) — they
  *      ride on the same stream as the user-visible UIMessageChunks.
  *   3. Split chunks at `start`/`finish` boundaries so each segment is a
- *      single message, then feed each segment through the AI SDK's
- *      `readUIMessageStream` reducer (the same one `useChat` uses on the
- *      browser side) and grab the final emitted snapshot.
+ *      single message, then reduce each segment with the AI SDK's reducer
+ *      (the same one `useChat` uses on the browser side) via
+ *      {@link reduceUIMessageChunks}, which builds only the final state.
  *   4. The trailing message — if it never received a `finish` chunk —
  *      goes through `cleanupAbortedParts` so partial in-flight parts
  *      don't leak into the next turn's accumulator. Drop it entirely
@@ -249,8 +251,8 @@ async function replaySessionOutTail(sessionId, options) {
         }
         if (!current) {
             // Chunk arrived before any `start`. Synthesize a segment so the reducer
-            // has something to work with — `readUIMessageStream` tolerates a missing
-            // `start` because we pass `message: undefined`.
+            // has something to work with. The reducer tolerates a missing `start`
+            // and leaves the message ID empty.
             current = { chunks: [], closed: false };
             segments.push(current);
         }
@@ -266,18 +268,9 @@ async function replaySessionOutTail(sessionId, options) {
     for (let i = 0; i < segments.length; i++) {
         const seg = segments[i];
         const isTrailing = i === segments.length - 1 && !seg.closed;
-        const segmentStream = new ReadableStream({
-            start(controller) {
-                for (const c of seg.chunks)
-                    controller.enqueue(c);
-                controller.close();
-            },
-        });
         let last;
         try {
-            for await (const snapshot of readUIMessageStream({ stream: segmentStream })) {
-                last = snapshot;
-            }
+            last = await reduceUIMessageChunks(seg.chunks);
         }
         catch (error) {
             // Reducer error — the segment is malformed. Skip it and keep going so a
@@ -310,15 +303,15 @@ async function replaySessionOutTail(sessionId, options) {
 }
 /**
  * Test-only entry point that bypasses `__setReplaySessionOutTailImplForTests`
- * and reaches the real `apiClient.subscribeToSessionStream` + chunk-segment
- * splitter + `readUIMessageStream` reducer. Pairs with the snapshot
+ * and reaches the real `apiClient.readSessionStreamRecords` + chunk-segment
+ * splitter + {@link reduceUIMessageChunks} reducer. Pairs with the snapshot
  * production-path wrappers above. Lets `replay-session-out.test.ts` drive
  * synthetic chunk sequences through the real reducer to lock down chunk-
  * stream → `UIMessage[]` correctness — if the AI SDK's chunk semantics
  * shift in a future version, the test catches it before customers do.
  *
- * Tests should mock `apiClient.subscribeToSessionStream` (e.g. via
- * `vi.spyOn(apiClient, ...)`) to feed a `ReadableStream<UIMessageChunk>`.
+ * Tests should stub `apiClient.readSessionStreamRecords` to return the
+ * recorded chunks as session stream records.
  *
  * Not part of the public API.
  * @internal
@@ -3540,7 +3533,11 @@ function toStreamTextOptions(options, retain = true) {
                 });
                 locals.set(chatPendingBackgroundKey, pendingBackground);
             }
-            return resultMessages ? { messages: resultMessages } : undefined;
+            // 4. Parallel tool results in call order, the order the next turn's history
+            // will list them in. See `withToolResultsInCallOrder`.
+            const base = resultMessages ?? messages;
+            const ordered = withToolResultsInCallOrder(base);
+            return resultMessages || ordered !== base ? { messages: ordered } : undefined;
         };
     }
     if (retain && typeof result.prepareStep === "function") {
@@ -5745,8 +5742,11 @@ function chatAgent(options) {
                                     }
                                 }
                                 catch (error) {
-                                    // Handle AbortError from streamText gracefully
-                                    if (error instanceof Error && error.name === "AbortError") {
+                                    // A stop aborts with a string reason, which the managed pipe
+                                    // rethrows as-is. Match the reason itself so a real failure
+                                    // after a stop is still reported.
+                                    if ((error instanceof Error && error.name === "AbortError") ||
+                                        (combinedSignal.aborted && error === combinedSignal.reason)) {
                                         if (runSignal.aborted) {
                                             return "exit"; // Full run cancellation — exit
                                         }
@@ -7582,7 +7582,7 @@ function tapUIMessageChunks(source, buffer) {
  * 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
+ * same {@link reduceUIMessageChunks} reducer as the boot-time replay path. Returns
  * `undefined` if there's nothing to assemble or the reducer throws.
  */
 async function assemblePartialFromChunks(chunks) {
@@ -7593,18 +7593,7 @@ async function assemblePartialFromChunks(chunks) {
     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;
+        return await reduceUIMessageChunks(relevant);
     }
     catch {
         return undefined;
@@ -8850,6 +8839,7 @@ function createChatStartSessionAction(taskId, options) {
             taskIdentifier: taskId,
             triggerConfig,
             metadata: params.metadata,
+            ...(params.tags !== undefined ? { tags: params.tags } : {}),
         };
         const baseURLOption = options?.baseURL;
         const fetchOverride = options?.fetch;