ai 7.0.94 → 7.0.96

package/dist/internal/index.js

@@ -91,7 +91,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.94" : "0.0.0-test";
+var VERSION = true ? "7.0.96" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/docs/03-ai-sdk-core/35-image-generation.mdx

@@ -314,6 +314,8 @@ for (const file of result.files) {
 | Provider                                                                        | Model                                                        | Support sizes (`width x height`) or aspect ratios (`width : height`)                                                                                                |
 | ------------------------------------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | [xAI Grok](/providers/ai-sdk-providers/xai#image-models)                        | `grok-imagine-image`                                         | `1:1`, `16:9`, `9:16`, `4:3`, `3:4`, `3:2`, `2:3`, `2:1`, `1:2`, `19.5:9`, `9:19.5`, `20:9`, `9:20`, `auto`                                                         |
+| [OpenAI](/providers/ai-sdk-providers/openai#image-models)                       | `gpt-image-2.5-flare`                                        | 1024x1024, 1536x1024, 1024x1536, custom                                                                                                                             |
+| [OpenAI](/providers/ai-sdk-providers/openai#image-models)                       | `gpt-image-2.5-sunburst`                                     | 1024x1024, 1536x1024, 1024x1536, custom                                                                                                                             |
 | [OpenAI](/providers/ai-sdk-providers/openai#image-models)                       | `gpt-image-2`                                                | 1024x1024, 1536x1024, 1024x1536                                                                                                                                     |
 | [OpenAI](/providers/ai-sdk-providers/openai#image-models)                       | `dall-e-3`                                                   | 1024x1024, 1792x1024, 1024x1792                                                                                                                                     |
 | [OpenAI](/providers/ai-sdk-providers/openai#image-models)                       | `dall-e-2`                                                   | 256x256, 512x512, 1024x1024                                                                                                                                         |

package/docs/03-ai-sdk-core/42-batch.mdx

@@ -0,0 +1,333 @@
+---
+title: Batch
+description: Learn how to process asynchronous batches with the AI SDK.
+---
+
+# Batch
+
+<Note type="warning">
+  Batch support is experimental and the API may change in patch releases.
+</Note>
+
+Batches let you submit multiple independent requests for asynchronous
+processing. The provider processes the batch in the background, so your
+application does not need to keep the request open while the model generates
+the results. This is useful for workloads such as classification,
+summarization, and content generation that do not need an immediate response.
+
+The batch API is designed to support multiple request types. Currently, only
+`type: 'text'` is supported.
+
+The AI SDK provides five functions for the batch lifecycle:
+
+- [`experimental_startBatch`](/docs/reference/ai-sdk-core/start-batch)
+  submits a batch and returns its initial status and a serializable reference.
+- [`experimental_getBatchStatus`](/docs/reference/ai-sdk-core/get-batch-status)
+  retrieves the latest status and request counts.
+- [`experimental_getBatchResults`](/docs/reference/ai-sdk-core/get-batch-results)
+  asynchronously iterates over the terminal result for each request.
+- [`experimental_cancelBatch`](/docs/reference/ai-sdk-core/cancel-batch)
+  requests cancellation of a batch.
+- [`experimental_listBatches`](/docs/reference/ai-sdk-core/list-batches)
+  lists batches and their latest statuses.
+
+All five functions are exported from `ai`. The examples below use aliases so
+the shorter names can be used in application code:
+
+```ts
+import {
+  experimental_cancelBatch as cancelBatch,
+  experimental_getBatchResults as getBatchResults,
+  experimental_getBatchStatus as getBatchStatus,
+  experimental_listBatches as listBatches,
+  experimental_startBatch as startBatch,
+} from 'ai';
+```
+
+Cancellation and listing are optional provider capabilities. Calling either
+function with a provider that does not implement it throws an
+`UnsupportedFunctionalityError`. In the cancellation and listing examples
+below, `provider` represents a batch provider that implements the respective
+capability.
+
+## Supported providers
+
+Batch processing requires a provider that implements the batch interface.
+Support is provider- and model-specific. The first-party providers with
+support are:
+
+| Provider                                             | Provider value | Model example                  | Provider API                                                                                  |
+| ---------------------------------------------------- | -------------- | ------------------------------ | --------------------------------------------------------------------------------------------- |
+| [Anthropic](/providers/ai-sdk-providers/anthropic)   | `anthropic`    | `'claude-haiku-4-5'`           | [Message Batches API](https://platform.claude.com/docs/en/build-with-claude/batch-processing) |
+| [Google](/providers/ai-sdk-providers/google)         | `google`       | `'gemini-3.6-flash'`           | [Gemini Batch API](https://ai.google.dev/gemini-api/docs/batch-api)                           |
+| [OpenAI](/providers/ai-sdk-providers/openai)         | `openai`       | `'gpt-4.1-nano'`               | [Batch API](https://developers.openai.com/api/docs/guides/batch)                              |
+| [xAI](/providers/ai-sdk-providers/xai)               | `xai`          | `'grok-4.3'`                   | [Batch API](https://docs.x.ai/developers/advanced-api-usage/batch-api)                        |
+| [AI Gateway](/providers/ai-sdk-providers/ai-gateway) | global default | `'anthropic/claude-haiku-4.5'` | [Batch processing](https://vercel.com/docs/ai-gateway/models-and-providers/batch-processing)  |
+
+See the provider documentation for the supported models, limits, and native
+batch behavior. For example, OpenAI batch support is available through the
+Responses API, not `openai.chat()`, and xAI batch support is available through
+the Responses API, not `xai.chat()`.
+
+## Starting a batch
+
+Pass a provider and one or more uniquely identified requests to `startBatch`.
+Each request must specify `type: 'text'`, a model ID, and either a text `prompt`
+or a `messages` array. Requests can use different model IDs when supported by
+the provider. Each request can also use the usual text-generation settings such
+as `instructions`, `maxOutputTokens`, `temperature`, `topP`, `topK`,
+`presencePenalty`, `frequencyPenalty`, `stopSequences`, `seed`, and `reasoning`.
+
+Tool definitions and tool settings are provided on individual requests. A tool
+with the same name must have the same definition in every request that uses it.
+
+```ts
+import { anthropic } from '@ai-sdk/anthropic';
+import { experimental_startBatch as startBatch } from 'ai';
+
+const provider = anthropic;
+
+const batch = await startBatch({
+  provider,
+  requests: [
+    {
+      id: 'capital-france',
+      type: 'text',
+      model: 'claude-haiku-4-5',
+      prompt: 'What is the capital of France?',
+    },
+    {
+      id: 'capital-germany',
+      type: 'text',
+      model: 'claude-haiku-4-5',
+      prompt: 'What is the capital of Germany?',
+    },
+  ],
+});
+
+console.log(batch.id, batch.status);
+```
+
+Request IDs must be non-empty and unique within the batch. They are the link
+between an input request and its result. Results are not guaranteed to arrive
+in input order, so use the ID rather than an array position when associating a
+result with application data.
+
+You can pass provider-specific settings at the batch level with
+`providerOptions`, or on an individual request with that request's
+`providerOptions`. Settings supported by the provider can differ between the
+two levels. The `warnings` property on the start result contains warnings about
+unsupported settings.
+
+The batch reference returned by `startBatch` is serializable. Persist it
+before the process exits if the batch will be completed by another process or
+at a later time. When retrieving a batch, pass the same provider. The AI SDK
+uses the reference to ensure that a batch is not read through an incompatible
+provider.
+
+## Batch tools
+
+Batch text requests support both client-defined tools and provider-defined
+tools. Tool definitions are sent with each request that includes them, so the
+model can call them independently for each request.
+
+Client-defined tools are definition-only in a batch. Their `execute` functions
+are never invoked, and the AI SDK does not submit tool results or start a
+follow-up generation after retrieving a tool call. Pass the same tool set to
+`getBatchResults` to validate and normalize returned tool calls:
+
+```ts
+import { anthropic } from '@ai-sdk/anthropic';
+import {
+  experimental_getBatchResults as getBatchResults,
+  experimental_startBatch as startBatch,
+  tool,
+} from 'ai';
+import { z } from 'zod';
+
+const tools = {
+  get_weather: tool({
+    description: 'Get the current weather for a location.',
+    inputSchema: z.object({ location: z.string() }),
+    execute: async ({ location }) => {
+      // This function is not called by batch processing.
+      return { location, temperature: 21, condition: 'sunny' };
+    },
+  }),
+};
+
+const batch = await startBatch({
+  provider: anthropic,
+  requests: [
+    {
+      id: 'weather-san-francisco',
+      type: 'text',
+      model: 'claude-haiku-4-5',
+      prompt: 'Call get_weather for San Francisco, California.',
+      tools,
+      toolChoice: { type: 'tool', toolName: 'get_weather' },
+    },
+  ],
+});
+
+for await (const item of getBatchResults({
+  provider: anthropic,
+  batch,
+  tools,
+})) {
+  if (item.status === 'succeeded') {
+    console.log(item.id, item.content);
+  }
+}
+```
+
+Provider-defined tools, such as web search or code execution, can execute on
+the provider when supported by that provider's batch API. Their tool calls and
+results are returned as normalized `content` parts. See the provider
+documentation for the tools and models available in batches.
+
+## Checking batch status
+
+The start result includes the initial status. Use `getBatchStatus` to retrieve
+the latest status while the provider is processing the batch:
+
+```ts
+import { setTimeout } from 'node:timers/promises';
+
+let status = batch.status;
+let error = batch.error;
+
+while (status === 'pending') {
+  await setTimeout(10_000);
+  const latestStatus = await getBatchStatus({
+    provider: anthropic,
+    batch,
+  });
+  status = latestStatus.status;
+  error = latestStatus.error;
+}
+
+if (status === 'failed') {
+  throw new Error(error?.message ?? 'The batch failed.');
+}
+```
+
+The normalized batch status is one of:
+
+- `pending` — the provider is still processing the batch.
+- `completed` — the batch reached a terminal state and results can be
+  retrieved.
+- `failed` — the batch could not be completed. The `error` property may
+  contain additional details.
+
+Status responses can also include `requestCounts`, `createdAt`, `expiresAt`,
+`rawStatus`, and provider metadata. `requestCounts` reports the total,
+pending, completed, and failed requests known by the provider.
+
+For webhook-capable providers, pass `webhookUrl` to `startBatch` to
+receive a notification when the batch reaches a terminal state. Webhook
+support and payloads are provider-specific. The provider pages linked above
+describe their webhook behavior; providers that do not support webhooks return
+an unsupported warning and continue without one.
+
+## Cancelling a batch
+
+Use `cancelBatch` to ask the provider to stop processing a batch:
+
+```ts
+const result = await cancelBatch({
+  provider,
+  batch,
+});
+
+console.log(result.providerMetadata);
+```
+
+A successful call means that the provider accepted the cancellation request.
+It does not guarantee that cancellation has finished or that every pending
+request will be cancelled. Use `getBatchStatus` to retrieve the latest status
+after requesting cancellation.
+
+The result can include provider metadata with additional information from the
+cancellation response.
+
+## Listing batches
+
+Use `listBatches` to retrieve batches from the provider. Results are paginated.
+Pass the returned `nextCursor` as `cursor` to retrieve the next page:
+
+```ts
+let cursor: string | undefined;
+
+do {
+  const page = await listBatches({
+    provider,
+    limit: 20,
+    cursor,
+  });
+
+  for (const batch of page.batches) {
+    console.log(batch.id, batch.status);
+  }
+
+  cursor = page.nextCursor;
+} while (cursor != null);
+```
+
+Each item is a serializable batch reference with its latest normalized status,
+so it can be passed directly to `getBatchStatus`, `getBatchResults`, or
+`cancelBatch`. Cursors are opaque and provider-specific; applications should
+store or pass them unchanged rather than inspect their contents.
+
+## Retrieving results
+
+After the batch is complete, `getBatchResults` returns an async iterable. Each
+item contains the ID and terminal status for one input request:
+
+```ts
+for await (const item of getBatchResults({ provider: anthropic, batch })) {
+  if (item.status === 'succeeded') {
+    console.log(item.id, item.text);
+  } else {
+    console.error(item.id, item.status, item.error);
+  }
+}
+```
+
+Successful items include:
+
+- `text` — the concatenated text content. This can be an empty string when the
+  result contains no text parts.
+- `content` — ordered, normalized content parts, including text, reasoning,
+  files, sources, tool calls, tool results, and provider content where
+  supported.
+- `finishReason` and optional `rawFinishReason`.
+- `usage` and optional `response` metadata.
+- Optional `providerMetadata`.
+
+Failed, cancelled, and expired items include their `id` and status. Failed
+items include an `error`; cancelled and expired items may also include one.
+One failed request does not necessarily mean that every request in the batch
+failed, so handle each item independently.
+
+Batch retrieval does not run an AI SDK tool loop or invoke client-defined
+`execute` functions. Provider-defined tools may execute on the provider as part
+of batch processing. Treat result content and provider metadata as untrusted
+model output, and avoid logging it indiscriminately because it can contain
+sensitive data.
+
+## Request controls
+
+All batch lifecycle functions accept `providerOptions`, `headers`, `timeout`,
+and `abortSignal` for the current operation. `getBatchStatus`,
+`getBatchResults`, and `listBatches` also accept `maxRetries`:
+
+- `maxRetries` controls retries for status, result retrieval, and listing. It
+  does not retry batch creation or cancellation. It defaults to 2; set it to 0
+  to disable retries.
+- `abortSignal` cancels the current API request.
+- `timeout` limits the current HTTP operation.
+
+These controls affect communication with the provider. They do not change the
+provider's processing deadline or cancel a batch that has already been
+submitted.

package/docs/03-ai-sdk-core/index.mdx

@@ -98,6 +98,11 @@ description: Learn about AI SDK Core.
       description: 'Learn how to generate speech with AI SDK Core.',
       href: '/docs/ai-sdk-core/speech',
     },
+    {
+      title: 'Batch',
+      description: 'Submit requests for asynchronous batch processing.',
+      href: '/docs/ai-sdk-core/batch',
+    },
     {
       title: 'File Uploads',
       description: 'Learn how to upload files to providers with the AI SDK.',

package/docs/03-ai-sdk-harnesses/05-harness-adapters.mdx

@@ -20,6 +20,7 @@ The AI SDK includes the following harness adapters:
 - [Cursor](/providers/ai-sdk-harnesses/cursor) (`@ai-sdk/harness-cursor`)
 - [Deep Agents](/providers/ai-sdk-harnesses/deepagents) (`@ai-sdk/harness-deepagents`)
 - [fx](/providers/ai-sdk-harnesses/fx) (`@ai-sdk/harness-fx`)
+- [GitHub Copilot](/providers/ai-sdk-harnesses/github-copilot) (`@ai-sdk/harness-github-copilot`)
 - [Grok Build](/providers/ai-sdk-harnesses/grok-build) (`@ai-sdk/harness-grok-build`)
 - [OpenCode](/providers/ai-sdk-harnesses/opencode) (`@ai-sdk/harness-opencode`)
 - [Pi](/providers/ai-sdk-harnesses/pi) (`@ai-sdk/harness-pi`)
@@ -32,14 +33,15 @@ The AI SDK includes the following harness adapters:
 
 ## Adapter Capabilities
 
-| Adapter                                                | Runtime location | Custom tools | Custom skills | Structured output | Built-in tool approval | Built-in tool filtering      |
-| ------------------------------------------------------ | ---------------- | ------------ | ------------- | ----------------- | ---------------------- | ---------------------------- |
-| [Claude Code](/providers/ai-sdk-harnesses/claude-code) | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Check />              | <Check />                    |
-| [Cline](/providers/ai-sdk-harnesses/cline)             | Host process     | <Check />    | <Check />     | <Check />         | <Check />              | <Check />                    |
-| [Codex](/providers/ai-sdk-harnesses/codex)             | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Cross />              | <Cross />                    |
-| [Cursor](/providers/ai-sdk-harnesses/cursor)           | Sandbox via ACP  | <Check />    | <Check />     | <Cross />         | <Check />              | <Cross />                    |
-| [Deep Agents](/providers/ai-sdk-harnesses/deepagents)  | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Check />              | <Check /> via auto-rejection |
-| [fx](/providers/ai-sdk-harnesses/fx)                   | Sandbox via ACP  | <Check />    | <Check />     | <Cross />         | <Check />              | <Cross />                    |
-| [Grok Build](/providers/ai-sdk-harnesses/grok-build)   | Sandbox via ACP  | <Check />    | <Check />     | <Check />         | <Check />              | <Cross />                    |
-| [OpenCode](/providers/ai-sdk-harnesses/opencode)       | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Check />              | <Check /> via auto-rejection |
-| [Pi](/providers/ai-sdk-harnesses/pi)                   | Host process     | <Check />    | <Check />     | <Cross />         | <Check />              | <Check />                    |
+| Adapter                                                      | Runtime location | Custom tools | Custom skills | Structured output | Built-in tool approval | Built-in tool filtering      |
+| ------------------------------------------------------------ | ---------------- | ------------ | ------------- | ----------------- | ---------------------- | ---------------------------- |
+| [Claude Code](/providers/ai-sdk-harnesses/claude-code)       | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Check />              | <Check />                    |
+| [Cline](/providers/ai-sdk-harnesses/cline)                   | Host process     | <Check />    | <Check />     | <Check />         | <Check />              | <Check />                    |
+| [Codex](/providers/ai-sdk-harnesses/codex)                   | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Cross />              | <Cross />                    |
+| [Cursor](/providers/ai-sdk-harnesses/cursor)                 | Sandbox via ACP  | <Check />    | <Check />     | <Cross />         | <Check />              | <Cross />                    |
+| [Deep Agents](/providers/ai-sdk-harnesses/deepagents)        | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Check />              | <Check /> via auto-rejection |
+| [fx](/providers/ai-sdk-harnesses/fx)                         | Sandbox via ACP  | <Check />    | <Check />     | <Cross />         | <Check />              | <Cross />                    |
+| [GitHub Copilot](/providers/ai-sdk-harnesses/github-copilot) | Sandbox via ACP  | <Check />    | <Check />     | <Cross />         | <Check />              | <Cross />                    |
+| [Grok Build](/providers/ai-sdk-harnesses/grok-build)         | Sandbox via ACP  | <Check />    | <Check />     | <Check />         | <Check />              | <Cross />                    |
+| [OpenCode](/providers/ai-sdk-harnesses/opencode)             | Sandbox bridge   | <Check />    | <Check />     | <Check />         | <Check />              | <Check /> via auto-rejection |
+| [Pi](/providers/ai-sdk-harnesses/pi)                         | Host process     | <Check />    | <Check />     | <Cross />         | <Check />              | <Check />                    |

package/docs/06-advanced/04-caching.mdx

@@ -110,6 +110,13 @@ export const cacheMiddleware: LanguageModelV4Middleware = {
   responses but you can use any KV storage provider you would like.
 </Note>
 
+<Note>
+  This middleware caches the raw model response before AI SDK validates
+  structured output. When using structured output, cache only a response that
+  has passed your schema validation; otherwise, an invalid response can be
+  replayed from the cache on later requests.
+</Note>
+
 `LanguageModelV4Middleware` has two methods: `wrapGenerate` and `wrapStream`. `wrapGenerate` is called when using [`generateText`](/docs/reference/ai-sdk-core/generate-text), while `wrapStream` is called when using [`streamText`](/docs/reference/ai-sdk-core/stream-text).
 
 For `wrapGenerate`, you can cache the response directly. Instead, for `wrapStream`, you cache an array of the stream parts, which can then be used with [`simulateReadableStream`](/docs/ai-sdk-core/testing#simulate-ui-message-stream-responses) function to create a simulated `ReadableStream` that returns the cached response. In this way, the cached response is returned chunk-by-chunk as if it were being generated by the model. You can control the initial delay and delay between chunks by adjusting the `initialDelayInMs` and `chunkDelayInMs` parameters of `simulateReadableStream`.

package/docs/07-reference/01-ai-sdk-core/20-start-batch.mdx

@@ -0,0 +1,155 @@
+---
+title: experimental_startBatch
+description: API Reference for experimental_startBatch.
+---
+
+# `experimental_startBatch()`
+
+<Note type="warning">
+  Batch support is experimental and the API may change in patch releases.
+</Note>
+
+Starts an asynchronous batch. Currently, only `type: 'text'` requests are
+supported. For a complete guide to the batch lifecycle, see
+[Batch](/docs/ai-sdk-core/batch).
+
+```ts
+import { experimental_startBatch as startBatch } from 'ai';
+
+const batch = await startBatch({
+  requests: [
+    {
+      id: 'france',
+      type: 'text',
+      model: 'gpt-4.1-nano',
+      prompt: 'What is the capital of France?',
+    },
+  ],
+});
+```
+
+## Import
+
+<Snippet text={`import { experimental_startBatch } from "ai"`} prompt={false} />
+
+## API Signature
+
+### Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: 'provider',
+      type: 'Experimental_BatchProvider',
+      isOptional: true,
+      description:
+        'The provider to use. Defaults to the global provider, or the AI Gateway when no global provider is configured.',
+    },
+    {
+      name: 'requests',
+      type: 'Array<Experimental_BatchRequest>',
+      description:
+        'The independent requests to process. Each request must have a unique, non-empty id, a supported type, and type-specific properties such as model and prompt or messages for text requests.',
+    },
+    {
+      name: 'providerOptions',
+      type: 'ProviderOptions',
+      isOptional: true,
+      description: 'Additional provider-specific options for the batch.',
+    },
+    {
+      name: 'webhookUrl',
+      type: 'string',
+      isOptional: true,
+      description:
+        'URL to notify when the batch reaches a terminal state. Support and payloads are provider-specific.',
+    },
+    {
+      name: 'abortSignal',
+      type: 'AbortSignal',
+      isOptional: true,
+      description:
+        'An optional abort signal to cancel the request that starts the batch.',
+    },
+    {
+      name: 'timeout',
+      type: 'number | { totalMs?: number }',
+      isOptional: true,
+      description: 'Maximum time allowed for the batch creation request.',
+    },
+    {
+      name: 'headers',
+      type: 'Record<string, string | undefined>',
+      isOptional: true,
+      description: 'Additional HTTP headers for the request.',
+    },
+  ]}
+/>
+
+### Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: 'version',
+      type: '2',
+      description: 'Version of the serializable batch reference.',
+    },
+    {
+      name: 'id',
+      type: 'string',
+      description: 'Provider batch identifier.',
+    },
+    {
+      name: 'provider',
+      type: 'string',
+      description: 'Provider identifier for the batch.',
+    },
+    {
+      name: 'status',
+      type: "'pending' | 'completed' | 'failed'",
+      description: 'Initial normalized batch status.',
+    },
+    {
+      name: 'rawStatus',
+      type: 'string',
+      isOptional: true,
+      description: 'The provider-specific batch status, when available.',
+    },
+    {
+      name: 'requestCounts',
+      type: '{ total: number; pending: number; completed: number; failed: number }',
+      isOptional: true,
+      description: 'Provider-reported request counts.',
+    },
+    {
+      name: 'error',
+      type: 'Experimental_BatchError',
+      isOptional: true,
+      description: 'Error details when the batch fails.',
+    },
+    {
+      name: 'createdAt',
+      type: 'string',
+      isOptional: true,
+      description: 'Creation timestamp, when provided by the provider.',
+    },
+    {
+      name: 'expiresAt',
+      type: 'string',
+      isOptional: true,
+      description: 'Expiration timestamp, when provided by the provider.',
+    },
+    {
+      name: 'providerMetadata',
+      type: 'ProviderMetadata',
+      isOptional: true,
+      description: 'Provider-specific metadata for the batch.',
+    },
+    {
+      name: 'warnings',
+      type: 'Warning[]',
+      description: 'Warnings returned while starting the batch.',
+    },
+  ]}
+/>