@trigger.dev/sdk 4.5.0-rc.3 → 4.5.0-rc.5

package/dist/esm/v3/ai.js

@@ -1,5 +1,7 @@
 import { accessoryAttributes, apiClientManager, getSchemaParseFn, headerValue, InputStreamOncePromise, isSchemaZodEsque, logger, ManualWaitpointPromise, OutOfMemoryError, sessionStreams, SemanticInternalAttributes, taskContext, SESSION_IN_EVENT_ID_HEADER, TRIGGER_CONTROL_SUBTYPE, generateJWT, } from "@trigger.dev/core/v3";
-import { convertToModelMessages, dynamicTool, generateId as generateMessageId, getToolName, isToolUIPart, jsonSchema, readUIMessageStream, tool as aiTool, zodSchema, } from "ai";
+// Runtime VALUES go through the ESM/CJS shim so the CJS build can `require`
+// ESM-only `ai@7` (see ../imports/ai-runtime.ts).
+import { convertToModelMessages, dynamicTool, generateId as generateMessageId, getToolName, isToolUIPart, jsonSchema, readUIMessageStream, tool as aiTool, zodSchema, } from "../imports/ai-runtime.js";
 import { trace } from "@opentelemetry/api";
 import { auth } from "./auth.js";
 import { locals } from "./locals.js";
@@ -16,6 +18,7 @@ import { runBashInSkill, readFileInSkill } from "./agentSkillsRuntime.js";
 import { markChatAgentRunForStreamsWarning } from "./streams.js";
 import { sessions, } from "./sessions.js";
 import { createTask } from "./shared.js";
+import { ensureAiSdkTelemetry } from "./aiAutoTelemetry.js";
 import { resourceCatalog } from "@trigger.dev/core/v3";
 import { tracer } from "./tracer.js";
 const METADATA_KEY = "tool.execute.options";
@@ -25,7 +28,16 @@ const METADATA_KEY = "tool.execute.options";
  * stopped/aborted conversations with partial tool parts.
  */
 function toModelMessages(messages) {
-    return convertToModelMessages(messages, { ignoreIncompleteToolCalls: true });
+    // Pass the resolved per-turn `tools` (if any) so the AI SDK can look up each
+    // tool's `toModelOutput` and re-apply it to prior-turn tool results. Without
+    // `tools` it falls back to JSON-stringifying the raw output (TRI-10149). The
+    // conditional spread keeps the options object byte-identical to the no-tools
+    // path when nothing was declared.
+    const tools = locals.get(chatResolvedToolsKey);
+    return convertToModelMessages(messages, {
+        ignoreIncompleteToolCalls: true,
+        ...(tools ? { tools } : {}),
+    });
 }
 const chatTurnContextKey = locals.create("chat.turnContext");
 /**
@@ -632,9 +644,14 @@ function createTaskToolExecuteHandler(task) {
         const toolMeta = {
             toolCallId: toolOpts?.toolCallId ?? "",
         };
-        if (toolOpts?.experimental_context !== undefined) {
+        // v6 passes user context as `experimental_context`, v7 as `context`. Read
+        // whichever is set and stamp both so subtasks reading either name work.
+        const toolContext = toolOpts?.context ?? toolOpts?.experimental_context;
+        if (toolContext !== undefined) {
             try {
-                toolMeta.experimental_context = JSON.parse(JSON.stringify(toolOpts.experimental_context));
+                const serialized = JSON.parse(JSON.stringify(toolContext));
+                toolMeta.experimental_context = serialized;
+                toolMeta.context = serialized;
             }
             catch {
                 /* non-serializable */
@@ -1730,6 +1747,18 @@ const chatOnCompactedKey = locals.create("chat.onCompacted");
 /** @internal Full task `ctx` for the active `chat.agent` run (for hooks invoked from nested compaction). */
 const chatAgentRunContextKey = locals.create("chat.agentRunContext");
 const chatPrepareMessagesKey = locals.create("chat.prepareMessages");
