@trigger.dev/sdk 4.5.0-rc.0 → 4.5.0-rc.2

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

@@ -171,3 +171,73 @@ export type InferChatClientData<TTask extends AnyTask> = TTask extends Task<stri
  * ```
  */
 export type InferChatUIMessage<TTask extends AnyTask> = TTask extends Task<string, ChatTaskWirePayload<infer TUIM extends UIMessage, any>, any> ? TUIM : UIMessage;
+/**
+ * Upsert an incoming wire message into the customer's DB-backed chain
+ * inside a `hydrateMessages` hook. Returns `true` iff the chain was
+ * mutated (the caller should persist).
+ *
+ * Handles the three cases that matter:
+ *
+ *  - **Non-submit-message trigger** (`regenerate-message` / `action`,
+ *    or `submit-message` with no incoming): no-op. Returns `false`.
+ *  - **Incoming id already in `stored`** (HITL `addToolOutput` /
+ *    `addToolApproveResponse` continuation — the wire carries the
+ *    existing assistant's id with a slim resolution payload): no-op.
+ *    The runtime's per-turn merge overlays the new tool-state advance
+ *    onto the existing entry; pushing again would duplicate the row
+ *    in the chain you return, and the duplicate slim copy would hit
+ *    `toModelMessages` with no `input`. Returns `false`.
+ *  - **Incoming id not in `stored`** (typically a fresh user message
+ *    on a new turn): push. Returns `true`.
+ *
+ * Mutates `stored` in place. The caller persists `stored`, not the
+ * return value.
+ *
+ * @example
+ * ```ts
+ * import { chat, upsertIncomingMessage } from "@trigger.dev/sdk/ai";
+ *
+ * chat.agent({
+ *   hydrateMessages: async ({ chatId, trigger, incomingMessages }) => {
+ *     const record = await db.chat.findUnique({ where: { id: chatId } });
+ *     const stored = record?.messages ?? [];
+ *     if (upsertIncomingMessage(stored, { trigger, incomingMessages })) {
+ *       await db.chat.update({ where: { id: chatId }, data: { messages: stored } });
+ *     }
+ *     return stored;
+ *   },
+ * });
+ * ```
+ */
+export declare function upsertIncomingMessage<TMsg extends UIMessage = UIMessage>(stored: TMsg[], event: {
+    trigger: "submit-message" | "regenerate-message" | "action";
+    incomingMessages: TMsg[];
+}): boolean;
+/**
+ * Slim an outgoing assistant message before it ships on `submit-message`.
+ *
+ * When the client calls `addToolOutput(...)` to resolve a HITL tool (or
+ * `addToolApproveResponse(...)` to approve/deny one), the AI SDK turns
+ * it into a `submit-message` whose `messages.at(-1)` is the existing
+ * assistant message with the new state stitched onto a single tool
+ * part. On a reasoning-heavy multi-step turn, that full assistant
+ * message can be 600 KB – 1 MB (encrypted reasoning blobs, reasoning
+ * text, full tool `input` JSON, prior tool outputs) — well over the
+ * `.in/append` cap.
+ *
+ * The agent runtime only consumes the wire-advanced fields of those
+ * tool parts (state + output / errorText / approval). Everything else
+ * (text, reasoning, tool `input`) is rebuilt server-side from the
+ * durable snapshot or `hydrateMessages`. So we drop everything but
+ * the advanced tool parts here, and reduce those to just the fields
+ * the server overlays.
+ *
+ * The slim only fires when the assistant message carries at least one
+ * wire-advanceable tool part. Plain assistant resends (no resolved /
+ * approval-responded tool) and non-assistant messages pass through
+ * untouched.
+ *
+ * Pairs with the per-turn merge on the agent side
+ * (`mergeIncomingIntoHydrated` in `ai.ts`).
+ */
+export declare function slimSubmitMessageForWire<TMsg extends UIMessage | undefined>(message: TMsg): TMsg;

package/dist/commonjs/v3/ai-shared.js

@@ -17,9 +17,153 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PENDING_MESSAGE_INJECTED_TYPE = void 0;
+exports.upsertIncomingMessage = upsertIncomingMessage;
+exports.slimSubmitMessageForWire = slimSubmitMessageForWire;
 /**
  * Message-part `type` value for the pending-message data part the agent
  * injects when a follow-up message arrives mid-turn.
  */
 exports.PENDING_MESSAGE_INJECTED_TYPE = "data-pending-message-injected";
+/**
+ * Upsert an incoming wire message into the customer's DB-backed chain
+ * inside a `hydrateMessages` hook. Returns `true` iff the chain was
+ * mutated (the caller should persist).
+ *
+ * Handles the three cases that matter:
+ *
+ *  - **Non-submit-message trigger** (`regenerate-message` / `action`,
+ *    or `submit-message` with no incoming): no-op. Returns `false`.
+ *  - **Incoming id already in `stored`** (HITL `addToolOutput` /
+ *    `addToolApproveResponse` continuation — the wire carries the
+ *    existing assistant's id with a slim resolution payload): no-op.
+ *    The runtime's per-turn merge overlays the new tool-state advance
+ *    onto the existing entry; pushing again would duplicate the row
+ *    in the chain you return, and the duplicate slim copy would hit
+ *    `toModelMessages` with no `input`. Returns `false`.
+ *  - **Incoming id not in `stored`** (typically a fresh user message
+ *    on a new turn): push. Returns `true`.
+ *
+ * Mutates `stored` in place. The caller persists `stored`, not the
+ * return value.
+ *
+ * @example
+ * ```ts
+ * import { chat, upsertIncomingMessage } from "@trigger.dev/sdk/ai";
+ *
+ * chat.agent({
+ *   hydrateMessages: async ({ chatId, trigger, incomingMessages }) => {
+ *     const record = await db.chat.findUnique({ where: { id: chatId } });
+ *     const stored = record?.messages ?? [];
+ *     if (upsertIncomingMessage(stored, { trigger, incomingMessages })) {
+ *       await db.chat.update({ where: { id: chatId }, data: { messages: stored } });
+ *     }
+ *     return stored;
+ *   },
+ * });
+ * ```
+ */
+function upsertIncomingMessage(stored, event) {
+    if (event.trigger !== "submit-message")
+        return false;
+    if (event.incomingMessages.length === 0)
+        return false;
+    const newMsg = event.incomingMessages[event.incomingMessages.length - 1];
+    if (!newMsg)
+        return false;
+    if (newMsg.id) {
+        const existingIdx = stored.findIndex((m) => m.id === newMsg.id);
+        if (existingIdx !== -1)
+            return false;
+    }
+    stored.push(newMsg);
+    return true;
+}
+/**
+ * Tool-part states that the client advances and ships back over the wire.
+ * Covers HITL `addToolOutput` (output-available / output-error) and the
+ * approval flow (approval-responded / output-denied). `input-streaming` /
+ * `input-available` / `approval-requested` are server-emitted only — if
+ * we see them on the wire we treat them as no-ops and skip the slim/merge.
+ */
+function isWireAdvanceableToolState(state) {
+    return (state === "output-available" ||
+        state === "output-error" ||
+        state === "approval-responded" ||
+        state === "output-denied");
+}
+/** Whether a tool-UI part is a static (`tool-${name}`) or dynamic tool. */
+function isToolPartType(type) {
+    return typeof type === "string" && (type.startsWith("tool-") || type === "dynamic-tool");
+}
+/**
+ * Slim an outgoing assistant message before it ships on `submit-message`.
+ *
+ * When the client calls `addToolOutput(...)` to resolve a HITL tool (or
+ * `addToolApproveResponse(...)` to approve/deny one), the AI SDK turns
+ * it into a `submit-message` whose `messages.at(-1)` is the existing
+ * assistant message with the new state stitched onto a single tool
+ * part. On a reasoning-heavy multi-step turn, that full assistant
+ * message can be 600 KB – 1 MB (encrypted reasoning blobs, reasoning
+ * text, full tool `input` JSON, prior tool outputs) — well over the
+ * `.in/append` cap.
+ *
+ * The agent runtime only consumes the wire-advanced fields of those
+ * tool parts (state + output / errorText / approval). Everything else
+ * (text, reasoning, tool `input`) is rebuilt server-side from the
+ * durable snapshot or `hydrateMessages`. So we drop everything but
+ * the advanced tool parts here, and reduce those to just the fields
+ * the server overlays.
+ *
+ * The slim only fires when the assistant message carries at least one
+ * wire-advanceable tool part. Plain assistant resends (no resolved /
+ * approval-responded tool) and non-assistant messages pass through
+ * untouched.
+ *
+ * Pairs with the per-turn merge on the agent side
+ * (`mergeIncomingIntoHydrated` in `ai.ts`).
+ */
+function slimSubmitMessageForWire(message) {
+    if (!message)
+        return message;
+    if (message.role !== "assistant")
+        return message;
+    const parts = (message.parts ?? []);
+    const advancedToolParts = parts.filter((p) => p &&
+        typeof p === "object" &&
+        isToolPartType(p.type) &&
+        isWireAdvanceableToolState(p.state));
+    if (advancedToolParts.length === 0)
+        return message;
+    const slimParts = advancedToolParts.map((p) => {
+        const base = {
+            type: p.type,
+            toolCallId: p.toolCallId,
+            state: p.state,
+        };
+        if (p.type === "dynamic-tool" && typeof p.toolName === "string") {
+            base.toolName = p.toolName;
+        }
+        if (p.state === "output-available") {
+            base.output = p.output;
+            if (p.approval !== undefined)
+                base.approval = p.approval;
+        }
+        else if (p.state === "output-error") {
+            if (p.errorText !== undefined)
+                base.errorText = p.errorText;
+            if (p.approval !== undefined)
+                base.approval = p.approval;
+        }
+        else if (p.state === "approval-responded" || p.state === "output-denied") {
+            if (p.approval !== undefined)
+                base.approval = p.approval;
+        }
+        return base;
+    });
+    return {
+        id: message.id,
+        role: message.role,
+        parts: slimParts,
+    };
+}
 //# sourceMappingURL=ai-shared.js.map

package/dist/commonjs/v3/ai-shared.js.map

@@ -1 +1 @@
-{"version":3,"file":"ai-shared.js","sourceRoot":"","sources":["../../../src/v3/ai-shared.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAKH;;;GAGG;AACU,QAAA,6BAA6B,GAAG,+BAAwC,CAAC"}
+{"version":3,"file":"ai-shared.js","sourceRoot":"","sources":["../../../src/v3/ai-shared.ts"],"names":[],"mappings":"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"}

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

@@ -446,7 +446,7 @@ 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 } from "./ai-shared.js";
+export { PENDING_MESSAGE_INJECTED_TYPE, upsertIncomingMessage } from "./ai-shared.js";
 /**
  * Event passed to the `prepareMessages` hook.
  */
@@ -1085,7 +1085,14 @@ export type HydrateMessagesEvent<TClientData = unknown, TUIM extends UIMessage =
  * Event passed to the `onValidateMessages` callback.
  */
 export type ValidateMessagesEvent<TUIM extends UIMessage = UIMessage> = {
-    /** The incoming UI messages for this turn (after cleanup of aborted tool parts). */
+    /**
+     * The incoming UI messages for this turn (after cleanup of aborted tool parts).
+     *
+     * For HITL continuations the assistant entry is slim — `state` + `output` /
+     * `errorText` / `approval` only, no `input` or other parts. Don't pass the
+     * full `messages` array to `validateUIMessages` from `ai`; filter to user
+     * messages (or your own subset) first.
+     */
     messages: TUIM[];
     /** The unique identifier for the chat session. */
     chatId: string;
@@ -1534,8 +1541,13 @@ export type ChatAgentOptions<TIdentifier extends string, TClientDataSchema exten
      *
      * Return the validated messages array. Throw to abort the turn with an error.
      *
-     * This is the right place to call the AI SDK's `validateUIMessages` to catch
-     * malformed messages from storage or untrusted input before they reach the model.
+     * This is the right place to call the AI SDK's `validateUIMessages` on fresh
+     * user input. For HITL continuations (`addToolOutput` /
+     * `addToolApproveResponse`), the wire carries a slim assistant message — only
+     * the resolved tool parts, with `state` + `output` / `errorText` / `approval`
+     * and no `input`. `validateUIMessages` against the AI SDK schema rejects
+     * that shape, so filter to user messages (or skip validation entirely) on
+     * those turns.
      *
      * @example
      * ```ts
