fix(sdk): trace model steps and tool calls in chat.agent by default

`chat.agent` now traces each model step and tool call by default: the
`streamText` passed to `run()` turns AI SDK telemetry on even when no
prompt is stored with `chat.prompt.set()`. An agent with `telemetry: {
recordUserMessage: false }` gets these spans without prompt and response
content, including when it stores a prompt (whose variables are left out
of the span metadata). Pass `experimental_telemetry: { isEnabled: false
}` to turn them off, or `recordInputs` / `recordOutputs: false` to keep
them without content.
Mono-RevId: 8c1936ba08de8d3b6199a5d9e23384440b81f7d5

Author: ericallam

.changeset/chat-agent-telemetry-default.md

@@ -0,0 +1,5 @@
+---
+"@trigger.dev/sdk": patch
+---
+
+The `streamText` passed to a `chat.agent`'s `run()` now turns AI SDK telemetry on by default, so each model step and tool call shows up as a span in the run trace even when the agent doesn't store a prompt with `chat.prompt.set()`. An agent with `telemetry: { recordUserMessage: false }` gets these spans without prompt and response content, including when it stores a prompt (whose variables are left out of the span metadata). Pass `experimental_telemetry: { isEnabled: false }` at the call site to turn them off, or `recordInputs: false` / `recordOutputs: false` to keep them without content.

docs/ai-chat/backend.mdx

@@ -272,7 +272,7 @@ export const myChat = chat.agent({
 });
 ```
 
-The managed `streamText` carries the stored prompt's `system`, `model` (resolved through the agent's `registry`), sampling config, and `experimental_telemetry`. Options you pass at the call site win, apart from `system`, which throws when the prompt already set one.
+The managed `streamText` carries the stored prompt's `system`, `model` (resolved through the agent's `registry`), sampling config, and `experimental_telemetry`. AI SDK telemetry is on even without a stored prompt, so model steps and tool calls show in the run trace. Options you pass at the call site win, apart from `system`, which throws when the prompt already set one.
 
 `chat.toStreamTextOptions()` remains available for the same job, and is the only option in a [custom agent](#custom-agents), which has no `run` argument to take a bound `streamText` from. A `chat.headStart` route does get one, and there it also owns `messages`, `stopWhen` and `abortSignal`, since the handover depends on them. Pass `{ registry }` when a prompt names a provider-prefixed model, and `{ tools }` when you want HITL tool approvals, so the SDK knows which calls pause on `needsApproval`.
 

docs/ai-chat/patterns/redacting-telemetry.mdx

@@ -4,7 +4,7 @@ sidebarTitle: "Redact chat content"
 description: "Stop a chat agent recording user messages and clientData on its spans, turn off AI SDK prompt and response recording, or redact span content with a span processor before it leaves the worker."
 ---
 
-A chat agent's run trace records conversation content by default: the user's message and the `clientData` your frontend sends. When AI SDK telemetry is on, it also records the prompts and responses of each model call. This page covers the three controls that change that, and what they don't cover.
+A chat agent's run trace records conversation content by default: the user's message, the `clientData` your frontend sends, and, through AI SDK telemetry, the prompts and responses of each model call. This page covers the three controls that change that, and what they don't cover.
 
 ## What the run trace records
 
@@ -13,7 +13,7 @@ A chat agent's run trace records conversation content by default: the user's mes
 | `chat turn N` | The last user message (`chat.user_message`) and its first 80 characters as the span preview | `telemetry.recordUserMessage` |
 | `chat turn N` | The raw `clientData` (`chat.client_data`) | `telemetry.recordClientData` |
 | `pending message injected` | Messages sent mid-turn (`pending.messages`) | `telemetry.recordUserMessage` |
-| AI SDK model call spans, when AI SDK telemetry is on | Prompt messages, response text, tool calls | `experimental_telemetry` on the model call |
+| AI SDK model call spans (on by default with the `streamText` from `run`) | Prompt messages, response text, tool calls | `telemetry.recordUserMessage` for the default config, or `experimental_telemetry` on the model call |
 | Any span | Everything above, plus your own attributes and span events | A span processor |
 
 ## Stop recording chat content
@@ -32,11 +32,11 @@ export const supportAgent = chat.agent({
 });
 ```
 
-The spans still appear in the trace with their timings and token usage. The turn spans have no preview text.
+The spans still appear in the trace with their timings and token usage. The turn spans have no preview text. `recordUserMessage: false` also keeps prompts and responses out of the AI SDK spans that the `streamText` passed to `run()` turns on, with or without a prompt stored by `chat.prompt.set()`, and leaves a stored prompt's variables out of the span metadata, unless the call passes its own `experimental_telemetry`.
 
 ## Stop the AI SDK recording prompts and responses
 
