ai 7.0.159 → 7.0.161

package/docs/03-agents/04-loop-control.mdx

@@ -12,7 +12,7 @@ You can control both the execution flow and the settings at each step of the age
 - A tool call needs approval, or
 - A stop condition is met
 
-A [steering message](#steering) that is waiting when the model finishes its answer keeps the loop going for another step.
+A [steering message](#steering) that is waiting when the model finishes its answer keeps the loop going for another step. So does a [queued message](#queueing-messages), unless the answer was cut off.
 
 The AI SDK provides built-in loop control through two parameters: `stopWhen` for defining stopping conditions and `prepareStep` for modifying settings (model, tools, messages, and more) between steps.
 
@@ -477,6 +477,34 @@ prepareStep: ({ initialMessages, steps, experimental_steeringMessages }) => ({
 }),
 ```
 
+### Queueing Messages
+
+`steer()` changes what the agent is doing right now. Use `queue()` for a follow-up that should wait until the agent has finished its current task:
+
+```ts
+const steering = experimental_createSteering();
+
+const resultPromise = agent.generate({
+  prompt: 'Refactor the auth module.',
+  experimental_steering: steering,
+});
+
+// while the agent is working:
+steering.queue('Then add tests for it.');
+steering.queue('Then update the readme.');
+
+const result = await resultPromise;
+```
+
+A queued message is added once the model finishes its current task, i.e. when it gives a final answer without tool calls. The loop then continues with the message, so the agent works through the queue one task at a time:
+
+- Queued messages are added one per task, in the order they are queued.
+- Waiting steering messages are added first. A queued message waits for the next task that finishes.
+- Messages that are queued before the loop starts wait until the model has answered the prompt.
+- A response that is cut off (finish reason `length` or `content-filter`) does not finish the task, so the loop ends and the queued message is reported as not delivered.
+- Stop conditions still apply, and a queued message that the loop does not reach is reported as not delivered, so you can send it as a new message instead.
+- Queued messages are saved in `experimental_steeringMessages` like steering messages, and `queue()` resolves with the same outcome as `steer()`.
+
 ### Handling the Outcome
 
 `steer()` resolves with the outcome of the message and never rejects:

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

@@ -16,7 +16,7 @@ to see providers that offer monitoring and tracing for AI SDK applications.
 
 ### Step 1: Register the OpenTelemetry integration
 
-OpenTelemetry span collection requires the `@ai-sdk/otel` package. Install it and register the integration once at application startup:
+OpenTelemetry collection requires the `@ai-sdk/otel` package. Install it and register the integration once at application startup:
 
 ```bash
 pnpm install @ai-sdk/otel
@@ -513,6 +513,37 @@ The `LegacyOpenTelemetry` integration emits legacy AI SDK-specific spans.
 The `OpenTelemetry` emits spans that follow the [OpenTelemetry Semantic Conventions for GenAI](https://opentelemetry.io/docs/specs/semconv/gen-ai/).
 By default, attributes use the `gen_ai.*` prefix. Provider names are mapped to well-known values (e.g. `openai`, `anthropic`, `gcp.vertex_ai`).
 
+#### Inference duration metric
+
+For `generateText` and `streamText`, `OpenTelemetry` also records the
+[`gen_ai.client.inference.duration`](https://github.com/open-telemetry/semantic-conventions-genai/blob/3fe84604a581b3d50dd5b4bd29383b462d2a5018/docs/gen-ai/client-inference.md#metric-gen_aiclientinferenceduration)
+histogram in seconds, following the development GenAI semantic conventions.
+Configure a global OpenTelemetry `MeterProvider` with a metric reader and exporter
+to collect it. A `TracerProvider` alone does not export metrics.
+
+Each language model call contributes one observation, including calls that fail or
+are cancelled. Streaming calls record the full response duration. In a workflow
+with multiple model calls, each call is recorded separately; local tool execution
+time is excluded. Each attempt of a retried model stream contributes its own
+observation, including failed attempts that close without a finish chunk.
+
+The histogram includes these attributes:
+
+- `gen_ai.operation.name`: `"chat"`
+- `gen_ai.provider.name`: the normalized provider name
+- `gen_ai.request.model`: the requested model ID
+- `gen_ai.response.model`: the response model ID, when available
+- `error.type`: the error name for thrown errors, `"AbortError"` for cancellation,
+  or `"_OTHER"` when a call ends with an error finish reason or an unknown error
+
+The default bucket boundary advice is `[0.01, 0.02, 0.04, 0.08, 0.16, 0.32, 0.64,
+1.28, 2.56, 5.12, 10.24, 20.48, 40.96, 81.92]` seconds. Your OpenTelemetry SDK
+configuration can override aggregation and bucket boundaries.
+
+Setting `telemetry.isEnabled` to `false` disables these metrics for a call.
+Setting `recordInputs` or `recordOutputs` to `false` does not disable duration
+metrics. The `LegacyOpenTelemetry` integration does not emit this histogram.
+
 #### generateText / streamText
 
 For `generateText` and `streamText`, the integration records 3 types of spans:

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/docs/07-reference/01-ai-sdk-core/01-generate-text.mdx

@@ -857,7 +857,7 @@ To see `generateText` in action, check out [these examples](#examples).
       type: 'Experimental_Steering',
       isOptional: true,
       description:
-        "Experimental steering object created with `experimental_createSteering()`. Messages sent with `steering.steer()` are added as user messages at the next step boundary, after the current step and its tool calls are done. A waiting message keeps the loop going for another step unless a stop condition is met. `steer()` resolves with `{ type: 'delivered', id, message, stepNumber }` or `{ type: 'not-delivered', id, message, reason }`. See [Steering](/docs/agents/loop-control#steering).",
+        "Experimental steering object created with `experimental_createSteering()`. Messages sent with `steering.steer()` are added as user messages at the next step boundary, after the current step and its tool calls are done. Messages sent with `steering.queue()` wait until the model finishes its current task and are added one per task. A waiting message keeps the loop going for another step unless a stop condition is met. `steer()` and `queue()` resolve with `{ type: 'delivered', id, message, stepNumber }` or `{ type: 'not-delivered', id, message, reason }`. See [Steering](/docs/agents/loop-control#steering).",
     },
     {
       name: 'experimental_download',

package/docs/07-reference/01-ai-sdk-core/02-stream-text.mdx

@@ -914,7 +914,7 @@ retain the content their contracts require.
       type: 'Experimental_Steering',
       isOptional: true,
       description:
-        "Experimental steering object created with `experimental_createSteering()`. Messages sent with `steering.steer()` are added as user messages at the next step boundary, after the current step and its tool calls are done. A waiting message keeps the loop going for another step unless a stop condition is met. `steer()` resolves with `{ type: 'delivered', id, message, stepNumber }` or `{ type: 'not-delivered', id, message, reason }`. See [Steering](/docs/agents/loop-control#steering).",
+        "Experimental steering object created with `experimental_createSteering()`. Messages sent with `steering.steer()` are added as user messages at the next step boundary, after the current step and its tool calls are done. Messages sent with `steering.queue()` wait until the model finishes its current task and are added one per task. A waiting message keeps the loop going for another step unless a stop condition is met. `steer()` and `queue()` resolve with `{ type: 'delivered', id, message, stepNumber }` or `{ type: 'not-delivered', id, message, reason }`. See [Steering](/docs/agents/loop-control#steering).",
     },
     {
       name: 'experimental_download',

package/docs/07-reference/01-ai-sdk-core/16-tool-loop-agent.mdx

@@ -768,7 +768,7 @@ const result = await agent.generate({
       type: 'Experimental_Steering',
       isOptional: true,
       description:
-        "Experimental steering object created with `experimental_createSteering()`. Messages sent with `steering.steer()` are added as user messages at the next step boundary, after the current step and its tool calls are done. A waiting message keeps the loop going for another step unless a stop condition is met. `steer()` resolves with `{ type: 'delivered', id, message, stepNumber }` or `{ type: 'not-delivered', id, message, reason }`. See [Steering](/docs/agents/loop-control#steering).",
+        "Experimental steering object created with `experimental_createSteering()`. Messages sent with `steering.steer()` are added as user messages at the next step boundary, after the current step and its tool calls are done. Messages sent with `steering.queue()` wait until the model finishes its current task and are added one per task. A waiting message keeps the loop going for another step unless a stop condition is met. `steer()` and `queue()` resolve with `{ type: 'delivered', id, message, stepNumber }` or `{ type: 'not-delivered', id, message, reason }`. See [Steering](/docs/agents/loop-control#steering).",
     },
     {
       name: 'options',
@@ -891,7 +891,7 @@ for await (const chunk of stream.textStream) {
       type: 'Experimental_Steering',
       isOptional: true,
       description:
-        "Experimental steering object created with `experimental_createSteering()`. Messages sent with `steering.steer()` are added as user messages at the next step boundary, after the current step and its tool calls are done. A waiting message keeps the loop going for another step unless a stop condition is met. `steer()` resolves with `{ type: 'delivered', id, message, stepNumber }` or `{ type: 'not-delivered', id, message, reason }`. See [Steering](/docs/agents/loop-control#steering).",
+        "Experimental steering object created with `experimental_createSteering()`. Messages sent with `steering.steer()` are added as user messages at the next step boundary, after the current step and its tool calls are done. Messages sent with `steering.queue()` wait until the model finishes its current task and are added one per task. A waiting message keeps the loop going for another step unless a stop condition is met. `steer()` and `queue()` resolve with `{ type: 'delivered', id, message, stepNumber }` or `{ type: 'not-delivered', id, message, reason }`. See [Steering](/docs/agents/loop-control#steering).",
     },
     {
       name: 'options',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.159",
+  "version": "7.0.161",
   "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.132",
+    "@ai-sdk/gateway": "4.0.134",
     "@ai-sdk/provider": "4.0.35",
-    "@ai-sdk/provider-utils": "5.0.72"
+    "@ai-sdk/provider-utils": "5.0.73"
   },
   "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.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/test-server": "2.0.4",
-    "@ai-sdk/xai": "5.0.35",
+    "@ai-sdk/xai": "5.0.37",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/generate-text/generate-text.ts

@@ -981,7 +981,15 @@ async function generateTextInternal<
           clientToolCalls.length === 0 &&
           pendingDeferredToolCalls.size === 0
         ) {
-          if (!steeringRun?.hasPendingMessages()) {
+          // queued messages wait for a task that was not cut off:
+          const isTruncated =
+            steps[steps.length - 1].finishReason === 'length' ||
+            steps[steps.length - 1].finishReason === 'content-filter';
+
+          if (
+            !steeringRun?.hasPendingMessages() &&
+            (isTruncated || !steeringRun?.promoteQueuedMessage())
+          ) {
             return false;
           }
 

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/smooth-stream.ts

@@ -79,7 +79,7 @@ export function smoothStream<TOOLS extends ToolSet>({
 
       if (!buffer.startsWith(match)) {
         throw new Error(
-          `Chunking function must return a match that is a prefix of the buffer. Received: "${match}" expected to start with "${buffer}"`,
+          `Chunking function must return a match that is a prefix of the buffer. Received: "${match}" which is not a prefix of buffer "${buffer}"`,
         );
       }
 

package/src/generate-text/steering.ts

@@ -81,6 +81,24 @@ export interface Steering {
     message: string | UserModelMessage,
     options?: { id?: string },
   ): Promise<SteeringOutcome>;
+
+  /**
+   * Adds a user message to the run once the model has finished its current
+   * task, i.e. when it gives a final answer without tool calls. The run then
+   * continues with the message unless a stop condition is met. Queued
+   * messages are delivered one per task, in order, after any waiting steering
+   * messages.
+   *
+   * @param message - The user message, or its text.
+   * @param options.id - The id of the message. Sending a message again with
+   * the same id returns the outcome of the first message.
+   *
+   * @returns The outcome of the message. It never rejects.
+   */
+  queue(
+    message: string | UserModelMessage,
+    options?: { id?: string },
+  ): Promise<SteeringOutcome>;
 }
 
 /**
@@ -89,6 +107,12 @@ export interface Steering {
 export type SteeringRun = {
   hasPendingMessages(): boolean;
 
+  /**
+   * Moves the oldest queued message to the waiting messages for the next
+   * step. Returns `false` when no message is queued.
+   */
+  promoteQueuedMessage(): boolean;
+
   /**
    * Takes the waiting messages for the next step. They are resolved by
    * `resolveTakenMessages` once the prompt of the step is known.
@@ -116,6 +140,7 @@ type PendingSteer = {
 class DefaultSteering implements Steering {
   private state: 'idle' | 'running' | 'ended' = 'idle';
   private pending: Array<PendingSteer> = [];
+  private queued: Array<PendingSteer> = [];
   private taken: Array<PendingSteer> = [];
   private outcomes = new Map<string, Promise<SteeringOutcome>>();
 
@@ -123,8 +148,25 @@ class DefaultSteering implements Steering {
     message: string | UserModelMessage,
     options?: { id?: string },
   ): Promise<SteeringOutcome> {
-    const id = options?.id ?? generateSteeringId();
+    return this.add({ message, id: options?.id, target: this.pending });
+  }
+
+  queue(
+    message: string | UserModelMessage,
+    options?: { id?: string },
+  ): Promise<SteeringOutcome> {
+    return this.add({ message, id: options?.id, target: this.queued });
+  }
 
+  private add({
+    message,
+    id = generateSteeringId(),
+    target,
+  }: {
+    message: string | UserModelMessage;
+    id?: string;
+    target: Array<PendingSteer>;
+  }): Promise<SteeringOutcome> {
     const existingOutcome = this.outcomes.get(id);
     if (existingOutcome != null) {
       return existingOutcome;
@@ -144,7 +186,7 @@ class DefaultSteering implements Steering {
             reason: 'finished',
           })
         : new Promise<SteeringOutcome>(resolve => {
-            this.pending.push({ id, message: userMessage, resolve });
+            target.push({ id, message: userMessage, resolve });
           });
 
     this.outcomes.set(id, outcome);
@@ -168,6 +210,16 @@ class DefaultSteering implements Steering {
       hasPendingMessages: () =>
         this.state === 'running' && this.pending.length > 0,
 
+      promoteQueuedMessage: () => {
+        const next = this.state === 'running' ? this.queued.shift() : undefined;
+        if (next == null) {
+          return false;
+        }
+
+        this.pending.push(next);
+        return true;
+      },
+
       takeMessages: () => {
         if (this.state !== 'running') {
           return [];
@@ -207,9 +259,10 @@ class DefaultSteering implements Steering {
           return;
         }
 
-        const notDelivered = [...this.taken, ...this.pending];
+        const notDelivered = [...this.taken, ...this.pending, ...this.queued];
         this.taken = [];
         this.pending = [];
+        this.queued = [];
         this.state = 'ended';
 
         for (const { id, message, resolve } of notDelivered) {

package/src/generate-text/stream-text.ts

@@ -3389,7 +3389,15 @@ class DefaultStreamTextResult<
                       clientToolCalls.length === 0 &&
                       pendingDeferredToolCalls.size === 0
                     ) {
-                      if (!steeringRun?.hasPendingMessages()) {
+                      // queued messages wait for a task that was not cut off:
+                      const isTruncated =
+                        stepFinishReason === 'length' ||
+                        stepFinishReason === 'content-filter';
+
+                      if (
+                        !steeringRun?.hasPendingMessages() &&
+                        (isTruncated || !steeringRun?.promoteQueuedMessage())
+                      ) {
                         return false;
                       }
 

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/ui/process-ui-message-stream.ts

@@ -1056,7 +1056,9 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
             default: {
               if (isDataUIMessageChunk(chunk)) {
                 // validate data chunk if dataPartSchemas is provided
-                if (dataPartSchemas?.[chunk.type] != null) {
+                // (schemas are keyed by the part name without the 'data-' prefix)
+                const dataPartSchema = dataPartSchemas?.[chunk.type.slice(5)];
+                if (dataPartSchema != null) {
                   const partIdx = state.message.parts.findIndex(
                     p =>
                       'id' in p &&
@@ -1069,7 +1071,7 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
 
                   await validateTypes({
                     value: chunk.data,
-                    schema: dataPartSchemas[chunk.type],
+                    schema: dataPartSchema,
                     context: {
                       field: `message.parts[${actualPartIdx}].data`,
                       entityName: chunk.type,