ai 7.0.160 → 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/docs/03-ai-sdk-harnesses/02-harness-agent.mdx

@@ -579,6 +579,61 @@ to `'.'` to use the sandbox's default working directory itself. When omitted,
 regular sessions use the default `<harnessId>-<sessionId>` directory, while
 `onBootstrap` receives the sandbox's default working directory.
 
+When the harness declares a sandbox bootstrap recipe, as Claude Code and Codex
+do, `createSession()` runs the session's sandbox setup before the harness
+starts: it runs `onBootstrap` when its marker is missing, creates the session
+working directory, and calls `onSession`. For any other harness, such as Pi,
+the setup runs on the first file, exec, or spawn operation that the harness or
+a host tool performs on the sandbox. A session whose turns never touch the
+sandbox then makes no setup calls. If the setup fails, the operation that
+triggered it rejects, and the next operation runs the setup again. A sandbox
+session without `defaultWorkingDirectory` still answers one `pwd` in
+`createSession()`, because the session working directory is derived from it.
+When the sandbox comes from the `sandbox` provider setting instead of
+`sandboxSession`, the provider runs `onBootstrap` when it creates a new
+sandbox, which happens in `createSession()`.
+
+## Start the Sandbox on First Use
+
+Deferring the setup does not defer the sandbox itself: a session you pass to
+`createSession()` already exists. To defer the sandbox as well, pass
+`defaultWorkingDirectory` and a `createSandboxSession` function instead. With
+a harness that has no sandbox bootstrap recipe, such as Pi, `createSession()`
+returns without calling `createSandboxSession`, and the first file, exec, or
+spawn operation calls it, so a turn that only chats never starts the sandbox.
+For any other harness, `createSession()` calls it right away.
+
+```ts
+import { HarnessAgent } from '@ai-sdk/harness/agent';
+import { pi } from '@ai-sdk/harness-pi';
+import { createVercelNetworkSandboxSessionFromNativeSandbox } from '@ai-sdk/sandbox-vercel';
+import { Sandbox } from '@vercel/sandbox';
+
+const agent = new HarnessAgent({ harness: pi });
+
+const session = await agent.createSession({
+  sessionId: chatId,
+  resumeFrom: resumeState,
+  sandboxSession: {
+    defaultWorkingDirectory: '/vercel/sandbox',
+    createSandboxSession: async () =>
+      createVercelNetworkSandboxSessionFromNativeSandbox(
+        await Sandbox.getOrCreate({
+          name: `chat-${chatId}`,
+          runtime: 'node24',
+        }),
+      ),
+  },
+});
+```
+
+The harness needs the working directory before the sandbox exists, so
+`defaultWorkingDirectory` must match the one the sandbox reports. Because the
+sandbox is looked up by name, the same call works for the first turn and for
+every later one. A failed `createSandboxSession` or setup is retried on the
+next operation. You own the sandbox lifecycle, as with any session you pass to
+`createSession()`.
+
 ## Prepare Reusable Sandboxes
 
 Use `agent.getSandboxTemplate()` to resolve one harness's bootstrap recipe and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.160",
+  "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.133",
+    "@ai-sdk/gateway": "4.0.135",
     "@ai-sdk/provider": "4.0.35",
-    "@ai-sdk/provider-utils": "5.0.72"
+    "@ai-sdk/provider-utils": "5.0.74"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.130",
-    "@ai-sdk/deepseek": "3.0.77",
-    "@ai-sdk/google": "4.0.109",
-    "@ai-sdk/groq": "4.0.74",
-    "@ai-sdk/huggingface": "2.0.82",
-    "@ai-sdk/moonshotai": "3.0.82",
-    "@ai-sdk/openai": "4.0.106",
+    "@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.36",
+    "@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/generated-file.ts

@@ -1,3 +1,4 @@
+import { convertDataContentToUint8Array } from '../prompt/data-content';
 import {
   convertBase64ToUint8Array,
   convertUint8ArrayToBase64,
@@ -48,13 +49,15 @@ export class DefaultGeneratedFile implements GeneratedFile {
     mediaType,
     providerMetadata,
   }: {
-    data: string | Uint8Array;
+    data: string | Uint8Array | ArrayBuffer;
     mediaType: string;
     providerMetadata?: Record<string, JSONObject>;
   }) {
-    const isUint8Array = data instanceof Uint8Array;
-    this.base64Data = isUint8Array ? undefined : data;
-    this.uint8ArrayData = isUint8Array ? data : undefined;
+    this.base64Data = typeof data === 'string' ? data : undefined;
+    this.uint8ArrayData =
+      typeof data === 'string'
+        ? undefined
+        : convertDataContentToUint8Array(data);
     this.mediaType = mediaType;
     this.providerMetadata = providerMetadata;
   }

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/prompt/clone-model-message.ts