+/**
+ * @internal The raw `tools` option from `chat.agent({ tools })`, either a
+ * static `ToolSet` or a per-turn function. Set once at boot.
+ */
+const chatToolsOptionKey = locals.create("chat.toolsOption");
+/**
+ * @internal The concrete `ToolSet` resolved for the current turn. Read by
+ * `toModelMessages` so `convertToModelMessages` can re-run `toModelOutput` on
+ * prior-turn tool results. Unset when no `tools` were declared (preserves the
+ * exact pre-feature conversion behavior).
+ */
+const chatResolvedToolsKey = locals.create("chat.resolvedTools");
 /** @internal Flag set by `chat.requestUpgrade()` to exit the loop after the current turn. */
 const chatUpgradeRequestedKey = locals.create("chat.upgradeRequested");
 /**
@@ -1821,6 +1850,37 @@ async function applyPrepareMessages(messages, reason) {
         },
     });
 }
+/**
+ * Resolve the `tools` option into a concrete `ToolSet` and cache it in locals so
+ * `toModelMessages` can pass it to `convertToModelMessages`. For the function
+ * form, invokes the user function with the given context (or the current turn
+ * context when no override is passed). Pass an `override` for the boot-time
+ * history conversion, which runs before the per-turn context exists and uses
+ * the run/continuation payload's `clientData`.
+ *
+ * Fails closed: a throwing resolver propagates rather than carrying a prior
+ * turn's set forward. The function form can gate capabilities by user or flag,
+ * so reusing stale tools would leak capabilities. No-op when no `tools` were
+ * declared.
+ * @internal
+ */
+async function resolveTurnTools(override) {
+    const option = locals.get(chatToolsOptionKey);
+    if (!option)
+        return;
+    if (typeof option !== "function") {
+        locals.set(chatResolvedToolsKey, option);
+        return;
+    }
+    const ctx = override ?? locals.get(chatTurnContextKey);
+    const resolved = await option({
+        chatId: ctx?.chatId ?? "",
+        turn: ctx?.turn ?? 0,
+        continuation: ctx?.continuation ?? false,
+        clientData: ctx?.clientData,
+    });
+    locals.set(chatResolvedToolsKey, resolved);
+}
 /**
  * Read the current compaction state. Returns the summary and base message count
  * if compaction has occurred in this turn, or `undefined` if not.
@@ -2546,7 +2606,7 @@ function chatCustomAgent(options) {
     return task;
 }
 function chatAgent(options) {
-    const { run: userRun, clientDataSchema, onBoot, onRecoveryBoot, onPreload, onChatStart, onValidateMessages, hydrateMessages, actionSchema, onAction, onTurnStart, onBeforeTurnComplete, onCompacted, compaction, pendingMessages: pendingMessagesConfig, prepareMessages, onTurnComplete, maxTurns = 100, turnTimeout = "1h", idleTimeoutInSeconds = 30, chatAccessTokenTTL = "1h", preloadIdleTimeoutInSeconds, preloadTimeout, uiMessageStreamOptions, onChatSuspend, onChatResume, exitAfterPreloadIdle = false, oomMachine, ...restOptions } = options;
+    const { run: userRun, clientDataSchema, onBoot, onRecoveryBoot, onPreload, onChatStart, onValidateMessages, hydrateMessages, actionSchema, onAction, onTurnStart, onBeforeTurnComplete, onCompacted, compaction, pendingMessages: pendingMessagesConfig, prepareMessages, tools: toolsOption, onTurnComplete, maxTurns = 100, turnTimeout = "1h", idleTimeoutInSeconds = 30, chatAccessTokenTTL = "1h", preloadIdleTimeoutInSeconds, preloadTimeout, uiMessageStreamOptions, onChatSuspend, onChatResume, exitAfterPreloadIdle = false, oomMachine, ...restOptions } = options;
     const parseClientData = clientDataSchema ? getSchemaParseFn(clientDataSchema) : undefined;
     const parseAction = actionSchema ? getSchemaParseFn(actionSchema) : undefined;
     // chat.agent does not expose generic retry options (see docstring on
@@ -2563,6 +2623,11 @@ function chatAgent(options) {
         agentConfig: { type: "ai-sdk-chat" },
         run: async (payload, { signal: runSignal, ctx }) => {
             locals.set(chatAgentRunContextKey, ctx);
+            // On AI SDK 7, register the `@ai-sdk/otel` integration (once per process)
+            // so `experimental_telemetry` spans flow into the run trace. Awaited here
+            // at run boot — before any `streamText` — and a no-op on v5/v6 or when the
+            // optional `@ai-sdk/otel` peer isn't installed. See ./aiAutoTelemetry.ts.
+            await ensureAiSdkTelemetry();
             // Bind the run to its backing Session so every module-level helper
             // (chat.stream, chat.messages, chat.stopSignal) resolves to this
             // chat's `.in` / `.out` channels.
@@ -2595,6 +2660,19 @@ function chatAgent(options) {
             if (prepareMessages) {
                 locals.set(chatPrepareMessagesKey, prepareMessages);
             }
+            if (toolsOption) {
+                // Cast: the option's function form is typed against the parsed
+                // `clientData` (`ResolveToolsEvent<inferSchemaOut<...>>`), but the
+                // locals key uses the erased `ResolveToolsEvent<unknown>`. The runtime
+                // value is identical; this mirrors how `prepareMessages` is stored.
+                locals.set(chatToolsOptionKey, toolsOption);
+                // Static tools are usable immediately. The function form is resolved
+                // just before the boot history conversion (with the payload's
+                // clientData) and again per-turn (see resolveTurnTools).
+                if (typeof toolsOption !== "function") {
+                    locals.set(chatResolvedToolsKey, toolsOption);
+                }
+            }
             if (compaction) {
                 locals.set(chatAgentCompactionKey, compaction);
             }
@@ -2925,6 +3003,27 @@ function chatAgent(options) {
                     accumulatedUIMessages = [...payload.headStartMessages];
                 }
                 if (accumulatedUIMessages.length > 0) {
+                    // Resolve a function-form `tools` with the run/continuation payload's
+                    // clientData so this conversion of the restored history applies each
+                    // tool's toModelOutput (static tools were already seeded above). This
+                    // only re-renders saved history, so it fails open: a resolver hiccup
+                    // logs and converts without tools rather than blocking the resume.
+                    // Per-turn resolveTurnTools still fails closed for live turns.
+                    if (typeof toolsOption === "function") {
+                        try {
+                            await resolveTurnTools({
+                                chatId: payload.chatId,
+                                turn: 0,
+                                continuation: payload.continuation ?? false,
+                                clientData: parseClientData
+                                    ? await parseClientData(payload.metadata)
+                                    : payload.metadata,
+                            });
+                        }
+                        catch (error) {
+                            logger.warn("chat.agent: tools() resolver threw at boot; restored history converted without toModelOutput", { error: error instanceof Error ? error.message : String(error) });
+                        }
+                    }
                     try {
                         accumulatedMessages = await toModelMessages(accumulatedUIMessages);
                     }
@@ -3346,6 +3445,10 @@ function chatAgent(options) {
                                 continuation,
                                 clientData,
                             });
+                            // Resolve the per-turn `tools` set now that turn context
+                            // (incl. parsed clientData) exists, so every toModelMessages
+                            // call this turn can re-apply tool `toModelOutput`.
+                            await resolveTurnTools();
                             // Per-turn stop controller (reset each turn)
                             const stopController = new AbortController();
                             currentStopController = stopController;
@@ -3915,6 +4018,7 @@ function chatAgent(options) {
                                             previousTurnUsage,
                                             totalUsage: cumulativeUsage,
                                             ctx,
+                                            tools: locals.get(chatResolvedToolsKey) ?? {},
                                             signal: combinedSignal,
                                             cancelSignal,
                                             stopSignal,