ai 7.0.160 → 7.0.161

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.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.133",
+    "@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.36",
+    "@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/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/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 },