@trigger.dev/sdk 4.6.1 → 4.6.3

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

@@ -415,6 +415,8 @@ export type ChatNewToolResult = {
 interface CompactionState {
     summary: string;
     baseResponseMessageCount: number;
+    /** Completed steps summarized this turn; unlike message counts, matches UI step markers. */
+    baseResponseStepCount: number;
 }
 /**
  * Event passed to `summarize` callbacks.
@@ -667,14 +669,24 @@ export type CompactedEvent = {
 export type ShouldCompactEvent = {
     /** The current model messages (full conversation). */
     messages: ModelMessage[];
-    /** Total token count from the triggering step/turn. */
+    /**
+     * Total token count of the triggering model call: the step that just finished
+     * (`"inner"`), or the turn's LAST step (`"outer"`). This is the size of the
+     * context the model held on that call, which is what a compaction decision is
+     * about. It is never the sum over a multi-step turn; see `turnUsage` for that.
+     */
     totalTokens: number | undefined;
-    /** Input token count from the triggering step/turn. */
+    /** Input token count of the triggering model call (see `totalTokens`). */
     inputTokens: number | undefined;
-    /** Output token count from the triggering step/turn. */
+    /** Output token count of the triggering model call (see `totalTokens`). */
     outputTokens: number | undefined;
-    /** Full usage object from the triggering step/turn. */
+    /** Full usage object of the triggering model call (see `totalTokens`). */
     usage?: LanguageModelUsage;
+    /**
+     * The whole turn's usage summed over every step, as the provider billed it.
+     * Only present when `source` is `"outer"`.
+     */
+    turnUsage?: LanguageModelUsage;
     /** Cumulative token usage across all completed turns. Present in chat.agent contexts. */
     totalUsage?: LanguageModelUsage;
     /** The chat session ID (if running inside a chat.agent). */
@@ -1444,13 +1456,17 @@ export type TurnCompleteEvent<TClientData = unknown, TUIM extends UIMessage = UI
      */
     uiMessages: TUIM[];
     /**
-     * Only the new model messages from this turn (user message(s) + assistant response).
-     * Useful for appending to an existing conversation record.
+     * Model messages for this turn's user message(s) and complete assistant response,
+     * including steps summarized during the turn. Same-ID approval and handover
+     * continuations include the full replacement response, so these are not always
+     * an append-only delta. Persist `messages` for future model context, or upsert
+     * `newUIMessages` by ID for the visible conversation.
      */
     newMessages: ModelMessage[];
     /**
-     * Only the new UI messages from this turn (user message(s) + assistant response).
-     * Useful for inserting individual message records instead of overwriting the full history.
+     * New or updated UI messages from this turn (user message(s) + assistant response).
+     * Upsert by message ID: approval and handover continuations can replace an
+     * existing assistant message.
      */
     newUIMessages: TUIM[];
     /** The assistant's response for this turn, with aborted parts cleaned up when `stopped` is true. Undefined if `pipeChat` was used manually. */
@@ -2899,6 +2915,8 @@ declare class ChatMessageAccumulator {
     modelMessages: ModelMessage[];
     uiMessages: UIMessage[];
     private _compaction?;
+    /** The run a spliced head-start partial contributed, until its response replaces it. */
+    private _handoverRun?;
     private _pendingMessages?;
     private _steeringQueue;
     constructor(options?: {
@@ -2995,8 +3013,10 @@ declare class ChatMessageAccumulator {
     } | undefined>) | undefined;
     /**
      * 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.
      */
@@ -3004,6 +3024,8 @@ declare class ChatMessageAccumulator {
         chatId?: string;
         turn?: number;
         clientData?: unknown;
+        /** The whole turn summed over its steps (`result.totalUsage`). */
+        turnUsage?: LanguageModelUsage;
         totalUsage?: LanguageModelUsage;
     }): Promise<boolean>;
 }

package/dist/commonjs/v3/ai.js

@@ -15,8 +15,10 @@ const v3_1 = require("@trigger.dev/core/v3");
 // Runtime VALUES go through the ESM/CJS shim so the CJS build can `require`
 // ESM-only `ai@7` (see ../imports/ai-runtime.ts).
 const api_1 = require("@opentelemetry/api");
+const sessionTracing_js_1 = require("./sessionTracing.js");
 const ai_runtime_js_1 = require("../imports/ai-runtime.js");
 const transcriptStorage_js_1 = require("./transcriptStorage.js");
+const compactionResponse_js_1 = require("./compactionResponse.js");
 let transcriptStorageOverride;
 /**
  * Test-only override for the storage `chat.agent` persists through, so a
@@ -1110,7 +1112,7 @@ async function waitOnChatRoute(route, options) {
     return tracer_js_1.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 (0, sessionTracing_js_1.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 };
@@ -1164,10 +1166,6 @@ async function waitOnChatRoute(route, options) {
             session: session.id,
             io: "in",
             route,
-            ...(0, v3_1.accessoryAttributes)({
-                items: [{ text: `${session.id}.in:${route}`, variant: "normal" }],
-                style: "codepath",
-            }),
         },
     });
 }
@@ -1843,6 +1841,14 @@ const chatHandoverPartialKey = locals_js_1.locals.create("chat.handoverPartial")
  * @internal
  */
 const chatHandoverMessageIdKey = locals_js_1.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_js_1.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
@@ -1926,16 +1932,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()`
@@ -2795,6 +2804,7 @@ async function chatCompact(messages, steps, options) {
                 locals_js_1.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,
@@ -3665,8 +3675,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
@@ -4798,7 +4808,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 () => {
@@ -4950,7 +4960,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_js_1.tracer.startActiveSpan("onChatSuspend()", async () => {
@@ -5479,10 +5489,12 @@ function chatAgent(options) {
                                     // `UIMessageStreamError: No tool invocation found`.
                                     const pendingHandoverPartial = locals_js_1.locals.get(chatHandoverPartialKey);
                                     if (pendingHandoverPartial && pendingHandoverPartial.length > 0) {
-                                        spliceHandoverPartial(accumulatedMessages, accumulatedUIMessages, {
+                                        const spliced = spliceHandoverPartial(accumulatedMessages, accumulatedUIMessages, {
                                             partialAssistantMessage: pendingHandoverPartial,
                                             messageId: locals_js_1.locals.get(chatHandoverMessageIdKey),
                                         });
+                                        if (spliced)
+                                            locals_js_1.locals.set(chatHandoverSplicedRunKey, spliced);
                                         locals_js_1.locals.set(chatHandoverPartialKey, []); // consume once
                                         splicedHandoverPartial = true;
                                     }
@@ -5827,6 +5839,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 {
@@ -5839,6 +5852,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;
@@ -5889,6 +5914,13 @@ function chatAgent(options) {
                                 // Check if compaction set a model-only override (preserves UI messages).
                                 // Apply compactUIMessages/compactModelMessages callbacks if configured.
                                 const modelOnlyOverride = locals_js_1.locals.get(chatOverrideModelMessagesKey);
+                                const responseCompaction = modelOnlyOverride
+                                    ? locals_js_1.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_js_1.locals.get(chatCompactionStateKey)?.summary ?? "";
                                     const taskCompactionConfig = locals_js_1.locals.get(chatAgentCompactionKey);
@@ -5980,12 +6012,39 @@ function chatAgent(options) {
                                         // rationale (TRI-9137).
                                         recordToolCallIdsFromMessage(capturedResponseMessage);
                                         try {
+                                            const responseForModel = (0, compactionResponse_js_1.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_js_1.locals.set(chatHandoverSplicedRunKey, undefined);
+                                            }
+                                            else if (existingIdx !== -1) {
+                                                const spliced = locals_js_1.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_js_1.locals.set(chatHandoverSplicedRunKey, undefined);
                                                 if (!ok) {
                                                     v3_1.logger.warn("chat.agent: replaced response not found at the model lane tail; reconverting the lane");
                                                     accumulatedMessages = await toModelMessages(accumulatedUIMessages);
@@ -5996,7 +6055,7 @@ function chatAgent(options) {
                                             else {
                                                 accumulatedMessages.push(...responseModelMessages);
                                             }
-                                            turnNewModelMessages.push(...responseModelMessages);
+                                            turnNewModelMessages.push(...responsePrefixMessages, ...responseModelMessages);
                                         }
                                         catch {
                                             // Conversion failed — skip accumulation for this turn
@@ -6045,12 +6104,14 @@ function chatAgent(options) {
                                 const outerCompaction = locals_js_1.locals.get(chatAgentCompactionKey);
                                 const innerCompactionState = locals_js_1.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,
@@ -6375,7 +6436,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_js_1.tracer.startActiveSpan("onChatSuspend()", async () => {
@@ -6712,7 +6773,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
@@ -7752,6 +7813,8 @@ class ChatMessageAccumulator {
     modelMessages = [];
     uiMessages = [];
     _compaction;
+    /** The run a spliced head-start partial contributed, until its response replaces it. */
+    _handoverRun;
     _pendingMessages;
     _steeringQueue = [];
     constructor(options) {
@@ -7795,7 +7858,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
@@ -7838,8 +7901,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)));
                 }
             }
@@ -7942,8 +8010,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.
      */
@@ -7956,6 +8026,7 @@ class ChatMessageAccumulator {
             inputTokens: usage.inputTokens,
             outputTokens: usage.outputTokens,
             usage,
+            turnUsage: context?.turnUsage,
             totalUsage: context?.totalUsage,
             chatId: context?.chatId,
             turn: context?.turn,
@@ -8188,8 +8259,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();
@@ -8226,7 +8297,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();
@@ -8437,6 +8508,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([
@@ -8453,14 +8525,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,