-AI SDK model call spans appear when AI SDK telemetry is on: [`chat.prompt.set()`](/ai-chat/backend#using-prompts) turns it on for you, or you pass `experimental_telemetry` yourself. Those spans include prompts and responses unless you turn that off with `recordInputs` and `recordOutputs`:
+The `streamText` passed to `run()` turns AI SDK telemetry on, so each model call and tool call is a span in the run trace (pass `experimental_telemetry: { isEnabled: false }` to turn the spans off). If you call `streamText` from `ai` yourself, pass `experimental_telemetry` to get them. Those spans include prompts and responses unless you turn that off with `recordInputs` and `recordOutputs`:
 
 ```ts /trigger/support-agent.ts
 import { chat } from "@trigger.dev/sdk/ai";
@@ -50,7 +50,7 @@ export const supportAgent = chat.agent({
       model: anthropic("claude-sonnet-4-5"),
       messages,
       abortSignal: signal,
-      // Replaces any telemetry config from chat.prompt.set(), so keep isEnabled on
+      // Replaces the default telemetry config (and chat.prompt.set()'s), so keep isEnabled on
       experimental_telemetry: { isEnabled: true, recordInputs: false, recordOutputs: false },
     }),
 });

packages/trigger-sdk/src/v3/ai.ts

@@ -5282,6 +5282,25 @@ function toStreamTextOptions(
     Object.assign(result, telemetry);
   }
 
+  const telemetry = (result.experimental_telemetry as Record<string, unknown> | undefined) ?? {
+    isEnabled: true,
+    metadata: { ...(options?.telemetry ?? {}) },
+  };
+  if (locals.get(chatTurnContextKey)?.recordUserMessage === false) {
+    const { "prompt.input": _input, ...metadata } = (telemetry.metadata ?? {}) as Record<
+      string,
+      unknown
+    >;
+    result.experimental_telemetry = {
+      ...telemetry,
+      metadata,
+      recordInputs: false,
+      recordOutputs: false,
+    };
+  } else {
+    result.experimental_telemetry = telemetry;
+  }
+
   // Skills: merge auto-injected tools with any user-provided tools.
   // User tools override on name conflict (though we namespace ours).
   if (skills && skills.length > 0) {
@@ -16873,7 +16892,8 @@ export const chat = {
   /**
    * Returns an options object ready to spread into `streamText()`.
    * Reads the stored prompt and returns `{ system, experimental_telemetry, ...config }`.
-   * Returns `{}` if no prompt has been set.
+   * With no stored prompt it still returns `experimental_telemetry` (on), so the model call is
+   * traced.
    */
   toStreamTextOptions,
   /**

packages/trigger-sdk/test/bound-streamtext.test.ts

@@ -5,6 +5,7 @@ import { mockChatAgent } from "../src/v3/test/index.js";
 import { describe, expect, it } from "vitest";
 import { chat, __buildManagedStreamTextOptionsForTests as buildManaged } from "../src/v3/ai.js";
 import { chat as chatServer } from "../src/v3/chat-server.js";
+import { definePrompt } from "../src/v3/prompt.js";
 import { simulateReadableStream, stepCountIs, tool } from "ai";
 import { MockLanguageModelV3 } from "ai/test";
 import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
@@ -401,6 +402,91 @@ describe("what the managed streamText passes through", () => {
     expect(merged.experimental_telemetry).toBe(callerTelemetry);
   });
 
+  it("turns AI SDK telemetry on when no prompt is stored, so model steps and tool calls are traced", () => {
+    const merged = buildManaged({ model: "m" }, {});
+    expect(merged.experimental_telemetry).toEqual({ isEnabled: true, metadata: {} });
+  });
+
+  it.each([
+    { name: "default telemetry", key: "default", prompt: undefined, metadata: {} },
+    {
+      name: "stored prompt telemetry",
+      key: "string-prompt",
+      prompt: async () => "You are terse.",
+      metadata: {},
+    },
+    {
+      name: "resolved prompt telemetry and its variables",
+      key: "resolved-prompt",
+      prompt: () =>
+        definePrompt({
+          id: "bound-streamtext-redacted",
+          content: "Help {{name}}.",
+        }).resolve({ name: "secret" }),
+      metadata: {
+        "prompt.slug": "bound-streamtext-redacted",
+        "prompt.id": "bound-streamtext-redacted",
+        "prompt.version": "0",
+        "prompt.labels": "local",
+      },
+    },
+  ])(
+    "keeps prompt and response content out of $name when recordUserMessage is off",
+    async ({ key, prompt, metadata }) => {
+      const stored = await prompt?.();
+      const seen: unknown[] = [];
+      const model = new MockLanguageModelV3({
+        doStream: async () => ({
+          stream: simulateReadableStream({
+            chunks: [
+              { type: "text-start", id: "t" },
+              { type: "text-delta", id: "t", delta: "ok" },
+              { type: "text-end", id: "t" },
+              {
+                type: "finish",
+                finishReason: { unified: "stop", raw: "stop" },
+                usage: {
+                  inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
+                  outputTokens: { total: 1, text: 1, reasoning: 0 },
+                },
+              },
+            ] as LanguageModelV3StreamPart[],
+          }),
+        }),
+      });
+      const agent = chat.agent({
+        id: `bound-streamtext.redacted-telemetry-${key}`,
+        telemetry: { recordUserMessage: false },
+        run: async ({ messages, signal, streamText }) => {
+          if (stored) chat.prompt.set(stored);
+          seen.push(chat.toStreamTextOptions().experimental_telemetry);
+          return streamText({ model, messages, abortSignal: signal });
+        },
+      });
+      const harness = mockChatAgent(agent, { chatId: `bound-streamtext-redacted-${key}` });
+      try {
+        await harness.sendMessage({
+          id: "u1",
+          role: "user",
+          parts: [{ type: "text", text: "secret" }],
+        });
+        expect(seen[0]).toEqual({
+          isEnabled: true,
+          metadata,
+          recordInputs: false,
+          recordOutputs: false,
+        });
+      } finally {
+        await harness.close();
+      }
+    }
+  );
+
+  it("lets a caller turn telemetry off", () => {
+    const merged = buildManaged({ model: "m", experimental_telemetry: { isEnabled: false } }, {});
+    expect(merged.experimental_telemetry).toEqual({ isEnabled: false });
+  });
+
   it("carries the agent's system when the caller names none", () => {
     const merged = buildManaged({ model: "m" }, { system: "AGENT-SYSTEM" });
     expect(JSON.stringify(merged.system)).toContain("AGENT-SYSTEM");