@trigger.dev/sdk 4.6.1 → 4.6.3

package/dist/esm/v3/ai.js

@@ -2,8 +2,10 @@ import { accessoryAttributes, apiClientManager, controlSubtype, generateJWT, get
 // Runtime VALUES go through the ESM/CJS shim so the CJS build can `require`
 // ESM-only `ai@7` (see ../imports/ai-runtime.ts).
 import { trace } from "@opentelemetry/api";
+import { traceSessionIdle } from "./sessionTracing.js";
 import { tool as aiTool, convertToModelMessages, dynamicTool, generateId as generateMessageId, getToolName, isToolUIPart, jsonSchema, readUIMessageStream, streamText as aiStreamText, zodSchema, } from "../imports/ai-runtime.js";
 import { createTranscriptShadow, defaultStorage, diffTranscript, fingerprintMessage, parseTranscriptRuntimeState, restoreModelLane, } from "./transcriptStorage.js";
+import { responseAfterCompaction } from "./compactionResponse.js";
 let transcriptStorageOverride;
 /**
  * Test-only override for the storage `chat.agent` persists through, so a
@@ -1087,7 +1089,7 @@ async function waitOnChatRoute(route, options) {
     return tracer.startActiveSpan(options.spanName ?? `chat.${route}.wait()`, async (span) => {
         const idleMs = (options.idleTimeoutInSeconds ?? 0) * 1000;
         if (idleMs > 0) {
-            const warm = await router.next(route, { timeoutMs: idleMs });
+            const warm = await traceSessionIdle(session.id, idleMs / 1000, () => router.next(route, { timeoutMs: idleMs }));
             if (warm) {
                 span.setAttribute("wait.resolved", "idle");
                 return { ok: true, output: warm.data, record: warm };
@@ -1141,10 +1143,6 @@ async function waitOnChatRoute(route, options) {
             session: session.id,
             io: "in",
             route,
-            ...accessoryAttributes({
-                items: [{ text: `${session.id}.in:${route}`, variant: "normal" }],
-                style: "codepath",
-            }),
         },
     });
 }
@@ -1820,6 +1818,14 @@ const chatHandoverPartialKey = locals.create("chat.handoverPartial");
  * @internal
  */
 const chatHandoverMessageIdKey = locals.create("chat.handoverMessageId");
+/**
+ * The model messages a turn-0 head-start splice contributed to the model lane,
+ * keyed by the UI message id it was synthesized under. When the agent's response
+ * completes that message under the same id, this is the run to replace: the UI
+ * form alone converts to something else (its pending tool calls drop out, the
+ * approval round was never on it), so it cannot locate the run itself.
+ */
+const chatHandoverSplicedRunKey = locals.create("chat.handoverSplicedRun");
 /**
  * Run-scoped slot indicating that the customer's step-1 head-start
  * response is the FINAL turn response. When true, turn 0 runs through
@@ -1903,16 +1909,19 @@ function synthesizeHandoverUIMessage(partial, messageId) {
  */
 function spliceHandoverPartial(modelMessages, uiMessages, signal) {
     if (!signal.partialAssistantMessage || signal.partialAssistantMessage.length === 0) {
-        return;
+        return undefined;
     }
     // Skip if the hydrated chain already persisted the partial under this id.
     const alreadyInChain = signal.messageId !== undefined && uiMessages.some((m) => m.id === signal.messageId);
     if (alreadyInChain)
-        return;
-    modelMessages.push(...signal.partialAssistantMessage);
+        return undefined;
+    const run = [...signal.partialAssistantMessage];
+    modelMessages.push(...run);
     const partialUI = synthesizeHandoverUIMessage(signal.partialAssistantMessage, signal.messageId);
-    if (partialUI)
-        uiMessages.push(partialUI);
+    if (!partialUI)
+        return undefined;
+    uiMessages.push(partialUI);
+    return { id: partialUI.id, run };
 }
 /**
  * Per-turn background context queue. Messages added via `chat.backgroundWork.inject()`
@@ -2782,6 +2791,7 @@ async function chatCompact(messages, steps, options) {
                 locals.set(chatCompactionStateKey, {
                     summary,
                     baseResponseMessageCount: currentStep.response.messages.length,
+                    baseResponseStepCount: steps.length,
                 });
                 // Set model-only override — UI messages stay intact for persistence.
                 // The summary becomes the model message history for the next turn,
@@ -3652,8 +3662,8 @@ function isActionTurn(value) {
  * tail does not match the old message's conversion, nothing is changed and
  * `false` is returned so the caller can fall back to a full reconversion.
  */
-async function replaceModelRun(lane, oldUi, newUi, tailAfter) {
-    const oldRun = await toModelMessages([stripProviderMetadata(oldUi)]);
+async function replaceModelRun(lane, oldUi, newUi, tailAfter, knownOldRun) {
+    const oldRun = knownOldRun ?? (await toModelMessages([stripProviderMetadata(oldUi)]));
     const newRun = await toModelMessages([stripProviderMetadata(newUi)]);
     // A message that converts to nothing (a pending tool call with no output yet,
     // which `ignoreIncompleteToolCalls` drops) locates no run in the lane. Matching
@@ -4785,7 +4795,7 @@ function chatAgent(options) {
                     const preloadResult = await messagesInput.waitWithIdleTimeout({
                         idleTimeoutInSeconds: effectivePreloadIdleTimeout,
                         timeout: effectivePreloadTimeout,
-                        spanName: "waiting for first message",
+                        spanName: "first message",
                         skipSuspend: exitAfterPreloadIdle,
                         onSuspend: onChatSuspend
                             ? async () => {
@@ -4937,7 +4947,7 @@ function chatAgent(options) {
                         const continuationResult = await messagesInput.waitWithIdleTimeout({
                             idleTimeoutInSeconds: effectiveIdleTimeout,
                             timeout: effectiveTurnTimeout,
-                            spanName: "waiting for first message (continuation)",
+                            spanName: "first message (continuation)",
                             onSuspend: onChatSuspend
                                 ? async () => {
                                     await tracer.startActiveSpan("onChatSuspend()", async () => {
@@ -5466,10 +5476,12 @@ function chatAgent(options) {
                                     // `UIMessageStreamError: No tool invocation found`.
                                     const pendingHandoverPartial = locals.get(chatHandoverPartialKey);
                                     if (pendingHandoverPartial && pendingHandoverPartial.length > 0) {
-                                        spliceHandoverPartial(accumulatedMessages, accumulatedUIMessages, {
+                                        const spliced = spliceHandoverPartial(accumulatedMessages, accumulatedUIMessages, {
                                             partialAssistantMessage: pendingHandoverPartial,
                                             messageId: locals.get(chatHandoverMessageIdKey),
                                         });
+                                        if (spliced)
+                                            locals.set(chatHandoverSplicedRunKey, spliced);
                                         locals.set(chatHandoverPartialKey, []); // consume once
                                         splicedHandoverPartial = true;
                                     }
@@ -5814,6 +5826,7 @@ function chatAgent(options) {
                                 // never reports final usage), which would block the turn loop
                                 // from ever firing onTurnComplete / writeTurnComplete.
                                 let turnUsage;
+                                let lastStepUsage;
                                 if (runResult != null &&
                                     typeof runResult.totalUsage?.then === "function") {
                                     try {
@@ -5826,6 +5839,18 @@ function chatAgent(options) {
                                         /* non-fatal — usage capture failed */
                                     }
                                 }
+                                const lastStepUsagePromise = runResult != null ? runResult.usage : undefined;
+                                if (typeof lastStepUsagePromise?.then === "function") {
+                                    try {
+                                        lastStepUsage = (await Promise.race([
+                                            lastStepUsagePromise,
+                                            new Promise((r) => setTimeout(() => r(undefined), 2_000)),
+                                        ]));
+                                    }
+                                    catch {
+                                        /* non-fatal — usage capture failed */
+                                    }
+                                }
                                 if (turnUsage) {
                                     cumulativeUsage = addUsage(cumulativeUsage, turnUsage);
                                     previousTurnUsage = turnUsage;
@@ -5876,6 +5901,13 @@ function chatAgent(options) {
                                 // Check if compaction set a model-only override (preserves UI messages).
                                 // Apply compactUIMessages/compactModelMessages callbacks if configured.
                                 const modelOnlyOverride = locals.get(chatOverrideModelMessagesKey);
+                                const responseCompaction = modelOnlyOverride
+                                    ? locals.get(chatCompactionStateKey)
+                                    : undefined;
+                                // Capture the original assistant before compactUIMessages can remove it.
+                                const originalResponse = responseCompaction && capturedResponseMessage
+                                    ? accumulatedUIMessages.find((m) => m.id === capturedResponseMessage?.id)
+                                    : undefined;
                                 if (modelOnlyOverride) {
                                     const compactionSummary = locals.get(chatCompactionStateKey)?.summary ?? "";
                                     const taskCompactionConfig = locals.get(chatAgentCompactionKey);
@@ -5967,12 +5999,39 @@ function chatAgent(options) {
                                         // rationale (TRI-9137).
                                         recordToolCallIdsFromMessage(capturedResponseMessage);
                                         try {
+                                            const responseForModel = responseAfterCompaction(capturedResponseMessage, responseCompaction?.baseResponseStepCount, originalResponse);
+                                            // Preserve the complete persistence response, including same-ID
+                                            // replacements whose old tool parts can contain new results.
+                                            // Convert prefix and suffix separately so each tool output is
+                                            // converted once, while only the suffix enters model context.
+                                            const responsePrefixMessages = responseCompaction
+                                                ? await toModelMessages([
+                                                    stripProviderMetadata({
+                                                        ...capturedResponseMessage,
+                                                        parts: capturedResponseMessage.parts.slice(0, capturedResponseMessage.parts.length -
+                                                            responseForModel.parts.length),
+                                                    }),
+                                                ])
+                                                : [];
                                             const responseModelMessages = await toModelMessages([
-                                                stripProviderMetadata(capturedResponseMessage),
+                                                stripProviderMetadata(responseForModel),
                                             ]);
-                                            if (existingIdx !== -1) {
+                                            if (responseCompaction) {
+                                                // The summary already replaced the original response, including
+                                                // a same-ID approval/handover prefix. Replacing its old model run
+                                                // would miss and fall back to the full, uncompacted UI history.
+                                                accumulatedMessages.push(...responseModelMessages);
+                                                locals.set(chatHandoverSplicedRunKey, undefined);
+                                            }
+                                            else if (existingIdx !== -1) {
+                                                const spliced = locals.get(chatHandoverSplicedRunKey);
+                                                const splicedRun = spliced && previousAtIdx && spliced.id === previousAtIdx.id
+                                                    ? spliced.run
+                                                    : undefined;
                                                 const ok = previousAtIdx !== undefined &&
-                                                    (await replaceModelRun(accumulatedMessages, previousAtIdx, capturedResponseMessage, steerTailThisTurn));
+                                                    (await replaceModelRun(accumulatedMessages, previousAtIdx, capturedResponseMessage, steerTailThisTurn, splicedRun));
+                                                if (splicedRun)
+                                                    locals.set(chatHandoverSplicedRunKey, undefined);
                                                 if (!ok) {
                                                     logger.warn("chat.agent: replaced response not found at the model lane tail; reconverting the lane");
                                                     accumulatedMessages = await toModelMessages(accumulatedUIMessages);
@@ -5983,7 +6042,7 @@ function chatAgent(options) {
                                             else {
                                                 accumulatedMessages.push(...responseModelMessages);
                                             }
-                                            turnNewModelMessages.push(...responseModelMessages);
+                                            turnNewModelMessages.push(...responsePrefixMessages, ...responseModelMessages);
                                         }
                                         catch {
                                             // Conversion failed — skip accumulation for this turn
@@ -6032,12 +6091,14 @@ function chatAgent(options) {
                                 const outerCompaction = locals.get(chatAgentCompactionKey);
                                 const innerCompactionState = locals.get(chatCompactionStateKey);
                                 if (outerCompaction && !innerCompactionState && turnUsage && !wasStopped) {
+                                    const contextUsage = lastStepUsage ?? turnUsage;
                                     const shouldTrigger = await outerCompaction.shouldCompact({
                                         messages: accumulatedMessages,
-                                        totalTokens: turnUsage.totalTokens,
-                                        inputTokens: turnUsage.inputTokens,
-                                        outputTokens: turnUsage.outputTokens,
-                                        usage: turnUsage,
+                                        totalTokens: contextUsage.totalTokens,
+                                        inputTokens: contextUsage.inputTokens,
+                                        outputTokens: contextUsage.outputTokens,
+                                        usage: contextUsage,
+                                        turnUsage,
                                         totalUsage: cumulativeUsage,
                                         chatId: currentWirePayload.chatId,
                                         turn,
@@ -6362,7 +6423,7 @@ function chatAgent(options) {
                             const next = await messagesInput.waitWithIdleTimeout({
                                 idleTimeoutInSeconds: effectiveIdleTimeout,
                                 timeout: effectiveTurnTimeout,
-                                spanName: "waiting for next message",
+                                spanName: "next message",
                                 onSuspend: onChatSuspend
                                     ? async () => {
                                         await tracer.startActiveSpan("onChatSuspend()", async () => {
@@ -6699,7 +6760,7 @@ function chatAgent(options) {
                         const next = await messagesInput.waitWithIdleTimeout({
                             idleTimeoutInSeconds: effectiveIdleTimeout,
                             timeout: effectiveTurnTimeout,
-                            spanName: "waiting for next message (after error)",
+                            spanName: "next message (after error)",
                         });
                         if (!next.ok) {
                             return; // Timed out — end run gracefully
@@ -7739,6 +7800,8 @@ class ChatMessageAccumulator {
     modelMessages = [];
     uiMessages = [];
     _compaction;
+    /** The run a spliced head-start partial contributed, until its response replaces it. */
+    _handoverRun;
     _pendingMessages;
     _steeringQueue = [];
     constructor(options) {
@@ -7782,7 +7845,7 @@ class ChatMessageAccumulator {
      * `consumeHandover` for the wait+seed+apply convenience.
      */
     applyHandover(signal) {
-        spliceHandoverPartial(this.modelMessages, this.uiMessages, signal);
+        this._handoverRun = spliceHandoverPartial(this.modelMessages, this.uiMessages, signal);
     }
     /**
      * One-call `chat.headStart` handover for a custom-agent loop: waits for the
@@ -7825,8 +7888,13 @@ class ChatMessageAccumulator {
         if (existingIdx !== -1) {
             const previous = this.uiMessages[existingIdx];
             this.uiMessages[existingIdx] = response;
+            const handoverRun = this._handoverRun && this._handoverRun.id === previous.id
+                ? this._handoverRun.run
+                : undefined;
+            if (handoverRun)
+                this._handoverRun = undefined;
             try {
-                if (!(await replaceModelRun(this.modelMessages, previous, response, 0))) {
+                if (!(await replaceModelRun(this.modelMessages, previous, response, 0, handoverRun))) {
                     this.modelMessages = await toModelMessages(this.uiMessages.map((m) => stripProviderMetadata(m)));
                 }
             }
@@ -7929,8 +7997,10 @@ class ChatMessageAccumulator {
     }
     /**
      * Run outer-loop compaction if needed. Call after adding the response
-     * and capturing usage. Applies `compactModelMessages` and `compactUIMessages`
-     * callbacks if configured.
+     * and capturing usage. Pass the LAST step's usage (`result.usage`), which is
+     * the context the model held on its final call; `result.totalUsage` sums every
+     * step of a tool-using turn and belongs in `context.turnUsage`. Applies
+     * `compactModelMessages` and `compactUIMessages` callbacks if configured.
      *
      * @returns `true` if compaction was performed, `false` otherwise.
      */
@@ -7943,6 +8013,7 @@ class ChatMessageAccumulator {
             inputTokens: usage.inputTokens,
             outputTokens: usage.outputTokens,
             usage,
+            turnUsage: context?.turnUsage,
             totalUsage: context?.totalUsage,
             chatId: context?.chatId,
             turn: context?.turn,
@@ -8175,8 +8246,8 @@ function createChatSession(payload, options) {
                             idleTimeoutInSeconds: sessionIdleTimeoutOpt ?? currentPayload.idleTimeoutInSeconds ?? 30,
                             timeout,
                             spanName: currentPayload.trigger === "preload"
-                                ? "waiting for first message"
-                                : "waiting for first message (continuation)",
+                                ? "first message"
+                                : "first message (continuation)",
                         });
                         if (!result.ok || runSignal.aborted) {
                             stop.cleanup();
@@ -8213,7 +8284,7 @@ function createChatSession(payload, options) {
                         const next = await messagesInput.waitWithIdleTimeout({
                             idleTimeoutInSeconds,
                             timeout,
-                            spanName: "waiting for next message",
+                            spanName: "next message",
                         });
                         if (!next.ok || runSignal.aborted) {
                             stop.cleanup();
@@ -8424,6 +8495,7 @@ function createChatSession(payload, options) {
                             // indefinitely, which would wedge the turn loop (same guard as
                             // chat.agent's turn loop).
                             let turnUsage;
+                            let lastStepUsage;
                             if (typeof source.totalUsage?.then === "function") {
                                 try {
                                     const usage = (await Promise.race([
@@ -8440,14 +8512,28 @@ function createChatSession(payload, options) {
                                     /* non-fatal */
                                 }
                             }
+                            const lastStepUsagePromise = source.usage;
+                            if (typeof lastStepUsagePromise?.then === "function") {
+                                try {
+                                    lastStepUsage = (await Promise.race([
+                                        lastStepUsagePromise,
+                                        new Promise((r) => setTimeout(() => r(undefined), 2_000)),
+                                    ]));
+                                }
+                                catch {
+                                    /* non-fatal */
+                                }
+                            }
                             // Outer-loop compaction (same logic as chat.agent)
                             if (sessionCompaction && turnUsage && !turnObj.stopped) {
+                                const contextUsage = lastStepUsage ?? turnUsage;
                                 const shouldTrigger = await sessionCompaction.shouldCompact({
                                     messages: accumulator.modelMessages,
-                                    totalTokens: turnUsage.totalTokens,
-                                    inputTokens: turnUsage.inputTokens,
-                                    outputTokens: turnUsage.outputTokens,
-                                    usage: turnUsage,
+                                    totalTokens: contextUsage.totalTokens,
+                                    inputTokens: contextUsage.inputTokens,
+                                    outputTokens: contextUsage.outputTokens,
+                                    usage: contextUsage,
+                                    turnUsage,
                                     totalUsage: cumulativeUsage,
                                     chatId: currentPayload.chatId,
                                     turn,