@@ -1,4 +1,8 @@
-import type { ModelMessage } from '@ai-sdk/provider-utils';
+import {
+  isArrayBuffer,
+  isUint8Array,
+  type ModelMessage,
+} from '@ai-sdk/provider-utils';
 
 /**
  * Clone model messages while preserving URL instances. Node's structuredClone
@@ -7,35 +11,67 @@ import type { ModelMessage } from '@ai-sdk/provider-utils';
 export function cloneModelMessages<T extends ModelMessage>(
   messages: Array<T>,
 ): Array<T> {
-  return messages.map(message => cloneValue(message)) as Array<T>;
+  return cloneValue(messages, new Map()) as Array<T>;
 }
 
-function cloneValue<T>(value: T): T {
+function cloneValue(value: unknown, seen: Map<object, unknown>): unknown {
+  if (value == null || typeof value !== 'object') {
+    return value;
+  }
+
+  if (seen.has(value)) {
+    return seen.get(value);
+  }
+
   if (value instanceof URL) {
-    return new URL(value.href) as T;
+    const copy = new URL(value.href);
+    seen.set(value, copy);
+    return copy;
   }
 
   if (Array.isArray(value)) {
-    return value.map(item => cloneValue(item)) as T;
+    const copy: unknown[] = new Array(value.length);
+    seen.set(value, copy);
+    value.forEach((item, index) => {
+      copy[index] = cloneValue(item, seen);
+    });
+    return copy;
   }
 
-  if (value instanceof Uint8Array) {
-    return new Uint8Array(value) as T;
+  if (isUint8Array(value)) {
+    const copy = new Uint8Array(value);
+    seen.set(value, copy);
+    return copy;
   }
 
-  if (value instanceof ArrayBuffer) {
-    return value.slice(0) as T;
+  if (isArrayBuffer(value)) {
+    const copy = new Uint8Array(value).slice().buffer;
+    seen.set(value, copy);
+    return copy;
   }
 
-  if (value instanceof Date) {
-    return new Date(value) as T;
+  if (
+    value instanceof Date ||
+    Object.prototype.toString.call(value) === '[object Date]'
+  ) {
+    try {
+      const copy = new Date(Date.prototype.getTime.call(value));
+      seen.set(value, copy);
+      return copy;
+    } catch {
+      // A string tag alone does not make a plain object a Date.
+    }
   }
 
-  if (value != null && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, value]) => [key, cloneValue(value)]),
-    ) as T;
+  const copy: Record<string, unknown> = {};
+  seen.set(value, copy);
+  for (const [key, val] of Object.entries(value)) {
+    Object.defineProperty(copy, key, {
+      value: cloneValue(val, seen),
+      writable: true,
+      enumerable: true,
+      configurable: true,
+    });
   }
-
-  return value;
+  return copy;
 }

package/src/prompt/content-part.ts

@@ -1,5 +1,7 @@
 import {
   isBuffer,
+  isUint8Array,
+  isArrayBuffer,
   type CustomPart,
   type DataContent,
   type FilePart,
@@ -19,8 +21,8 @@ import { z, type ZodType } from '../util/zod';
 
 const fileInlineDataSchema: ZodType<DataContent> = z.union([
   z.string(),
-  z.instanceof(Uint8Array),
-  z.instanceof(ArrayBuffer),
+  z.custom<Uint8Array>(isUint8Array, { message: 'Must be a Uint8Array' }),
+  z.custom<ArrayBuffer>(isArrayBuffer, { message: 'Must be an ArrayBuffer' }),
   z.custom<Buffer>(isBuffer, { message: 'Must be a Buffer' }),
 ]);
 

package/src/prompt/data-content.ts

@@ -1,4 +1,6 @@
 import {
+  isUint8Array,
+  isArrayBuffer,
   convertBase64ToUint8Array,
   convertUint8ArrayToBase64,
   type DataContent,
@@ -16,11 +18,7 @@ export function convertDataContentToBase64String(content: DataContent): string {
     return content;
   }
 
-  if (content instanceof ArrayBuffer) {
-    return convertUint8ArrayToBase64(new Uint8Array(content));
-  }
-
-  return convertUint8ArrayToBase64(content);
+  return convertUint8ArrayToBase64(convertDataContentToUint8Array(content));
 }
 
 /**
@@ -32,8 +30,12 @@ export function convertDataContentToBase64String(content: DataContent): string {
 export function convertDataContentToUint8Array(
   content: DataContent,
 ): Uint8Array {
-  if (content instanceof Uint8Array) {
-    return content;
+  if (isUint8Array(content)) {
+    if (content instanceof Uint8Array) {
+      return content;
+    }
+    const { buffer, byteOffset, byteLength } = content;
+    return new Uint8Array(buffer, byteOffset, byteLength);
   }
 
   if (typeof content === 'string') {
@@ -49,7 +51,7 @@ export function convertDataContentToUint8Array(
     }
   }
 
-  if (content instanceof ArrayBuffer) {
+  if (isArrayBuffer(content)) {
     return new Uint8Array(content);
   }
 

package/src/prompt/file-part-data.ts

@@ -1,5 +1,8 @@
+import { convertDataContentToUint8Array } from './data-content';
 import type { LanguageModelV4FilePart } from '@ai-sdk/provider';
 import {
+  isUint8Array,
+  isArrayBuffer,
   isBuffer,
   isProviderReference,
   type DataContent,
@@ -58,12 +61,9 @@ function convertUrlStringToFilePartData(content: string): ConvertResult {
 }
 
 function convertInlineDataToFilePartData(content: DataContent): ConvertResult {
-  if (content instanceof Uint8Array) {
-    return { data: { type: 'data', data: content }, mediaType: undefined };
-  }
-  if (content instanceof ArrayBuffer) {
+  if (isUint8Array(content) || isArrayBuffer(content)) {
     return {
-      data: { type: 'data', data: new Uint8Array(content) },
+      data: { type: 'data', data: convertDataContentToUint8Array(content) },
       mediaType: undefined,
     };
   }
@@ -130,6 +130,10 @@ export function convertToLanguageModelV4FilePart(
     }
   }
 
+  if (isUint8Array(content) || isArrayBuffer(content)) {
+    return convertInlineDataToFilePartData(content);
+  }
+
   if (isProviderReference(content)) {
     return {
       data: { type: 'reference', reference: content as ProviderReference },

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),