@trigger.dev/sdk 0.0.0-chat-prerelease-20260506093419 → 0.0.0-chat-prerelease-20260507131256

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

@@ -263,6 +263,28 @@ export type ChatTurnUsage = LanguageModelUsage;
  * and converts to `ModelMessage[]` internally.
  */
 declare function setChatMessages<TUIM extends UIMessage = UIMessage>(uiMessages: TUIM[]): void;
+/**
+ * A tool call surfaced by `chat.history.getPendingToolCalls()` /
+ * `getResolvedToolCalls()`. Identifies the call by its `toolCallId` plus
+ * the `messageId` of the assistant message that hosts it, so callers can
+ * locate the part precisely without re-walking the chain.
+ */
+export type ChatToolCallRef = {
+    toolCallId: string;
+    toolName: string;
+    messageId: string;
+};
+/**
+ * A new tool result surfaced by `chat.history.extractNewToolResults()`.
+ * `errorText` is set iff the part is in `output-error` state; otherwise
+ * `output` carries the resolved value.
+ */
+export type ChatNewToolResult = {
+    toolCallId: string;
+    toolName: string;
+    output: unknown;
+    errorText?: string;
+};
 /** State stored in locals during prepareStep compaction. */
 interface CompactionState {
     summary: string;
@@ -2493,6 +2515,50 @@ export declare const chat: {
     history: {
         /** Read the current accumulated UI messages (copy). */
         all(): UIMessage[];
+        /**
+         * Read the current chain as an ordered `UIMessage[]`. Identical to
+         * `all()`; use whichever name reads better in context.
+         */
+        getChain(): UIMessage[];
+        /**
+         * Find a message by id. Returns `undefined` if no message with that id
+         * is present in the current chain.
+         */
+        findMessage(messageId: string): UIMessage | undefined;
+        /**
+         * Tool calls on the *most recent* assistant message that are still in
+         * `input-available` state (waiting on an `addToolOutput` answer). The
+         * scan walks back from the tail and stops at the first assistant
+         * message it finds, so a trailing user message does not change the
+         * result — pending tool calls remain pending until they're resolved
+         * on that assistant or the assistant is removed.
+         *
+         * Use this to gate fresh user turns or actions during HITL flows: if
+         * `getPendingToolCalls().length > 0`, an `addToolOutput` is expected.
+         *
+         * Returns `[]` if there is no assistant message yet, or if the most
+         * recent assistant has no pending tool calls.
+         *
+         * Approval flows (`approval-requested` / `approval-responded` states)
+         * are not surfaced here. Those are about the user authorizing a tool
+         * to run; "pending" is about the user *answering* a tool call.
+         */
+        getPendingToolCalls(): ChatToolCallRef[];
+        /**
+         * Tool calls across the chain with a final result (`output-available`
+         * or `output-error`). Use this to dedup re-saves when the AI SDK
+         * resends an assistant message with progressively more answered parts.
+         */
+        getResolvedToolCalls(): ChatToolCallRef[];
+        /**
+         * Pure helper: returns the tool parts in `message` whose results are
+         * not already represented in the current chain. Use this when
+         * persisting tool results to your own store: each call surfaces only
+         * the *new* answers, so writes stay idempotent across re-streams.
+         * Duplicate `toolCallId`s within `message` itself are also collapsed
+         * to a single entry.
+         */
+        extractNewToolResults(message: UIMessage): ChatNewToolResult[];
         /** Replace all accumulated messages. Same as `chat.setMessages()`. */
         set(messages: UIMessage[]): void;
         /** Remove a specific message by ID. */

package/dist/commonjs/v3/ai.js

@@ -807,6 +807,54 @@ const chatStopControllerKey = locals_js_1.locals.create("chat.stopController");
 const chatUIStreamStaticKey = locals_js_1.locals.create("chat.uiMessageStreamOptions.static");
 /** Per-turn UIMessageStream options, set via chat.setUIMessageStreamOptions(). @internal */
 const chatUIStreamPerTurnKey = locals_js_1.locals.create("chat.uiMessageStreamOptions.perTurn");
+/**
+ * Run-scoped `toolCallId → assistant messageId` map. Records the head
+ * assistant id whenever the accumulator absorbs an assistant message
+ * containing tool parts. Used as a fallback in the id-merge for
+ * incoming tool-answer messages — if the AI SDK regenerates the
+ * assistant id on a HITL `addToolOutput` resume, we look up the
+ * original head id by `toolCallId` and rewrite it before the merge.
+ *
+ * Customer-side workaround for the same case is documented in Arena
+ * AI's chat-agent task; lifting it into the SDK so customers don't
+ * have to. See TRI-9137.
+ * @internal
+ */
+const chatToolCallToMessageIdKey = locals_js_1.locals.create("chat.toolCallToMessageId");
+function recordToolCallIdsFromMessage(message) {
+    if (!message || message.role !== "assistant" || !message.id)
+        return;
+    let map = locals_js_1.locals.get(chatToolCallToMessageIdKey);
+    if (!map) {
+        map = new Map();
+        locals_js_1.locals.set(chatToolCallToMessageIdKey, map);
+    }
+    for (const part of message.parts ?? []) {
+        if (typeof part !== "object" || part == null)
+            continue;
+        const toolCallId = part.toolCallId;
+        if (typeof toolCallId === "string" && toolCallId.length > 0) {
+            map.set(toolCallId, message.id);
+        }
+    }
+}
+function rewriteIncomingIdViaToolCallMap(incoming) {
+    const map = locals_js_1.locals.get(chatToolCallToMessageIdKey);
+    if (!map || map.size === 0)
+        return incoming;
+    for (const part of incoming.parts ?? []) {
+        if (typeof part !== "object" || part == null)
+            continue;
+        const toolCallId = part.toolCallId;
+        if (typeof toolCallId !== "string" || toolCallId.length === 0)
+            continue;
+        const headId = map.get(toolCallId);
+        if (headId && headId !== incoming.id) {
+            return { ...incoming, id: headId };
+        }
+    }
+    return incoming;
+}
 function emptyUsage() {
     return {
         inputTokens: undefined,
@@ -872,19 +920,179 @@ function getChatHistoryState() {
     return locals_js_1.locals.get(chatCurrentUIMessagesKey) ?? [];
 }
 /**
- * Imperative API for modifying the accumulated message history.
+ * Tool parts that are "done" — either succeeded with a value or failed
+ * with an error. Excludes pending (`input-streaming`/`input-available`)
+ * and approval (`approval-requested`/`approval-responded`) states.
+ * @internal
+ */
+function isResolvedToolState(state) {
+    return state === "output-available" || state === "output-error";
+}
+/** @internal */
+function isPendingToolState(state) {
+    return state === "input-available";
+}
+/**
+ * Walk an assistant message and yield each tool part with its callId,
+ * name, and state. Skips non-assistant messages and non-tool parts.
+ * @internal
+ */
+function* iterateToolParts(message) {
+    if (message.role !== "assistant")
+        return;
+    for (const part of (message.parts ?? [])) {
+        if (!(0, ai_1.isToolUIPart)(part))
+            continue;
+        const toolCallId = part.toolCallId;
+        if (typeof toolCallId !== "string" || toolCallId.length === 0)
+            continue;
+        yield {
+            part,
+            toolCallId,
+            toolName: (0, ai_1.getToolName)(part),
+            state: part.state,
+        };
+    }
+}
+/**
+ * Tool parts on the *leaf* assistant message that are still waiting on
+ * an answer (`input-available` state). Used to gate fresh user turns
+ * during HITL flows.
+ * @internal
+ */
+function getPendingToolCallsFromHistory(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== "assistant")
+            continue;
+        const pending = [];
+        for (const { toolCallId, toolName, state } of iterateToolParts(msg)) {
+            if (isPendingToolState(state)) {
+                pending.push({ toolCallId, toolName, messageId: msg.id });
+            }
+        }
+        return pending;
+    }
+    return [];
+}
+/**
+ * All tool parts across the chain that have already produced an output
+ * (`output-available` or `output-error`). Used to dedup re-saves when
+ * the AI SDK resends an assistant with progressively more answered
+ * parts.
+ * @internal
+ */
+function getResolvedToolCallsFromHistory(messages) {
+    const out = [];
+    for (const msg of messages) {
+        for (const { toolCallId, toolName, state } of iterateToolParts(msg)) {
+            if (isResolvedToolState(state)) {
+                out.push({ toolCallId, toolName, messageId: msg.id });
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Pure helper: tool parts in `message` that have a fresh result not
+ * already represented by the resolved toolCallIds in `messages`. The
+ * `errorText` field is present only for `output-error` parts.
+ *
+ * Within a single `message`, duplicate `toolCallId`s emit only once
+ * (first occurrence wins). This guards against malformed assistants
+ * with repeated tool parts.
+ * @internal
+ */
+function extractNewToolResultsFromHistory(message, messages) {
+    const resolved = new Set(getResolvedToolCallsFromHistory(messages).map((r) => r.toolCallId));
+    const seen = new Set();
+    const out = [];
+    for (const { part, toolCallId, toolName, state } of iterateToolParts(message)) {
+        if (!isResolvedToolState(state))
+            continue;
+        if (resolved.has(toolCallId))
+            continue;
+        if (seen.has(toolCallId))
+            continue;
+        seen.add(toolCallId);
+        if (state === "output-error") {
+            out.push({ toolCallId, toolName, output: undefined, errorText: part.errorText });
+        }
+        else {
+            out.push({ toolCallId, toolName, output: part.output });
+        }
+    }
+    return out;
+}
+/**
+ * Imperative API for reading and modifying the accumulated message history.
  *
  * Mutations use the same deferred override mechanism as `chat.setMessages()`:
- * they are applied at lifecycle checkpoints (after hooks return).
+ * they are applied at lifecycle checkpoints (after hooks return). Reads are
+ * synchronous against the current accumulator state.
  *
  * Can be called from `onTurnStart`, `onBeforeTurnComplete`, `onTurnComplete`,
- * `run()`, or AI SDK tools.
+ * `run()`, `onAction`, or AI SDK tools.
  */
 const chatHistory = {
     /** Read the current accumulated UI messages (copy). */
     all() {
         return [...getChatHistoryState()];
     },
+    /**
+     * Read the current chain as an ordered `UIMessage[]`. Identical to
+     * `all()`; use whichever name reads better in context.
+     */
+    getChain() {
+        return chatHistory.all();
+    },
+    /**
+     * Find a message by id. Returns `undefined` if no message with that id
+     * is present in the current chain.
+     */
+    findMessage(messageId) {
+        return getChatHistoryState().find((m) => m.id === messageId);
+    },
+    /**
+     * Tool calls on the *most recent* assistant message that are still in
+     * `input-available` state (waiting on an `addToolOutput` answer). The
+     * scan walks back from the tail and stops at the first assistant
+     * message it finds, so a trailing user message does not change the
+     * result — pending tool calls remain pending until they're resolved
+     * on that assistant or the assistant is removed.
+     *
+     * Use this to gate fresh user turns or actions during HITL flows: if
+     * `getPendingToolCalls().length > 0`, an `addToolOutput` is expected.
+     *
+     * Returns `[]` if there is no assistant message yet, or if the most
+     * recent assistant has no pending tool calls.
+     *
+     * Approval flows (`approval-requested` / `approval-responded` states)
+     * are not surfaced here. Those are about the user authorizing a tool
+     * to run; "pending" is about the user *answering* a tool call.
+     */
+    getPendingToolCalls() {
+        return getPendingToolCallsFromHistory(getChatHistoryState());
+    },
+    /**
+     * Tool calls across the chain with a final result (`output-available`
+     * or `output-error`). Use this to dedup re-saves when the AI SDK
+     * resends an assistant message with progressively more answered parts.
+     */
+    getResolvedToolCalls() {
+        return getResolvedToolCallsFromHistory(getChatHistoryState());
+    },
+    /**
+     * Pure helper: returns the tool parts in `message` whose results are
+     * not already represented in the current chain. Use this when
+     * persisting tool results to your own store: each call surfaces only
+     * the *new* answers, so writes stay idempotent across re-streams.
+     * Duplicate `toolCallId`s within `message` itself are also collapsed
+     * to a single entry.
+     */
+    extractNewToolResults(message) {
+        return extractNewToolResultsFromHistory(message, getChatHistoryState());
+    },
     /** Replace all accumulated messages. Same as `chat.setMessages()`. */
     set(messages) {
         locals_js_1.locals.set(chatOverrideMessagesKey, messages);
@@ -2361,9 +2569,24 @@ function chatAgent(options) {
                                         // IDs match because we always pass generateMessageId + originalMessages
                                         // to toUIMessageStream, so the backend's start chunk carries the same
                                         // messageId that the frontend uses.
+                                        //
+                                        // Fallback for HITL `addToolOutput` continuations where the AI SDK
+                                        // regenerates the assistant id (Arena AI report, TRI-9137): if the
+                                        // id-match fails, look up the head messageId via toolCallId and
+                                        // rewrite the incoming id before retrying. The mapping is
+                                        // populated whenever an assistant containing tool parts lands in
+                                        // the accumulator.
                                         let replaced = false;
-                                        for (const incoming of cleanedUIMessages) {
-                                            const idx = accumulatedUIMessages.findIndex((m) => m.id === incoming.id);
+                                        for (const raw of cleanedUIMessages) {
+                                            let incoming = raw;
+                                            let idx = accumulatedUIMessages.findIndex((m) => m.id === incoming.id);
+                                            if (idx === -1) {
+                                                const rewritten = rewriteIncomingIdViaToolCallMap(incoming);
+                                                if (rewritten.id !== incoming.id) {
+                                                    incoming = rewritten;
+                                                    idx = accumulatedUIMessages.findIndex((m) => m.id === incoming.id);
+                                                }
+                                            }
                                             if (idx !== -1) {
                                                 accumulatedUIMessages[idx] = incoming;
                                                 replaced = true;
@@ -2372,6 +2595,7 @@ function chatAgent(options) {
                                                 accumulatedUIMessages.push(incoming);
                                                 turnNewUIMessages.push(incoming);
                                             }
+                                            recordToolCallIdsFromMessage(incoming);
                                         }
                                         if (replaced) {
                                             // Reconvert all model messages since a replacement changes the structure
@@ -2773,6 +2997,12 @@ function chatAgent(options) {
                                     }
                                     turnNewUIMessages.push(capturedResponseMessage);
                                     locals_js_1.locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
+                                    // Record toolCallId → head messageId so a HITL
+                                    // continuation next turn can recover the head id
+                                    // even if the AI SDK regenerates it. See
+                                    // `chatToolCallToMessageIdKey` for the full
+                                    // rationale (TRI-9137).
+                                    recordToolCallIdsFromMessage(capturedResponseMessage);
                                     try {
                                         const responseModelMessages = await toModelMessages([
                                             stripProviderMetadata(capturedResponseMessage),