ai 7.0.161 → 7.0.162

package/docs/03-agents/06-tool-approvals.mdx

@@ -296,6 +296,8 @@ In the standard `useChat` pattern, the server rebuilds the conversation from the
 
 Tool approvals reconstructed from this history are re-validated before execution: the tool input is checked against the tool's schema, and the approval policy is re-evaluated. However, without additional protection, a client that crafts a valid-looking approval for a schema-conforming input can bypass the human-in-the-loop step.
 
+During re-validation, `toolCall.toolMetadata` and `toolCall.dynamic` come from the current server-side tool definition. The deprecated `toolCall.title` field is also restored from that definition. A server-side policy denial prevents execution even when the client supplies an approved response with a valid signature.
+
 If your tools perform sensitive operations (modifying data, spending money, calling external APIs, accessing private resources), use `experimental_toolApprovalSecret` to cryptographically bind approvals to the server that issued them.
 
 ### Signing approvals with `experimental_toolApprovalSecret`

package/docs/03-ai-sdk-core/60-telemetry.mdx

@@ -253,6 +253,42 @@ registerTelemetry(
 );
 ```
 
+## Durable WorkflowAgent runs
+
+The steps of a durable `WorkflowAgent` run (`@ai-sdk/workflow`) can execute in
+different processes. To report the run as one `invoke_agent` span tree, use the
+same `OpenTelemetryIdGenerator` instance as your tracer provider's ID generator
+and sampler, and pass it to the globally registered `OpenTelemetry` integration:
+
+```ts
+import { OpenTelemetry, OpenTelemetryIdGenerator } from '@ai-sdk/otel';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { registerTelemetry } from 'ai';
+
+const durable = new OpenTelemetryIdGenerator();
+new NodeSDK({ idGenerator: durable, sampler: durable }).start();
+registerTelemetry(new OpenTelemetry({ durable }));
+```
+
+Model calls are reported live from their durable steps, so spans started by the
+provider call (for example auto-instrumented HTTP spans) nest under their `chat`
+span. The root, step, and tool spans appear when the run ends or suspends (for
+example on a tool approval), using the original event timestamps. The root
+includes the run's prompt and final output, subject to `recordInputs` and
+`recordOutputs`.
+
+A preparation step captures the active parent trace and makes the run's sampling
+decision once. That context is carried to subsequent steps, preserving the trace
+ID, sampling decision, and trace state. By default, the bridge uses parent-based
+sampling with roots enabled. To use another sampler, pass it through
+`new OpenTelemetryIdGenerator({ sampler: yourSampler })` and keep the bridge as
+the provider's sampler. Unrelated spans use random IDs and the configured sampler.
+
+Install this setup in every process that executes workflow steps, with integrations
+registered in the same order. Without the bridge, `OpenTelemetry` preserves live
+per-model operation traces. Other globally registered telemetry integrations receive
+the recorded run lifecycle when it ends or suspends.
+
 ## Telemetry Integrations
 
 Telemetry integrations let you hook into the generation lifecycle to build custom observability — logging, analytics, DevTools, or any other monitoring system. Instead of wiring up individual callbacks on every call, you implement a `Telemetry` once and register it globally or pass it via `telemetry.integrations`.
@@ -395,6 +431,18 @@ export function myIntegration(): Telemetry {
 }
 ```
 
+For durable workflows, integrations normally receive recorded events after the
+run ends. Events can include `timestamp` (Unix milliseconds); use it for span
+start and end times instead of the current time. Integrations that can reconstruct
+traces across processes can implement the experimental
+`experimental_durable.captureContext(event)` hook. It runs in a preparation step
+and returns a serializable `DurableTelemetryContext`. Live model-start events
+then carry that context in `event.durableContext` with `phase: 'live'`; the
+recorded operation-start event carries it with `phase: 'replay'`. Such integrations
+should skip replayed model events to avoid duplicate spans. Returning `undefined`
+selects live per-model operations instead, with no deferred replay to that
+integration.
+
 ### Available lifecycle methods
 
 <PropertiesTable

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.161",
+  "version": "7.0.162",
   "type": "module",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
@@ -42,20 +42,20 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.134",
+    "@ai-sdk/gateway": "4.0.135",
     "@ai-sdk/provider": "4.0.35",
-    "@ai-sdk/provider-utils": "5.0.73"
+    "@ai-sdk/provider-utils": "5.0.74"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.131",
-    "@ai-sdk/deepseek": "3.0.78",
-    "@ai-sdk/google": "4.0.110",
-    "@ai-sdk/groq": "4.0.75",
-    "@ai-sdk/huggingface": "2.0.83",
-    "@ai-sdk/moonshotai": "3.0.83",
-    "@ai-sdk/openai": "4.0.107",
+    "@ai-sdk/amazon-bedrock": "5.0.132",
+    "@ai-sdk/deepseek": "3.0.79",
+    "@ai-sdk/google": "4.0.111",
+    "@ai-sdk/groq": "4.0.76",
+    "@ai-sdk/huggingface": "2.0.84",
+    "@ai-sdk/moonshotai": "3.0.84",
+    "@ai-sdk/openai": "4.0.108",
     "@ai-sdk/test-server": "2.0.4",
