@trigger.dev/sdk 4.5.0 → 4.5.2

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

@@ -1,5 +1,9 @@
-import { AnyTask, type MachinePresetName, type RealtimeDefinedInputStream, type RealtimeDefinedStream, type ApiClientConfiguration, Task, type inferSchemaIn, type inferSchemaOut, type TaskIdentifier, type TaskOptions, type TaskSchema, type TaskRunContext, type TaskWithSchema } from "@trigger.dev/core/v3";
+import { type AnyTask, type Task, type ChatSnapshotV1, type ApiClientConfiguration, type inferSchemaIn, type inferSchemaOut, type MachinePresetName, type RealtimeDefinedInputStream, type RealtimeDefinedStream, type SessionTriggerConfig, type TaskIdentifier, type TaskOptions, type TaskRunContext, type TaskSchema, type TaskWithSchema } from "@trigger.dev/core/v3";
 import type { FinishReason, LanguageModelUsage, ModelMessage, ProviderMetadata, Tool, ToolSet, UIMessage, UIMessageChunk, UIMessageStreamOptions } from "ai";
+import { type ChatInputChunk, type ChatTaskWirePayload, type InferChatClientData, type InferChatUIMessage, type InferChatUIMessageFromTools, PENDING_MESSAGE_INJECTED_TYPE, upsertIncomingMessage } from "./ai-shared.js";
+import { locals } from "./locals.js";
+import type { ResolvedPrompt } from "./prompt.js";
+import type { ResolvedSkill } from "./skill.js";
 type ToolCallOptions = {
     toolCallId: string;
     messages?: ModelMessage[];
@@ -7,10 +11,6 @@ type ToolCallOptions = {
     experimental_context?: unknown;
     context?: unknown;
 };
-import { locals } from "./locals.js";
-import type { ResolvedPrompt } from "./prompt.js";
-import type { ResolvedSkill } from "./skill.js";
-import { type SessionTriggerConfig } from "@trigger.dev/core/v3";
 /** Re-export for typing `ctx` in `chat.agent` hooks without importing `@trigger.dev/core`. */
 export type { TaskRunContext } from "@trigger.dev/core/v3";
 export type ToolCallExecutionOptions = {
@@ -171,8 +171,6 @@ export type ChatWriter = {
     /** Merge another stream's chunks into the chat stream. */
     merge(stream: ReadableStream<UIMessageChunk>): void;
 };
-import type { ChatTaskWirePayload } from "./ai-shared.js";
-export type { ChatTaskWirePayload, ChatInputChunk } from "./ai-shared.js";
 /**
  * The payload shape passed to the `chatAgent` run function.
  *
@@ -520,7 +518,8 @@ export type PendingMessagesOptions<TUIM extends UIMessage = UIMessage> = {
  * between tool-call steps. The frontend can match on this to render
  * injection points inline in the assistant response.
  */
-export { PENDING_MESSAGE_INJECTED_TYPE, upsertIncomingMessage } from "./ai-shared.js";
+export { PENDING_MESSAGE_INJECTED_TYPE, upsertIncomingMessage };
+export type { InferChatClientData, InferChatUIMessage, InferChatUIMessageFromTools };
 /**
  * Event passed to the `prepareMessages` hook.
  */
@@ -2795,8 +2794,6 @@ declare function chatLocal<T extends Record<string, unknown>>(options: {
  * // { model?: string; userId: string }
  * ```
  */
-import type { InferChatClientData } from "./ai-shared.js";
-export type { InferChatClientData, InferChatUIMessage, InferChatUIMessageFromTools, } from "./ai-shared.js";
 /**
  * Options for {@link createChatStartSessionAction}.
  */

package/dist/commonjs/v3/ai.js

@@ -15,8 +15,11 @@ exports.buildSkillTools = buildSkillTools;
 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 ai_runtime_js_1 = require("../imports/ai-runtime.js");
 const api_1 = require("@opentelemetry/api");
+const ai_runtime_js_1 = require("../imports/ai-runtime.js");
+const ai_shared_js_1 = require("./ai-shared.js");
+Object.defineProperty(exports, "PENDING_MESSAGE_INJECTED_TYPE", { enumerable: true, get: function () { return ai_shared_js_1.PENDING_MESSAGE_INJECTED_TYPE; } });
+Object.defineProperty(exports, "upsertIncomingMessage", { enumerable: true, get: function () { return ai_shared_js_1.upsertIncomingMessage; } });
 const auth_js_1 = require("./auth.js");
 const locals_js_1 = require("./locals.js");
 const metadata_js_1 = require("./metadata.js");
@@ -29,11 +32,10 @@ const metadata_js_1 = require("./metadata.js");
 // never touches `ai.ts`'s module graph, so the `node:*` builtins
 // pulled in transitively here never reach a client chunk.
 const agentSkillsRuntime_js_1 = require("./agentSkillsRuntime.js");
-const streams_js_1 = require("./streams.js");
+const aiAutoTelemetry_js_1 = require("./aiAutoTelemetry.js");
 const sessions_js_1 = require("./sessions.js");
 const shared_js_1 = require("./shared.js");
-const aiAutoTelemetry_js_1 = require("./aiAutoTelemetry.js");
-const v3_2 = require("@trigger.dev/core/v3");
+const streams_js_1 = require("./streams.js");
 const tracer_js_1 = require("./tracer.js");
 const METADATA_KEY = "tool.execute.options";
 /**
@@ -1899,19 +1901,6 @@ const chatUpgradeRequestedKey = locals_js_1.locals.create("chat.upgradeRequested
 const chatEndRunRequestedKey = locals_js_1.locals.create("chat.endRunRequested");
 /** @internal */
 const chatAgentCompactionKey = locals_js_1.locals.create("chat.agentCompaction");
-/**
- * The data part type used to signal that pending messages were injected
- * between tool-call steps. The frontend can match on this to render
- * injection points inline in the assistant response.
- */
-// `PENDING_MESSAGE_INJECTED_TYPE` lives in `./ai-shared.ts` so the chat
-// React hooks (`@trigger.dev/sdk/chat/react`) can import it without
-// dragging `ai.ts` into the browser graph. Re-exported here so
-// `@trigger.dev/sdk/ai` consumers still see it.
-var ai_shared_js_1 = require("./ai-shared.js");
-Object.defineProperty(exports, "PENDING_MESSAGE_INJECTED_TYPE", { enumerable: true, get: function () { return ai_shared_js_1.PENDING_MESSAGE_INJECTED_TYPE; } });
-Object.defineProperty(exports, "upsertIncomingMessage", { enumerable: true, get: function () { return ai_shared_js_1.upsertIncomingMessage; } });
-const ai_shared_js_2 = require("./ai-shared.js");
 /** @internal */
 const chatPendingMessagesKey = locals_js_1.locals.create("chat.pendingMessages");
 /** @internal */
@@ -2303,7 +2292,7 @@ async function drainSteeringQueue(config, messages, steps, queueOverride) {
         .filter((p) => p.type === "text")
         .map((p) => p.text)
         .join("") || "");
-    const previewText = messageTexts.length === 1 ? messageTexts[0].slice(0, 80) : `${queue.length} messages`;
+    const _previewText = messageTexts.length === 1 ? messageTexts[0].slice(0, 80) : `${queue.length} messages`;
     return tracer_js_1.tracer.startActiveSpan("pending message injected", async () => {
         // Transform the batch — default: concatenate all pre-converted model messages
         const injected = config.prepare
@@ -2324,7 +2313,7 @@ async function drainSteeringQueue(config, messages, steps, queueOverride) {
                     collapsed: true,
                     execute: ({ write }) => {
                         write({
-                            type: ai_shared_js_2.PENDING_MESSAGE_INJECTED_TYPE,
+                            type: ai_shared_js_1.PENDING_MESSAGE_INJECTED_TYPE,
                             id: (0, ai_runtime_js_1.generateId)(),
                             data: {
                                 messageIds: uiMessages.map((m) => m.id),
@@ -2817,7 +2806,7 @@ function chatCustomAgent(options) {
     // Register clientDataSchema so the CLI converts it to JSONSchema
     // and stores it as payloadSchema — used by the Playground UI
     if (clientDataSchema) {
-        v3_2.resourceCatalog.updateTaskMetadata(options.id, {
+        v3_1.resourceCatalog.updateTaskMetadata(options.id, {
             schema: clientDataSchema,
         });
     }
@@ -2933,6 +2922,11 @@ function chatAgent(options) {
             // default, `inFlightUsers`). The turn-loop checks this queue ahead of
             // `messagesInput.waitWithIdleTimeout` so recovered turns fire first.
             const bootInjectedQueue = [];
+            // Messages consumed by a turn's `messagesInput.on` handler, dispatched
+            // one per turn by the end-of-turn pickup. Loop-level on purpose:
+            // consuming a record advances the committed `.in` cursor, so entries
+            // dropped with a turn-local buffer are lost permanently.
+            const pendingWireMessages = [];
             const couldHavePriorState = payload.continuation === true || ctx.attempt.number > 1;
             // `.in` resume cursor, computed at most once per boot. The boot
             // block below resolves it (snapshot field or records scan) and the
@@ -3639,6 +3633,9 @@ function chatAgent(options) {
                     } // end else (no boot-injected first turn)
                 }
                 for (let turn = 0; turn < maxTurns; turn++) {
+                    // Declared here so the finally can detach it — a handler leaked past
+                    // its turn duplicates every mid-stream message into the shared buffer.
+                    let turnMsgSub;
                     try {
                         // Extract turn-level context before entering the span. Slim
                         // wire: at most one delta message per record. `headStartMessages`
@@ -3714,8 +3711,6 @@ function chatAgent(options) {
                             const stopSignal = stopController.signal;
                             const cancelSignal = runSignal;
                             const combinedSignal = AbortSignal.any([runSignal, stopController.signal]);
-                            // Buffer messages that arrive during streaming
-                            const pendingMessages = [];
                             const pmConfig = locals_js_1.locals.get(chatPendingMessagesKey);
                             const msgSub = messagesInput.on(async (msg) => {
                                 // If pendingMessages is configured, route to the steering queue
@@ -3762,8 +3757,9 @@ function chatAgent(options) {
                                     return; // Don't add to wire buffer — frontend handles non-injected case
                                 }
                                 // No pendingMessages config — standard wire buffer for next turn
-                                pendingMessages.push(msg);
+                                pendingWireMessages.push(msg);
                             });
+                            turnMsgSub = msgSub;
                             // Track new messages for this turn (user input + assistant response).
                             const turnNewModelMessages = [];
                             const turnNewUIMessages = [];
@@ -4818,9 +4814,10 @@ function chatAgent(options) {
                                 return "continue";
                             }
                             // If messages arrived during streaming (without pendingMessages config),
-                            // use the first one immediately as the next turn.
-                            if (pendingMessages.length > 0) {
-                                currentWirePayload = pendingMessages[0];
+                            // dispatch the oldest as the next turn. The rest stay queued
+                            // and drain one per turn.
+                            if (pendingWireMessages.length > 0) {
+                                currentWirePayload = pendingWireMessages.shift();
                                 return "continue";
                             }
                             // chat.requestUpgrade() was called — exit the loop so the
@@ -4906,6 +4903,9 @@ function chatAgent(options) {
                         // Turn error handler: write an error chunk + turn-complete to the stream
                         // so the client sees the error, then wait for the next message instead
                         // of killing the entire run. This keeps the conversation alive.
+                        // Detach the turn's message handler first — left attached it would
+                        // eat the very message the wait below is waiting for.
+                        turnMsgSub?.off();
                         if (turnError instanceof Error &&
                             turnError.name === "AbortError" &&
                             runSignal.aborted) {
@@ -5025,6 +5025,11 @@ function chatAgent(options) {
                             currentWirePayload = bootInjectedQueue.shift();
                             continue;
                         }
+                        // Same for messages buffered during the errored turn — already consumed, idling strands them.
+                        if (pendingWireMessages.length > 0) {
+                            currentWirePayload = pendingWireMessages.shift();
+                            continue;
+                        }
                         // Wait for the next message — same as after a successful turn
                         const effectiveIdleTimeout = metadata_js_1.metadata.get(IDLE_TIMEOUT_METADATA_KEY) ??
                             idleTimeoutInSeconds;
@@ -5040,6 +5045,9 @@ function chatAgent(options) {
                         currentWirePayload = next.output;
                         // Continue to next iteration of the for loop
                     }
+                    finally {
+                        turnMsgSub?.off();
+                    }
                 }
             }
             finally {
@@ -5053,7 +5061,7 @@ function chatAgent(options) {
     // Register clientDataSchema so the CLI converts it to JSONSchema
     // and stores it as payloadSchema — used by the Playground UI
     if (clientDataSchema) {
-        v3_2.resourceCatalog.updateTaskMetadata(options.id, {
+        v3_1.resourceCatalog.updateTaskMetadata(options.id, {
             schema: clientDataSchema,
         });
     }
@@ -5950,8 +5958,17 @@ function createChatSession(payload, options) {
             const accumulator = new ChatMessageAccumulator();
             let previousTurnUsage;
             let cumulativeUsage = emptyUsage();
+            // Messages consumed mid-turn, dispatched one per next(). Iterator-level
+            // for the same reason as the agent loop's `pendingWireMessages`:
+            // consumed records never replay, so a turn-local buffer loses them.
+            const sessionPendingWire = [];
+            // The current turn's message subscription — detached defensively at the
+            // top of next() in case user code threw without complete()/done().
+            let activeMsgSub;
             return {
                 async next() {
+                    activeMsgSub?.off();
+                    activeMsgSub = undefined;
                     if (!booted) {
                         booted = true;
                         await seedSessionInResumeCursorForCustomLoop(currentPayload);
@@ -6011,23 +6028,29 @@ function createChatSession(payload, options) {
                             currentPayload = { ...currentPayload, continuation: true };
                         }
                     }
-                    // Subsequent turns: wait for the next message
+                    // Subsequent turns: drain buffered mid-turn messages first (they
+                    // were consumed and won't be re-delivered), then wait.
                     if (turn > 0) {
-                        // chat.requestUpgrade() / chat.endRun() — exit before waiting
-                        if (locals_js_1.locals.get(chatUpgradeRequestedKey) || locals_js_1.locals.get(chatEndRunRequestedKey)) {
-                            stop.cleanup();
-                            return { done: true, value: undefined };
+                        if (sessionPendingWire.length > 0) {
+                            currentPayload = sessionPendingWire.shift();
                         }
-                        const next = await messagesInput.waitWithIdleTimeout({
-                            idleTimeoutInSeconds,
-                            timeout,
-                            spanName: "waiting for next message",
-                        });
-                        if (!next.ok || runSignal.aborted) {
-                            stop.cleanup();
-                            return { done: true, value: undefined };
+                        else {
+                            // chat.requestUpgrade() / chat.endRun() — exit before waiting
+                            if (locals_js_1.locals.get(chatUpgradeRequestedKey) || locals_js_1.locals.get(chatEndRunRequestedKey)) {
+                                stop.cleanup();
+                                return { done: true, value: undefined };
+                            }
+                            const next = await messagesInput.waitWithIdleTimeout({
+                                idleTimeoutInSeconds,
+                                timeout,
+                                spanName: "waiting for next message",
+                            });
+                            if (!next.ok || runSignal.aborted) {
+                                stop.cleanup();
+                                return { done: true, value: undefined };
+                            }
+                            currentPayload = next.output;
                         }
-                        currentPayload = next.output;
                     }
                     // Check limits
                     if (turn >= maxTurns || runSignal.aborted) {
@@ -6052,10 +6075,10 @@ function createChatSession(payload, options) {
                         clientData: currentPayload.metadata,
                     });
                     // Listen for messages during streaming (steering + next-turn buffer)
-                    const sessionPendingWire = [];
                     const sessionMsgSub = messagesInput.on(async (msg) => {
-                        sessionPendingWire.push(msg);
                         if (sessionPendingMessages) {
+                            // Steering route — the frontend re-sends non-injected
+                            // messages on turn complete, so don't also buffer the wire.
                             // Slim wire: at most one delta message per record. Read
                             // `msg.message` directly — no array slicing needed.
                             const lastUIMessage = msg.message;
@@ -6080,15 +6103,18 @@ function createChatSession(payload, options) {
                                     /* non-fatal */
                                 }
                             }
+                            return;
                         }
+                        sessionPendingWire.push(msg);
                     });
+                    activeMsgSub = sessionMsgSub;
                     // Accumulate messages. Slim wire: pass the single delta message as
                     // a 0-or-1-length array. The accumulator's behavior is unchanged —
                     // it still appends user messages and reconverts on regenerate.
                     const incomingForAccumulator = currentPayload.message
                         ? [currentPayload.message]
                         : [];
-                    const messages = await accumulator.addIncoming(incomingForAccumulator, currentPayload.trigger, turn);
+                    const _messages = await accumulator.addIncoming(incomingForAccumulator, currentPayload.trigger, turn);
                     // Apply the head-start handover AFTER addIncoming — turn-0 addIncoming
                     // replaces accumulator state, which would wipe a pre-applied splice.
                     // Seed prior history first, then splice the warm step-1 partial.
@@ -6172,6 +6198,11 @@ function createChatSession(payload, options) {
                                     throw error;
                                 }
                             }
+                            finally {
+                                // Detach at stream end (like the agent loop): the steering queue
+                                // can't inject anymore, so later arrivals must buffer for the next turn.
+                                sessionMsgSub.off();
+                            }
                             if (response) {
                                 const cleaned = stop.signal.aborted && !runSignal.aborted
                                     ? cleanupAbortedParts(response)
@@ -6315,6 +6346,8 @@ function createChatSession(payload, options) {
                     return { done: false, value: turnObj };
                 },
                 async return() {
+                    activeMsgSub?.off();
+                    activeMsgSub = undefined;
                     // `stop` only exists once next() has booted the iterator.
                     stop?.cleanup();
                     return { done: true, value: undefined };