@@ -1544,7 +1556,11 @@ export type ChatAgentOptions<TIdentifier extends string, TClientDataSchema exten
      * chat.agent({
      *   id: "my-chat",
      *   onValidateMessages: async ({ messages }) => {
-     *     return validateUIMessages({ messages, tools: chatTools });
+     *     const userMessages = messages.filter((m) => m.role === "user");
+     *     if (userMessages.length > 0) {
+     *       await validateUIMessages({ messages: userMessages, tools: chatTools });
+     *     }
+     *     return messages;
      *   },
      *   run: async ({ messages }) => {
      *     return streamText({ model, messages, tools: chatTools });

package/dist/commonjs/v3/ai.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.chat = exports.PENDING_MESSAGE_INJECTED_TYPE = exports.ai = void 0;
+exports.chat = exports.upsertIncomingMessage = exports.PENDING_MESSAGE_INJECTED_TYPE = exports.ai = void 0;
 exports.__setReadChatSnapshotImplForTests = __setReadChatSnapshotImplForTests;
 exports.__setWriteChatSnapshotImplForTests = __setWriteChatSnapshotImplForTests;
 exports.__readChatSnapshotProductionPathForTests = __readChatSnapshotProductionPathForTests;
@@ -1534,6 +1534,107 @@ function extractNewToolResultsFromHistory(message, messages) {
     }
     return out;
 }
+/**
+ * Per-turn merge of an incoming wire `UIMessage` onto the matching entry
+ * a `hydrateMessages` hook (or the default accumulator) provides. Used
+ * to fold tool-state advances from the client into the agent's
+ * authoritative chain without trusting the wire copy for fields the
+ * LLM consumes.
+ *
+ * `hydrated` is treated as the source of truth for everything outside
+ * tool-state advancement: text, reasoning blobs, provider metadata,
+ * and tool `input` all stay as hydrated had them. We only overlay
+ * tool parts whose incoming state is wire-advanced — `output-available`
+ * / `output-error` (HITL `addToolOutput`) or `approval-responded` /
+ * `output-denied` (approval flow) — and only the corresponding
+ * resolution fields (`output` / `errorText` / `approval`). Hydrated
+ * `input` and everything else stay put.
+ *
+ * Without this, a slim wire copy (which `TriggerChatTransport` /
+ * `AgentChat.sendRaw` ship by default on HITL continuations) would
+ * clobber the hydrated assistant — the next LLM call would receive a
+ * tool call with no `input` and 4xx.
+ *
+ * @internal
+ */
+function mergeIncomingIntoHydrated(hydrated, incoming) {
+    const incomingAdvancedByCallId = new Map();
+    for (const part of (incoming.parts ?? [])) {
+        if (!(0, ai_1.isToolUIPart)(part))
+            continue;
+        const toolCallId = part.toolCallId;
+        if (typeof toolCallId !== "string" || toolCallId.length === 0)
+            continue;
+        if (!isWireAdvanceableToolState(part.state))
+            continue;
+        incomingAdvancedByCallId.set(toolCallId, part);
+    }
+    if (incomingAdvancedByCallId.size === 0)
+        return hydrated;
+    let mutated = false;
+    const hydratedParts = (hydrated.parts ?? []);
+    const mergedParts = hydratedParts.map((part) => {
+        if (!(0, ai_1.isToolUIPart)(part))
+            return part;
+        const toolCallId = part.toolCallId;
+        if (typeof toolCallId !== "string" || toolCallId.length === 0)
+            return part;
+        const incomingPart = incomingAdvancedByCallId.get(toolCallId);
+        if (!incomingPart)
+            return part;
+        // Terminal hydrated states (`output-available`, `output-error`,
+        // `output-denied`) are authoritative — never regressed by a stale
+        // wire arrival (replay, retry, out-of-order). `output-denied`
+        // matters here because the wire's `approval-responded` could
+        // otherwise overwrite a hydrated denial back to a non-terminal
+        // state.
+        if (isResolvedToolState(part.state) || part.state === "output-denied") {
+            return part;
+        }
+        // Same state on both sides — no progression to apply.
+        if (part.state === incomingPart.state)
+            return part;
+        mutated = true;
+        if (incomingPart.state === "output-available") {
+            return {
+                ...part,
+                state: incomingPart.state,
+                output: incomingPart.output,
+                ...(incomingPart.approval !== undefined ? { approval: incomingPart.approval } : {}),
+            };
+        }
+        if (incomingPart.state === "output-error") {
+            return {
+                ...part,
+                state: incomingPart.state,
+                errorText: incomingPart.errorText,
+                ...(incomingPart.approval !== undefined ? { approval: incomingPart.approval } : {}),
+            };
+        }
+        // approval-responded / output-denied — overlay state + approval.
+        return {
+            ...part,
+            state: incomingPart.state,
+            ...(incomingPart.approval !== undefined ? { approval: incomingPart.approval } : {}),
+        };
+    });
+    if (!mutated)
+        return hydrated;
+    return { ...hydrated, parts: mergedParts };
+}
+/**
+ * Mirror of `slimSubmitMessageForWire`'s predicate. Kept here so the
+ * agent runtime doesn't have to import from `ai-shared.ts` for a
+ * one-liner. See that file for the full state-machine docs.
+ *
+ * @internal
+ */
+function isWireAdvanceableToolState(state) {
+    return (state === "output-available" ||
+        state === "output-error" ||
+        state === "approval-responded" ||
+        state === "output-denied");
+}
 /**
  * Imperative API for reading and modifying the accumulated message history.
  *
@@ -1663,6 +1764,7 @@ const chatAgentCompactionKey = locals_js_1.locals.create("chat.agentCompaction")
 // `@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");
@@ -3429,6 +3531,17 @@ function chatAgent(options) {
                                     }));
                                 }
                                 if (hydrateMessages) {
+                                    // Snapshot the ids the accumulator knew BEFORE this
+                                    // turn ran — used below to decide whether an
+                                    // incoming wire message is genuinely new or just a
+                                    // state advance on an existing entry. We can't use
+                                    // the post-`hydrateMessages` array for this because
+                                    // the canonical hook pattern pushes the incoming
+                                    // user message into the persisted chain and
+                                    // returns it.
+                                    const previouslyKnownMessageIds = new Set(accumulatedUIMessages
+                                        .map((m) => m.id)
+                                        .filter((id) => typeof id === "string"));
                                     // Backend hydration: load the full message history from the user's
                                     // backend, replacing the built-in accumulator entirely. With slim
                                     // wire, `incomingMessages` is consistently 0-or-1-length — what
@@ -3455,29 +3568,50 @@ function chatAgent(options) {
                                             "chat.incoming_messages.count": cleanedUIMessages.length,
                                         },
                                     });
-                                    // Auto-merge tool approval updates: if any incoming wire message
-                                    // has an ID that matches a hydrated message, replace it. This makes
-                                    // tool approvals work transparently with backend hydration.
+                                    // Per-turn merge of incoming wire messages onto the hydrated
+                                    // chain. Hydrated stays authoritative for text, reasoning
+                                    // blobs, provider metadata, and tool `input`; we only
+                                    // overlay tool-part state/output/errorText for tool calls
+                                    // the wire copy has just resolved. Apps that slim the wire
+                                    // copy to fit the .in/append cap (or drop fields they
+                                    // re-source from their own DB) get the hydrated copy
+                                    // through unchanged.
                                     const merged = [...hydrated];
                                     for (const incoming of cleanedUIMessages) {
                                         if (!incoming.id)
                                             continue;
                                         const idx = merged.findIndex((m) => m.id === incoming.id);
                                         if (idx !== -1) {
-                                            merged[idx] = incoming;
+                                            merged[idx] = mergeIncomingIntoHydrated(merged[idx], incoming);
                                         }
                                     }
                                     accumulatedUIMessages = merged;
                                     accumulatedMessages = await toModelMessages(merged);
                                     locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
-                                    // Track new messages for onTurnComplete.newUIMessages
+                                    // Track new messages for onTurnComplete.newUIMessages.
+                                    // Only push for genuinely new ids — HITL continuations
+                                    // whose incoming wire id matches an existing entry are
+                                    // state advances on an old message, not new messages.
+                                    // We compare against `previouslyKnownMessageIds`
+                                    // captured BEFORE hydration, not against `hydrated`:
+                                    // the canonical hydrate pattern pushes the incoming
+                                    // user message into the persisted chain and returns
+                                    // it, so the new id IS in `hydrated`, which would
+                                    // wrongly drop every fresh user turn from
+                                    // `newUIMessages`. The non-hydrate branch below has
+                                    // the same "push only on append" semantic via its
+                                    // own append-vs-replace path.
                                     if (currentWirePayload.trigger === "submit-message" &&
                                         cleanedUIMessages.length > 0) {
                                         const lastUI = cleanedUIMessages[cleanedUIMessages.length - 1];
-                                        turnNewUIMessages.push(lastUI);
-                                        const lastModel = (await toModelMessages([lastUI]))[0];
-                                        if (lastModel)
-                                            turnNewModelMessages.push(lastModel);
+                                        const matchedExisting = lastUI.id !== undefined &&
+                                            previouslyKnownMessageIds.has(lastUI.id);
+                                        if (!matchedExisting) {
+                                            turnNewUIMessages.push(lastUI);
+                                            const lastModel = (await toModelMessages([lastUI]))[0];
+                                            if (lastModel)
+                                                turnNewModelMessages.push(lastModel);
+                                        }
                                     }
                                 }
                                 else {
@@ -3503,15 +3637,17 @@ function chatAgent(options) {
                                     else if (cleanedUIMessages.length > 0) {
                                         // Submit-message (and the special-cased
                                         // handover-prepare → submit-message rewrite earlier in
-                                        // this scope): append-or-replace-by-id for the single
-                                        // delta message.
+                                        // this scope): merge-or-append for the single delta
+                                        // message.
                                         //
                                         // Tool approval responses arrive as a single assistant
                                         // message whose id collides with the existing assistant
-                                        // in the accumulator — we replace by id. The fallback
-                                        // for HITL `addToolOutput` continuations where AI SDK
-                                        // regenerates the id (TRI-9137) still applies via
-                                        // `rewriteIncomingIdViaToolCallMap`.
+                                        // in the accumulator — we merge the resolved tool-part
+                                        // resolutions onto the existing entry, keeping text,
+                                        // reasoning, and tool `input` from the prior snapshot.
+                                        // The fallback for HITL `addToolOutput` continuations
+                                        // where AI SDK regenerates the id (TRI-9137) still
+                                        // applies via `rewriteIncomingIdViaToolCallMap`.
                                         let replaced = false;
                                         for (const raw of cleanedUIMessages) {
                                             let incoming = raw;
@@ -3524,7 +3660,7 @@ function chatAgent(options) {
                                                 }
                                             }
                                             if (idx !== -1) {
-                                                accumulatedUIMessages[idx] = incoming;
+                                                accumulatedUIMessages[idx] = mergeIncomingIntoHydrated(accumulatedUIMessages[idx], incoming);
                                                 replaced = true;
                                             }
                                             else {