ai 7.0.97 → 7.0.98

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

@@ -15,8 +15,8 @@ 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 batch API supports text generation with `type: 'text'` and image generation
+with `type: 'image'`.
 
 The AI SDK provides five functions for the batch lifecycle:
 
@@ -56,13 +56,13 @@ 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)  |
+| Provider                                             | Provider value | Request types | Provider API                                                                                  |
+| ---------------------------------------------------- | -------------- | ------------- | --------------------------------------------------------------------------------------------- |
+| [Anthropic](/providers/ai-sdk-providers/anthropic)   | `anthropic`    | text          | [Message Batches API](https://platform.claude.com/docs/en/build-with-claude/batch-processing) |
+| [Google](/providers/ai-sdk-providers/google)         | `google`       | text, image   | [Gemini Batch API](https://ai.google.dev/gemini-api/docs/batch-api)                           |
+| [OpenAI](/providers/ai-sdk-providers/openai)         | `openai`       | text          | [Batch API](https://developers.openai.com/api/docs/guides/batch)                              |
+| [xAI](/providers/ai-sdk-providers/xai)               | `xai`          | text, image   | [Batch API](https://docs.x.ai/developers/advanced-api-usage/batch-api)                        |
+| [AI Gateway](/providers/ai-sdk-providers/ai-gateway) | global default | text          | [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
@@ -125,6 +125,45 @@ 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.
 
+### Image requests
+
+Image requests use the same prompt and generation settings as `generateImage`:
+`prompt`, `n`, `size`, `aspectRatio`, `seed`, and `providerOptions`. A prompt
+can also contain input images and a mask for providers that support image
+editing. Provider batch endpoints may support only a subset of these options;
+unsupported options produce warnings or errors.
+
+```ts
+import { google } from '@ai-sdk/google';
+import { experimental_startBatch as startBatch } from 'ai';
+
+const batch = await startBatch({
+  provider: google,
+  requests: [
+    {
+      id: 'red-panda',
+      type: 'image',
+      model: 'gemini-2.5-flash-image',
+      prompt: 'A red panda reading beside a cabin window',
+      aspectRatio: '16:9',
+    },
+  ],
+});
+```
+
+Successful image items have an `images` array of `GeneratedFile` values, plus
+image warnings, response metadata, usage, and provider metadata when the
+provider supplies them. Successful text items have `text` and `content`
+properties. Use the `type` property to narrow mixed results:
+
+```ts
+for await (const item of getBatchResults({ provider: google, batch })) {
+  if (item.type === 'image' && item.status === 'succeeded') {
+    console.log(item.images);
+  }
+}
+```
+
 ## Batch tools
 
 Batch text requests support both client-defined tools and provider-defined

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

@@ -126,7 +126,7 @@ const result = await generateText({
 });
 ```
 
-In this example, telemetry integrations receive `runtimeContext` as `{ requestId: 'req_abc' }`. Properties set to `false` or omitted are excluded. If `telemetry.includeRuntimeContext` is omitted, no runtime context properties are included. `telemetry.includeRuntimeContext` is supported by `generateText`, `streamText`, and `ToolLoopAgent`.
+In this example, telemetry integrations receive `runtimeContext` as `{ requestId: 'req_abc' }`. Properties set to `false` or omitted are excluded. If `telemetry.includeRuntimeContext` is omitted, no runtime context properties are included. `telemetry.includeRuntimeContext` is supported by `generateText`, `streamText`, `ToolLoopAgent`, `embed`, `embedMany`, and `rerank`.
 
 <Note>
   `telemetry.includeRuntimeContext` only filters telemetry integrations,
@@ -582,14 +582,37 @@ The callback runs when each span is created and receives:
 - `spanType`: the type of span being created (`operation`, `step`, `languageModel`, `tool`, `embedding`, or `reranking`).
 - `operationId`: the AI SDK operation ID for the current call, such as `ai.generateText` or `ai.streamText`.
 - `callId`: the unique ID for the current AI SDK call.
-- `runtimeContext`: the telemetry-filtered runtime context for text generation spans, including updates from `prepareStep`.
+- `runtimeContext`: the telemetry-filtered runtime context for text generation, embedding, and reranking spans. Text generation spans also reflect updates from `prepareStep`.
 
 Custom attributes are merged with AI SDK attributes on the span. AI SDK-owned
 attributes take precedence when a custom attribute uses the same key.
 
-`sensitiveRuntimeContext` is applied before telemetry integrations receive
-`runtimeContext`, so custom span enrichment does not receive top-level runtime
-context properties marked as sensitive.
+`telemetry.includeRuntimeContext` is applied before telemetry integrations receive
+`runtimeContext`, so custom span enrichment only receives top-level runtime context
+properties explicitly set to `true`. If the option is omitted, no runtime context
+properties are included.
+
+Embedding and reranking operations can share the same runtime context with text
+generation to attribute their spans to the same application request:
+
+```ts
+await embed({
+  model: 'openai/text-embedding-3-small',
+  value: 'sunny day at the beach',
+  runtimeContext: {
+    requestId: 'req_abc',
+    userId: 'user_123',
+  },
+  telemetry: {
+    includeRuntimeContext: { requestId: true },
+  },
+});
+```
+
+A globally registered `OpenTelemetry({ enrichSpan })` integration receives
+`{ requestId: 'req_abc' }` for the operation span and its embedding model span.
+The same applies to every chunk in `embedMany` and to the operation and model
+spans in `rerank`. The `onStart` and `onEnd` callbacks receive the full context.
 
 ### Supplemental AI SDK attributes on OpenTelemetry spans
 

package/docs/04-ai-sdk-ui/03-chatbot-tool-usage.mdx

@@ -329,7 +329,7 @@ export default function Chat() {
 
 ### Error handling
 
-Sometimes an error may occur during client-side tool execution. Use the `addToolOutput` method with a `state` of `output-error` and `errorText` value instead of `output` record the error.
+Sometimes an error may occur during client-side tool execution. Use the `addToolOutput` method with a `state` of `output-error` and `errorText` value instead of `output` to record the error.
 
 ```tsx filename='app/page.tsx' highlight="19,36-41"
 'use client';
@@ -380,6 +380,21 @@ export default function Chat() {
 }
 ```
 
+When rendering messages, use `isToolOutputErrorUIPart` to identify failed
+static and dynamic tool parts without checking the tool state directly:
+
+```tsx
+import { isToolOutputErrorUIPart, type UIMessage } from 'ai';
+
+function ToolError({ part }: { part: UIMessage['parts'][number] }) {
+  if (!isToolOutputErrorUIPart(part)) {
+    return null;
+  }
+
+  return <div role="alert">{part.errorText}</div>;
+}
+```
+
 ## Tool Execution Approval
 
 Tool execution approval lets you require user confirmation before a server-side tool runs. Unlike [client-side tools](#example) that execute in the browser, tools with approval still execute on the server—but only after the user approves.

package/docs/07-reference/01-ai-sdk-core/05-embed.mdx

@@ -67,9 +67,16 @@ const { embedding } = await embed({
       description:
         'Provider-specific options that are passed through to the provider.',
     },
+    {
+      name: 'runtimeContext',
+      type: 'RUNTIME_CONTEXT',
+      isOptional: true,
+      description:
+        'User-defined runtime context passed to lifecycle callbacks. Defaults to an empty object. Telemetry integrations only receive top-level properties explicitly included with telemetry.includeRuntimeContext.',
+    },
     {
       name: 'telemetry',
-      type: 'TelemetryOptions',
+      type: 'TelemetryOptions<RUNTIME_CONTEXT>',
       isOptional: true,
       description: 'Telemetry configuration.',
       properties: [
@@ -104,6 +111,13 @@ const { embedding } = await embed({
               description:
                 'Identifier for this function. Used to group telemetry data by function.',
             },
+            {
+              name: 'includeRuntimeContext',
+              type: '{ [KEY in keyof RUNTIME_CONTEXT]?: boolean }',
+              isOptional: true,
+              description:
+                'Top-level runtime context properties to include in telemetry. Only properties set to true are included. All properties are excluded by default. User callbacks still receive the full context.',
+            },
             {
               name: 'integrations',
               isOptional: true,
@@ -117,14 +131,20 @@ const { embedding } = await embed({
     },
     {
       name: 'onStart',
-      type: '(event: EmbedStartEvent) => PromiseLike<void> | void',
+      type: '(event: EmbedStartEvent<RUNTIME_CONTEXT>) => PromiseLike<void> | void',
       isOptional: true,
       description:
         'Callback that is called when the embed operation begins, before the embedding model is called. Errors thrown in this callback are silently caught and do not break the embedding flow.',
       properties: [
         {
-          type: 'EmbedStartEvent',
+          type: 'EmbedStartEvent<RUNTIME_CONTEXT>',
           parameters: [
+            {
+              name: 'runtimeContext',
+              type: 'RUNTIME_CONTEXT',
+              description:
+                'The full, unfiltered runtime context supplied to the operation.',
+            },
             {
               name: 'callId',
               type: 'string',
@@ -171,14 +191,20 @@ const { embedding } = await embed({
     },
     {
       name: 'onEnd',
-      type: '(event: EmbedEndEvent) => PromiseLike<void> | void',
+      type: '(event: EmbedEndEvent<RUNTIME_CONTEXT>) => PromiseLike<void> | void',
       isOptional: true,
       description:
         'Callback that is called when the embed operation completes, after the embedding model returns. Errors thrown in this callback are silently caught and do not break the embedding flow.',
       properties: [
         {
-          type: 'EmbedEndEvent',
+          type: 'EmbedEndEvent<RUNTIME_CONTEXT>',
           parameters: [
+            {
+              name: 'runtimeContext',
+              type: 'RUNTIME_CONTEXT',
+              description:
+                'The full, unfiltered runtime context supplied to the operation.',
+            },
             {
               name: 'callId',
               type: 'string',

package/docs/07-reference/01-ai-sdk-core/06-embed-many.mdx

@@ -83,9 +83,16 @@ const { embeddings } = await embedMany({
       description:
         'Maximum number of concurrent requests to the provider. Default: Infinity.',
     },
+    {
+      name: 'runtimeContext',
+      type: 'RUNTIME_CONTEXT',
+      isOptional: true,
+      description:
+        'User-defined runtime context passed to lifecycle callbacks. Defaults to an empty object. Telemetry integrations only receive top-level properties explicitly included with telemetry.includeRuntimeContext.',
+    },
     {
       name: 'telemetry',
-      type: 'TelemetryOptions',
+      type: 'TelemetryOptions<RUNTIME_CONTEXT>',
       isOptional: true,
       description: 'Telemetry configuration.',
       properties: [
@@ -120,6 +127,13 @@ const { embeddings } = await embedMany({
               description:
                 'Identifier for this function. Used to group telemetry data by function.',
             },
+            {
+              name: 'includeRuntimeContext',
+              type: '{ [KEY in keyof RUNTIME_CONTEXT]?: boolean }',
+              isOptional: true,
+              description:
+                'Top-level runtime context properties to include in telemetry. Only properties set to true are included. All properties are excluded by default. User callbacks still receive the full context.',
+            },
             {
               name: 'integrations',
               isOptional: true,
@@ -133,14 +147,20 @@ const { embeddings } = await embedMany({
     },
     {
       name: 'onStart',
-      type: '(event: EmbedStartEvent) => PromiseLike<void> | void',
+      type: '(event: EmbedStartEvent<RUNTIME_CONTEXT>) => PromiseLike<void> | void',
       isOptional: true,
       description:
         'Callback that is called when the embedMany operation begins, before the embedding model is called. Errors thrown in this callback are silently caught and do not break the embedding flow.',
       properties: [
         {
-          type: 'EmbedStartEvent',
+          type: 'EmbedStartEvent<RUNTIME_CONTEXT>',
           parameters: [
+            {
+              name: 'runtimeContext',
+              type: 'RUNTIME_CONTEXT',
+              description:
+                'The full, unfiltered runtime context supplied to the operation.',
+            },
             {
               name: 'callId',
               type: 'string',
@@ -188,14 +208,20 @@ const { embeddings } = await embedMany({
     },
     {
       name: 'onEnd',
-      type: '(event: EmbedEndEvent) => PromiseLike<void> | void',
+      type: '(event: EmbedEndEvent<RUNTIME_CONTEXT>) => PromiseLike<void> | void',
       isOptional: true,
       description:
         'Callback that is called when the embedMany operation completes, after all embedding model calls return. Errors thrown in this callback are silently caught and do not break the embedding flow.',
       properties: [
         {
-          type: 'EmbedEndEvent',
+          type: 'EmbedEndEvent<RUNTIME_CONTEXT>',
           parameters: [
+            {
+              name: 'runtimeContext',
+              type: 'RUNTIME_CONTEXT',
+              description:
+                'The full, unfiltered runtime context supplied to the operation.',
+            },
             {
               name: 'callId',
               type: 'string',

package/docs/07-reference/01-ai-sdk-core/06-rerank.mdx

@@ -81,9 +81,16 @@ const { ranking } = await rerank({
       isOptional: true,
       description: 'Provider-specific options for the reranking request.',
     },
+    {
+      name: 'runtimeContext',
+      type: 'RUNTIME_CONTEXT',
+      isOptional: true,
+      description:
+        'User-defined runtime context passed to lifecycle callbacks. Defaults to an empty object. Telemetry integrations only receive top-level properties explicitly included with telemetry.includeRuntimeContext.',
+    },
     {
       name: 'telemetry',
-      type: 'TelemetryOptions',
+      type: 'TelemetryOptions<RUNTIME_CONTEXT>',
       isOptional: true,
       description: 'Telemetry configuration.',
       properties: [
@@ -118,6 +125,13 @@ const { ranking } = await rerank({
               description:
                 'Identifier for this function. Used to group telemetry data by function.',
             },
+            {
+              name: 'includeRuntimeContext',
+              type: '{ [KEY in keyof RUNTIME_CONTEXT]?: boolean }',
+              isOptional: true,
+              description:
+                'Top-level runtime context properties to include in telemetry. Only properties set to true are included. All properties are excluded by default. User callbacks still receive the full context.',
+            },
             {
               name: 'integrations',
               isOptional: true,
@@ -131,17 +145,17 @@ const { ranking } = await rerank({
     },
     {
       name: 'onStart',
-      type: '(event: RerankStartEvent) => void | Promise<void>',
+      type: '(event: RerankStartEvent<RUNTIME_CONTEXT>) => void | Promise<void>',
       isOptional: true,
       description:
-        'Called when the rerank operation begins, before the reranking model is called.',
+        'Called when the rerank operation begins, before the reranking model is called. The event includes the full, unfiltered runtimeContext.',
     },
     {
       name: 'onEnd',
-      type: '(event: RerankEndEvent) => void | Promise<void>',
+      type: '(event: RerankEndEvent<RUNTIME_CONTEXT>) => void | Promise<void>',
       isOptional: true,
       description:
-        'Called when the rerank operation completes, after the reranking model returns.',
+        'Called when the rerank operation completes, after the reranking model returns. The event includes the full, unfiltered runtimeContext.',
     },
   ]}
 />

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

@@ -9,8 +9,7 @@ description: API Reference for experimental_startBatch.
   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
+Starts an asynchronous batch of text or image generation requests. For a complete guide to the batch lifecycle, see
 [Batch](/docs/ai-sdk-core/batch).
 
 ```ts

package/docs/07-reference/01-ai-sdk-core/31-ui-message.mdx

@@ -203,6 +203,34 @@ type ToolUIPart<TOOLS extends UITools = UITools> = ValueOf<{
 the tool part transitions from `approval-requested` to `approval-responded` and
 in later approval-bearing output states.
 
+### `ToolOutputErrorUIPart`
+
+A static or dynamic tool part whose execution failed. Use the
+`isToolOutputErrorUIPart` type guard when rendering messages so your code does
+not need to check the tool state discriminator directly.
+
+```tsx
+import { isToolOutputErrorUIPart, type UIMessage } from 'ai';
+
+function ToolError({ part }: { part: UIMessage['parts'][number] }) {
+  if (!isToolOutputErrorUIPart(part)) {
+    return null;
+  }
+
+  return <div role="alert">{part.errorText}</div>;
+}
+```
+
+The generic `ToolOutputErrorUIPart<TOOLS>` type preserves the input types of
+static tools and also includes dynamic tool errors:
+
+```typescript
+type ToolOutputErrorUIPart<TOOLS extends UITools = UITools> = Extract<
+  ToolUIPart<TOOLS> | DynamicToolUIPart,
+  { state: 'output-error' }
+>;
+```
+
 ### `CustomContentUIPart`
 
 A provider-specific custom content part of a message.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.97",
+  "version": "7.0.98",
   "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.78",
-    "@ai-sdk/provider": "4.0.13",
-    "@ai-sdk/provider-utils": "5.0.39"
+    "@ai-sdk/gateway": "4.0.79",
+    "@ai-sdk/provider": "4.0.14",
+    "@ai-sdk/provider-utils": "5.0.40"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.81",
-    "@ai-sdk/deepseek": "3.0.42",
-    "@ai-sdk/google": "4.0.67",
-    "@ai-sdk/groq": "4.0.40",
-    "@ai-sdk/huggingface": "2.0.47",
-    "@ai-sdk/moonshotai": "3.0.48",
-    "@ai-sdk/openai": "4.0.65",
+    "@ai-sdk/amazon-bedrock": "5.0.82",
+    "@ai-sdk/deepseek": "3.0.43",
+    "@ai-sdk/google": "4.0.68",
+    "@ai-sdk/groq": "4.0.41",
+    "@ai-sdk/huggingface": "2.0.48",
+    "@ai-sdk/moonshotai": "3.0.49",
+    "@ai-sdk/openai": "4.0.66",
     "@ai-sdk/test-server": "2.0.1",
-    "@ai-sdk/xai": "4.0.57",
+    "@ai-sdk/xai": "4.0.58",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/batch/batch-types.ts

@@ -4,6 +4,7 @@ import type {
   Experimental_BatchV4ModelIds as BatchV4ModelIds,
   Experimental_BatchV4StartResult as BatchV4StartResult,
   Experimental_BatchV4Status as BatchV4Status,
+  ImageModelV4ProviderMetadata,
   ProviderV4,
 } from '@ai-sdk/provider';
 import type {
@@ -17,7 +18,11 @@ import type { LanguageModelCallOptions } from '../prompt/language-model-call-opt
 import type { Prompt } from '../prompt/prompt';
 import type { FinishReason, ToolChoice } from '../types/language-model';
 import type { ProviderMetadata } from '../types/provider-metadata';
-import type { LanguageModelUsage } from '../types/usage';
+import type { ImageModelUsage, LanguageModelUsage } from '../types/usage';
+import type { GenerateImagePrompt } from '../generate-image/generate-image';
+import type { GeneratedFile } from '../generate-text/generated-file';
+import type { ImageModelResponseMetadata } from '../types/image-model-response-metadata';
+import type { Warning } from '../types/warning';
 
 /**
  * Provider or lower-level batch interface used for batch processing.
@@ -73,13 +78,30 @@ export type TextBatchRequest<
     providerOptions?: ProviderOptions;
   };
 
+/**
+ * One image generation request within a batch.
+ */
+export type ImageBatchRequest<ModelId extends string = string> = {
+  id: string;
+  type: 'image';
+  model: ModelId;
+  prompt: GenerateImagePrompt;
+  n?: number;
+  size?: `${number}x${number}`;
+  aspectRatio?: `${number}:${number}`;
+  seed?: number;
+  providerOptions?: ProviderOptions;
+};
+
 /**
  * One request within a batch, discriminated by modality.
  */
 export type BatchRequest<
   ModelIds extends BatchV4ModelIds = BatchV4ModelIds,
   TOOLS extends ToolSet = ToolSet,
-> = TextBatchRequest<ModelIds['text'], TOOLS>;
+> =
+  | TextBatchRequest<ModelIds['text'] & string, TOOLS>
+  | ImageBatchRequest<ModelIds['image'] & string>;
 
 type BatchCallOptions = {
   abortSignal?: AbortSignal;
@@ -203,7 +225,9 @@ export type TextBatchGenerationResult<TOOLS extends ToolSet = ToolSet> = {
 /**
  * A complete terminal result for one request in a text batch.
  */
-export type TextBatchItemResult<TOOLS extends ToolSet = ToolSet> =
+export type TextBatchItemResult<TOOLS extends ToolSet = ToolSet> = {
+  readonly type: 'text';
+} & (
   | (TextBatchGenerationResult<TOOLS> & {
       readonly id: string;
       readonly status: 'succeeded';
@@ -219,10 +243,45 @@ export type TextBatchItemResult<TOOLS extends ToolSet = ToolSet> =
       readonly status: 'cancelled' | 'expired';
       readonly error?: BatchError;
       readonly providerMetadata?: ProviderMetadata;
-    };
+    }
+);
+
+/**
+ * A normalized result for a successful image batch item.
+ */
+export type ImageBatchGenerationResult = {
+  readonly images: Array<GeneratedFile>;
+  readonly warnings: Array<Warning>;
+  readonly response: ImageModelResponseMetadata;
+  readonly providerMetadata?: ImageModelV4ProviderMetadata;
+  readonly usage?: ImageModelUsage;
+};
+
+/**
+ * A complete terminal result for one request in an image batch.
+ */
+export type ImageBatchItemResult = { readonly type: 'image' } & (
+  | (ImageBatchGenerationResult & {
+      readonly id: string;
+      readonly status: 'succeeded';
+    })
+  | {
+      readonly id: string;
+      readonly status: 'failed';
+      readonly error: BatchError;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly id: string;
+      readonly status: 'cancelled' | 'expired';
+      readonly error?: BatchError;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+);
 
 /**
  * A complete terminal result for one request in a batch.
  */
 export type BatchItemResult<TOOLS extends ToolSet = ToolSet> =
-  TextBatchItemResult<TOOLS>;
+  | TextBatchItemResult<TOOLS>
+  | ImageBatchItemResult;