-    "@ai-sdk/xai": "5.0.37",
+    "@ai-sdk/xai": "5.0.38",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/generate-text/validate-tool-approvals.ts

@@ -57,13 +57,31 @@ export async function validateApprovedToolApprovals<
     CollectedToolApprovals<TOOLS> & { error: InvalidToolInputError }
   > = [];
 
-  for (const approval of approvedToolApprovals) {
-    const { approvalRequest, toolCall } = approval;
+  for (const collectedApproval of approvedToolApprovals) {
     // Look up the tool by own property only: `toolName` comes from
     // client-supplied history, so a name matching an inherited object property
     // (e.g. `constructor`, `toString`) must resolve to "no such tool" rather
     // than a prototype value that would silently skip input validation below.
-    const tool = getOwn(tools, toolCall.toolName);
+    const tool = getOwn(tools, collectedApproval.toolCall.toolName);
+
+    // History can omit or alter these fields. Rebuild them from the current
+    // server-side definition before input refinement and approval policy checks,
+    // just as parsing a new model tool call does.
+    const {
+      toolMetadata: _toolMetadata,
+      dynamic: _dynamic,
+      ...toolCallFromHistory
+    } = collectedApproval.toolCall;
+    const approval: CollectedToolApprovals<TOOLS> = {
+      ...collectedApproval,
+      toolCall: {
+        ...toolCallFromHistory,
+        ...(tool?.metadata != null ? { toolMetadata: tool.metadata } : {}),
+        ...(tool?.type === 'dynamic' ? { dynamic: true } : {}),
+        title: tool?.title,
+      } as typeof collectedApproval.toolCall,
+    };
+    const { approvalRequest, toolCall } = approval;
 
     if (toolApprovalSecret != null) {
       if (approvalRequest.signature == null) {

package/src/telemetry/index.ts

@@ -1,5 +1,10 @@
 export type { TelemetryOptions } from './telemetry-options';
-export type { InferTelemetryEvent, Telemetry } from './telemetry';
+export type {
+  DurableTelemetryContext,
+  DurableTelemetryEventContext,
+  InferTelemetryEvent,
+  Telemetry,
+} from './telemetry';
 export { registerTelemetry } from './telemetry-registry';
 export {
   AI_SDK_TELEMETRY_TRACING_CHANNEL,

package/src/telemetry/telemetry.ts

@@ -56,6 +56,43 @@ import type { TelemetryOptions } from '../telemetry/telemetry-options';
 import type { TelemetryTracingEventType } from './tracing-channel';
 import type { TracingChannelContext } from './tracing-channel-publisher';
 
+/** Serializable tracing identity shared by the processes of a durable run. */
+export type DurableTelemetryContext = {
+  traceId: string;
+  rootSpanId: string;
+  /** The integration's root-span data, reused when the run is reported. */
+  rootSpanName?: string;
+  rootAttributes?: Record<
+    string,
+    | string
+    | number
+    | boolean
+    | Array<string | null | undefined>
+    | Array<number | null | undefined>
+    | Array<boolean | null | undefined>
+    | undefined
+  >;
+  traceFlags: number;
+  traceState?: string;
+  samplingDecision: 0 | 1 | 2;
+  parentSpanContext?: {
+    traceId: string;
+    spanId: string;
+    traceFlags: number;
+    traceState?: string;
+  };
+};
+
+/** Identifies live model events and the run events reported after completion. */
+export type DurableTelemetryEventContext = {
+  run: DurableTelemetryContext;
+  stepNumber?: number;
+  phase: 'live' | 'replay';
+  /** Context has already been filtered before crossing the step boundary. */
+  runtimeContext?: Record<string, unknown>;
+  headers?: Record<string, string | undefined>;
+};
+
 export type InferTelemetryEvent<EVENT> = EVENT &
   Omit<
     TelemetryOptions,
@@ -66,6 +103,16 @@ export type InferTelemetryEvent<EVENT> = EVENT &
      * Absent in older releases.
      */
     readonly aiVersion?: string;
+
+    /**
+     * Time at which the event occurred, in milliseconds since the Unix epoch.
+     *
+     * Set when events are reported after they happened, for example when a
+     * durable workflow reports a run that spanned several processes.
+     * Integrations should use it instead of the current time when present.
+     */
+    readonly timestamp?: number;
+    readonly durableContext?: DurableTelemetryEventContext;
   };
 
 type BivariantCallback<EVENT> = {
@@ -142,6 +189,21 @@ export interface TelemetryDispatcher {
  * Methods can be sync or return a PromiseLike.
  */
 export interface Telemetry {
+  /**
+   * Capture a serializable tracing identity before a durable run's model calls.
+   * Return undefined to preserve live per-model operations when the integration
+   * cannot reconstruct a run span across processes. Integrations without this
+   * hook receive the recorded lifecycle after completion.
+   */
+  experimental_durable?: {
+    captureContext: (
+      event: InferTelemetryEvent<GenerateTextStartEvent>,
+    ) =>
+      | DurableTelemetryContext
+      | undefined
+      | PromiseLike<DurableTelemetryContext | undefined>;
+  };
+
   /**
    * Called when an operation begins. Fired for text generation
    * (generateText/streamText), object generation (generateObject/streamObject),