@ai-sdk/openai 4.0.60 → 4.0.62

package/docs/03-openai.mdx

@@ -528,6 +528,55 @@ metadata on tool-call parts. The SDK uses `providerMetadata.openai.namespace` or
 `providerOptions.openai.namespace` to round-trip the namespace back to OpenAI on
 subsequent requests.
 
+#### Async Tool Calling
+
+GPT-6 Astra and later Responses models support
+[async tool calling](https://developers.openai.com/api/docs/guides/async-tool-calling).
+An async tool lets the model continue generating independent output after issuing
+the call instead of waiting for its result. Your application still executes the
+tool and sends its result in a later request using the original tool call ID.
+
+Enable async calling on a function tool with `providerOptions.openai.async`:
+
+```ts
+import { openai, type OpenAIToolOptions } from '@ai-sdk/openai';
+import { generateText, tool } from 'ai';
+import { z } from 'zod';
+
+const result = await generateText({
+  model: openai.responses('gpt-6-astra'),
+  tools: {
+    getWeather: tool({
+      description: 'Get the weather for a city.',
+      inputSchema: z.object({ city: z.string() }),
+      outputSchema: z.object({
+        city: z.string(),
+        temperatureC: z.number(),
+      }),
+      providerOptions: {
+        openai: { async: true } satisfies OpenAIToolOptions,
+      },
+    }),
+  },
+  prompt:
+    'Start the weather lookup for Paris, then list three general packing essentials without waiting.',
+});
+```
+
+The generated tool call exposes the provider marker as
+`providerMetadata.openai.async`. Use `providerMetadata.openai.responseId` as the
+next request's `previousResponseId`, and submit the result in a tool message with
+the original `toolCallId`.
+
+With `streamText`, OpenAI can continue streaming text after the completed
+`tool-call` part. Use the tool's `onInputAvailable` callback to start work as soon
+as that part arrives. If `execute` returns the same already-running promise, tool
+execution overlaps the rest of the model stream. Omit `execute` when the job
+should outlive the current generation and submit its result in a later request.
+
+Async calling applies to directly called function and custom tools. It does not
+apply to hosted tools and should not be combined with programmatic tool calling.
+
 #### Programmatic Tool Calling
 
 OpenAI Programmatic Tool Calling lets supported Responses models generate and run
@@ -778,6 +827,16 @@ for await (const part of result.stream) {
   setting `store: false`.
 </Note>
 
+To use `xhigh` or `max` quality, select `gpt-image-2.5-flare` or
+`gpt-image-2.5-sunburst` as the image generation tool's model:
+
+```ts
+openai.tools.imageGeneration({
+  model: 'gpt-image-2.5-flare',
+  quality: 'xhigh',
+});
+```
+
 For complete details on model availability, image quality controls, supported sizes, and tool-specific parameters,
 refer to the OpenAI documentation:
 
@@ -2035,27 +2094,37 @@ import { openai } from '@ai-sdk/openai';
 import {
   experimental_getBatchResults as getBatchResults,
   experimental_getBatchStatus as getBatchStatus,
-  experimental_startTextBatch as startTextBatch,
+  experimental_startBatch as startBatch,
 } from 'ai';
 import { setTimeout } from 'node:timers/promises';
 
-const model = openai('gpt-4.1-nano');
+const model = 'gpt-4.1-nano';
 
-const batch = await startTextBatch({
-  model,
+const batch = await startBatch({
+  provider: openai,
   requests: [
-    { id: 'capital-france', prompt: 'What is the capital of France?' },
-    { id: 'capital-germany', prompt: 'What is the capital of Germany?' },
+    {
+      id: 'capital-france',
+      type: 'text',
+      model,
+      prompt: 'What is the capital of France?',
+    },
+    {
+      id: 'capital-germany',
+      type: 'text',
+      model,
+      prompt: 'What is the capital of Germany?',
+    },
   ],
 });
 
 let status = batch.status;
 while (status === 'pending') {
   await setTimeout(60_000);
-  ({ status } = await getBatchStatus({ model, batch }));
+  ({ status } = await getBatchStatus({ provider: openai, batch }));
 }
 
-for await (const item of getBatchResults({ model, batch })) {
+for await (const item of getBatchResults({ provider: openai, batch })) {
   if (item.status === 'succeeded') {
     console.log(item.id, item.text);
   } else {
@@ -2064,11 +2133,15 @@ for await (const item of getBatchResults({ model, batch })) {
 }
 ```
 
-`startTextBatch` returns a serializable batch reference. Persist this reference
+`startBatch` returns a serializable batch reference. Persist this reference
 to check the batch status or retrieve its results from another process. Results
 can arrive in a different order from the input requests, so match each result by
 its `id`.
 
+Each request specifies its `type` and `model`. OpenAI requires every text
+request in a batch to use the same model and throws before submission when the
+models differ.
+
 #### Webhooks
 
 <Note>
@@ -3023,6 +3096,19 @@ const { image, providerMetadata } = await generateImage({
 });
 ```
 
+The `gpt-image-2.5-flare` and `gpt-image-2.5-sunburst` models also support
+`quality: 'xhigh'` and `quality: 'max'` for both image generation and editing:
+
+```ts
+const { image } = await generateImage({
+  model: openai.image('gpt-image-2.5-sunburst'),
+  prompt: 'A salamander at sunrise in a forest pond in the Seychelles.',
+  providerOptions: {
+    openai: { quality: 'max' } satisfies OpenAIImageModelGenerationOptions,
+  },
+});
+```
+
 For more on `generateImage()` see [Image Generation](/docs/ai-sdk-core/image-generation).
 
 OpenAI's image models return additional metadata in the response that can be
@@ -3035,7 +3121,7 @@ is available:
   - `revisedPrompt` _string_ - The revised prompt that was actually used to generate the image (OpenAI may modify your prompt for safety or clarity)
   - `created` _number_ - The Unix timestamp (in seconds) of when the image was created
   - `size` _string_ - The size of the generated image. One of `1024x1024`, `1024x1536`, or `1536x1024`
-  - `quality` _string_ - The quality of the generated image. One of `low`, `medium`, or `high`
+  - `quality` _string_ - The quality of the generated image. One of `low`, `medium`, `high`, `xhigh`, or `max`
   - `background` _string_ - The background parameter used for the image generation. Either `transparent` or `opaque`
   - `outputFormat` _string_ - The output format of the generated image. One of `png`, `webp`, or `jpeg`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.60",
+  "version": "4.0.62",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.10",
-    "@ai-sdk/provider-utils": "5.0.36"
+    "@ai-sdk/provider": "4.0.11",
+    "@ai-sdk/provider-utils": "5.0.37"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.1",

package/src/image/openai-image-model-options.ts

@@ -45,10 +45,11 @@ const baseImageModelOptionsObject = z.object({
   /**
    * Quality of the generated image(s).
    *
-   * Valid values: `standard`, `hd`, `low`, `medium`, `high`, `auto`.
+   * Valid values: `standard`, `hd`, `low`, `medium`, `high`, `xhigh`, `max`, `auto`.
+   * `xhigh` and `max` are supported by GPT Image 2.5 models.
    */
   quality: z
-    .enum(['standard', 'hd', 'low', 'medium', 'high', 'auto'])
+    .enum(['standard', 'hd', 'low', 'medium', 'high', 'xhigh', 'max', 'auto'])
     .optional(),
 
   /**

package/src/index.ts

@@ -44,6 +44,7 @@ export type {
   OpenaiResponsesCompactionProviderMetadata,
   OpenaiResponsesProviderMetadata,
   OpenaiResponsesReasoningProviderMetadata,
+  OpenaiResponsesToolCallProviderMetadata,
   OpenaiResponsesTextProviderMetadata,
   OpenaiResponsesSourceDocumentProviderMetadata,
 } from './responses/openai-responses-provider-metadata';

package/src/{openai-responses-batch.ts → openai-batch.ts}

@@ -1,13 +1,15 @@
 import {
   InvalidArgumentError,
   InvalidResponseDataError,
-  type Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
-  type Experimental_BatchV4StartOptions as BatchV4StartOptions,
+  type Experimental_BatchV4 as BatchV4,
   type Experimental_BatchV4StartResult as BatchV4StartResult,
   type Experimental_BatchV4Error as BatchV4Error,
   type Experimental_BatchV4ItemResult as BatchV4ItemResult,
   type Experimental_BatchV4OperationOptions as BatchV4OperationOptions,
   type Experimental_BatchV4Status as BatchV4Status,
+  type Experimental_TextBatchV4ItemResult as TextBatchV4ItemResult,
+  type Experimental_BatchV4StartOptions as BatchV4StartOptions,
+  type Experimental_TextBatchV4Request as TextBatchV4Request,
   type LanguageModelV4GenerateResult,
   type SharedV4ProviderMetadata,
   type SharedV4Warning,
@@ -24,8 +26,6 @@ import {
   postJsonToApi,
   postToApi,
   safeValidateTypes,
-  WORKFLOW_DESERIALIZE,
-  WORKFLOW_SERIALIZE,
   zodSchema,
   type InferSchema,
 } from '@ai-sdk/provider-utils';
@@ -34,10 +34,7 @@ import {
   openaiErrorDataSchema,
   openaiFailedResponseHandler,
 } from './openai-error';
-import {
-  prepareOpenAIConfigForWorkflowDeserialize,
-  type OpenAIConfig,
-} from './openai-config';
+import type { OpenAIConfig } from './openai-config';
 import { openaiFilesResponseSchema } from './files/openai-files-api';
 import { convertOpenAIResponsesUsage } from './responses/convert-openai-responses-usage';
 import { mapOpenAIResponseFinishReason } from './responses/map-openai-responses-finish-reason';
@@ -48,6 +45,7 @@ import {
 import {
   mapWebSearchOutput,
   OpenAIResponsesLanguageModel,
+  openaiResponsesSupportedUrls,
 } from './responses/openai-responses-language-model';
 import type { OpenAIResponsesModelId } from './responses/openai-responses-language-model-options';
 import type { ResponsesReasoningProviderMetadata } from './responses/openai-responses-provider-metadata';
@@ -73,16 +71,18 @@ const openaiBatchProviderOptionsSchema = lazySchema(() =>
   ),
 );
 
-type OpenAIBatchRequest = Parameters<
-  BatchLanguageModelV4['experimental_doStartBatch']
->[0]['requests'][number];
+type OpenAIBatchModelIds = {
+  readonly text: OpenAIResponsesModelId;
+};
+
+type OpenAIBatchRequest = TextBatchV4Request<OpenAIResponsesModelId>;
 
 type OpenAIBatchPreparedRequest = {
   body: unknown;
   warnings: SharedV4Warning[];
 };
 
-type OpenAIBatchResponseConversion =
+type OpenAIBatchResultConversion =
   | { success: true; result: LanguageModelV4GenerateResult }
   | { success: false; error: BatchV4Error };
 
@@ -143,20 +143,25 @@ const openaiBatchResultLineSchema = lazySchema(() =>
 
 type OpenAIBatchResultLine = InferSchema<typeof openaiBatchResultLineSchema>;
 
-class OpenAIResponsesBatch {
+export class OpenAIBatch implements BatchV4<OpenAIBatchModelIds> {
+  readonly specificationVersion = 'v4' as const;
+  readonly provider: string;
+  readonly supportedUrls = openaiResponsesSupportedUrls;
+
   constructor(
     private readonly options: {
-      modelId: string;
+      provider: string;
       config: OpenAIConfig;
-      prepareRequest: (
-        request: OpenAIBatchRequest,
-      ) => PromiseLike<OpenAIBatchPreparedRequest>;
     },
-  ) {}
+  ) {
+    this.provider = options.provider;
+  }
 
-  async startBatch(
-    options: BatchV4StartOptions<OpenAIBatchRequest>,
+  async doStartBatch(
+    options: BatchV4StartOptions<OpenAIBatchModelIds>,
   ): Promise<BatchV4StartResult> {
+    validateSingleModel(options.requests);
+
     const fileParts: string[] = [];
     const warnings: BatchV4StartResult['warnings'] =
       options.webhookUrl == null
@@ -180,7 +185,7 @@ class OpenAIResponsesBatch {
       openaiBatchInputFileDefaultExpiresAfterSeconds;
 
     for (const request of options.requests) {
-      const preparedRequest = await this.options.prepareRequest(request);
+      const preparedRequest = await this.prepareRequest(request);
 
       fileParts.push(
         JSON.stringify({
@@ -285,7 +290,7 @@ class OpenAIResponsesBatch {
   }
 
   private async parseBatchProviderOptions(
-    providerOptions: BatchV4StartOptions<OpenAIBatchRequest>['providerOptions'],
+    providerOptions: BatchV4StartOptions<OpenAIBatchModelIds>['providerOptions'],
   ) {
     const providerOptionsName = this.options.config.provider.includes('azure')
       ? 'azure'
@@ -307,16 +312,16 @@ class OpenAIResponsesBatch {
     return batchOptions;
   }
 
-  async getBatchStatus(
+  async doGetBatchStatus(
     options: BatchV4OperationOptions,
   ): Promise<BatchV4Status> {
     const batch = await this.retrieveBatch(options);
     return convertOpenAIBatchStatus(batch);
   }
 
-  async getBatchResults(
+  async doGetBatchResults(
     options: BatchV4OperationOptions,
-  ): Promise<ReadableStream<BatchV4ItemResult<LanguageModelV4GenerateResult>>> {
+  ): Promise<ReadableStream<BatchV4ItemResult>> {
     const batch = await this.retrieveBatch(options);
 
     const batchStatus = convertOpenAIBatchStatus(batch);
@@ -368,7 +373,7 @@ class OpenAIResponsesBatch {
   }: {
     fileIds: string[];
     options: BatchV4OperationOptions;
-  }): AsyncGenerator<BatchV4ItemResult<LanguageModelV4GenerateResult>> {
+  }): AsyncGenerator<BatchV4ItemResult> {
     for (const fileId of fileIds) {
       const { value: lines } = await getFromApi({
         url: this.getUrl(`/files/${encodeURIComponent(fileId)}/content`),
@@ -393,7 +398,7 @@ class OpenAIResponsesBatch {
 
   private async convertResultLine(
     line: OpenAIBatchResultLine,
-  ): Promise<BatchV4ItemResult<LanguageModelV4GenerateResult>> {
+  ): Promise<TextBatchV4ItemResult> {
     if (line.error != null) {
       const error = {
         message: line.error.message,
@@ -401,18 +406,19 @@ class OpenAIResponsesBatch {
       };
 
       if (line.error.code === 'batch_cancelled') {
-        return { id: line.custom_id, status: 'cancelled', error };
+        return { type: 'text', id: line.custom_id, status: 'cancelled', error };
       }
 
       if (line.error.code === 'batch_expired') {
-        return { id: line.custom_id, status: 'expired', error };
+        return { type: 'text', id: line.custom_id, status: 'expired', error };
       }
 
-      return { id: line.custom_id, status: 'failed', error };
+      return { type: 'text', id: line.custom_id, status: 'failed', error };
     }
 
     if (line.response == null) {
       return {
+        type: 'text',
         id: line.custom_id,
         status: 'failed',
         error: {
@@ -425,6 +431,7 @@ class OpenAIResponsesBatch {
 
     if (line.response.status_code < 200 || line.response.status_code >= 300) {
       return {
+        type: 'text',
         id: line.custom_id,
         status: 'failed',
         error: await convertOpenAIErrorResponse({
@@ -434,11 +441,10 @@ class OpenAIResponsesBatch {
       };
     }
 
-    const conversion = await convertOpenAIResponsesBatchResponse(
-      line.response.body,
-    );
+    const conversion = await convertOpenAIBatchResult(line.response.body);
     if (!conversion.success) {
       return {
+        type: 'text',
         id: line.custom_id,
         status: 'failed',
         error: conversion.error,
@@ -446,17 +452,43 @@ class OpenAIResponsesBatch {
     }
 
     return {
+      type: 'text',
       id: line.custom_id,
       status: 'succeeded',
       result: conversion.result,
     };
   }
 
+  private async prepareRequest(
+    request: OpenAIBatchRequest,
+  ): Promise<OpenAIBatchPreparedRequest> {
+    const { args: body, warnings } =
+      await OpenAIResponsesLanguageModel.prepareRequest({
+        modelId: request.modelId,
+        config: this.options.config,
+        options: request.options,
+      });
+
+    return { body, warnings };
+  }
+
   private getUrl(path: string) {
-    return this.options.config.url({
-      modelId: this.options.modelId,
-      path,
-    });
+    return this.options.config.url({ path, modelId: '' });
+  }
+}
+
+function validateSingleModel(requests: ReadonlyArray<OpenAIBatchRequest>) {
+  const modelId = requests[0]?.modelId;
+
+  for (const request of requests) {
+    if (request.modelId !== modelId) {
+      throw new InvalidArgumentError({
+        argument: 'requests',
+        message:
+          'The OpenAI Batch API requires all requests in a batch to use the ' +
+          `same model. Found "${modelId}" and "${request.modelId}".`,
+      });
+    }
   }
 }
 
@@ -468,54 +500,6 @@ const openAIBatchConvertibleProviderToolIds = new Set([
   'openai.web_search_preview',
 ]);
 
-export class OpenAIResponsesBatchLanguageModel
-  extends OpenAIResponsesLanguageModel
-  implements BatchLanguageModelV4
-{
-  private readonly batch: OpenAIResponsesBatch;
-
-  static [WORKFLOW_SERIALIZE](model: OpenAIResponsesLanguageModel) {
-    return OpenAIResponsesLanguageModel[WORKFLOW_SERIALIZE](model);
-  }
-
-  static [WORKFLOW_DESERIALIZE](options: {
-    modelId: string;
-    config: Parameters<typeof prepareOpenAIConfigForWorkflowDeserialize>[0];
-  }) {
-    return new OpenAIResponsesBatchLanguageModel(
-      options.modelId as OpenAIResponsesModelId,
-      prepareOpenAIConfigForWorkflowDeserialize(options.config),
-    );
-  }
-
-  constructor(modelId: OpenAIResponsesModelId, config: OpenAIConfig) {
-    super(modelId, config);
-    this.batch = new OpenAIResponsesBatch({
-      modelId,
-      config,
-      prepareRequest: async request => {
-        const { args: body, warnings } = await this.getArgs(request.options);
-
-        return { body, warnings };
-      },
-    });
-  }
-
-  experimental_doStartBatch(
-    options: Parameters<BatchLanguageModelV4['experimental_doStartBatch']>[0],
-  ) {
-    return this.batch.startBatch(options);
-  }
-
-  experimental_doGetBatchStatus(options: BatchV4OperationOptions) {
-    return this.batch.getBatchStatus(options);
-  }
-
-  experimental_doGetBatchResults(options: BatchV4OperationOptions) {
-    return this.batch.getBatchResults(options);
-  }
-}
-
 function convertOpenAIBatchStatus(batch: OpenAIBatchResponse): BatchV4Status {
   const status = mapOpenAIBatchStatus(batch.status);
   const firstError = batch.errors?.data?.[0];
@@ -616,9 +600,9 @@ async function convertOpenAIErrorResponse({
   };
 }
 
-async function convertOpenAIResponsesBatchResponse(
+async function convertOpenAIBatchResult(
   body: unknown,
-): Promise<OpenAIBatchResponseConversion> {
+): Promise<OpenAIBatchResultConversion> {
   const validation = await safeValidateTypes({
     value: body,
     schema: openaiResponsesResponseSchema,

package/src/openai-language-model-capabilities.ts

@@ -4,6 +4,7 @@ export type OpenAILanguageModelCapabilities = {
   supportsFlexProcessing: boolean;
   supportsPriorityProcessing: boolean;
   supportsConfigurationUpdate: boolean;
+  supportsAsyncToolCalling: boolean;
   supportedReasoningEfforts: readonly string[] | undefined;
 
   /**
@@ -55,6 +56,7 @@ export function getOpenAILanguageModelCapabilities(
     supportsFlexProcessing,
     supportsPriorityProcessing,
     supportsConfigurationUpdate: isGpt6OrLaterModel,
+    supportsAsyncToolCalling: isGpt6OrLaterModel,
     supportedReasoningEfforts: isGpt6OrLaterModel
       ? ['low', 'medium', 'high', 'xhigh', 'max']
       : undefined,

package/src/openai-provider.ts

@@ -1,6 +1,6 @@
 import type {
+  Experimental_BatchV4 as BatchV4,
   EmbeddingModelV4,
-  Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
   FilesV4,
   ImageModelV4,
   LanguageModelV4,
@@ -31,7 +31,8 @@ import type { OpenAIEmbeddingModelId } from './embedding/openai-embedding-model-
 import { OpenAIImageModel } from './image/openai-image-model';
 import type { OpenAIImageModelId } from './image/openai-image-model-options';
 import { openaiTools } from './openai-tools';
-import { OpenAIResponsesBatchLanguageModel } from './openai-responses-batch';
+import { OpenAIBatch } from './openai-batch';
+import { OpenAIResponsesLanguageModel } from './responses/openai-responses-language-model';
 import { OpenAIRealtimeModel } from './realtime/openai-realtime-model';
 import type { OpenAIResponsesModelId } from './responses/openai-responses-language-model-options';
 import { OpenAISpeechModel } from './speech/openai-speech-model';
@@ -44,12 +45,12 @@ import { OpenAISkills } from './skills/openai-skills';
 import { VERSION } from './version';
 
 export interface OpenAIProvider extends ProviderV4 {
-  (modelId: OpenAIResponsesModelId): BatchLanguageModelV4;
+  (modelId: OpenAIResponsesModelId): LanguageModelV4;
 
   /**
    * Creates an OpenAI model for text generation.
    */
-  languageModel(modelId: OpenAIResponsesModelId): BatchLanguageModelV4;
+  languageModel(modelId: OpenAIResponsesModelId): LanguageModelV4;
 
   /**
    * Creates an OpenAI chat model for text generation.
@@ -59,7 +60,7 @@ export interface OpenAIProvider extends ProviderV4 {
   /**
    * Creates an OpenAI responses API model for text generation.
    */
-  responses(modelId: OpenAIResponsesModelId): BatchLanguageModelV4;
+  responses(modelId: OpenAIResponsesModelId): LanguageModelV4;
 
   /**
    * Creates an OpenAI completion model for text generation.
@@ -136,6 +137,11 @@ export interface OpenAIProvider extends ProviderV4 {
    */
   skills(): SkillsV4;
 
+  /**
+   * Returns a BatchV4 interface for processing batches with OpenAI.
+   */
+  experimental_batch(): BatchV4<{ text: OpenAIResponsesModelId }>;
+
   /**
    * OpenAI-specific tools.
    */
@@ -306,7 +312,7 @@ export function createOpenAI(
   };
 
   const createResponsesModel = (modelId: OpenAIResponsesModelId) => {
-    return new OpenAIResponsesBatchLanguageModel(modelId, {
+    return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
       baseURL,
       url: ({ path }) => `${baseURL}${path}`,
@@ -317,6 +323,20 @@ export function createOpenAI(
     });
   };
 
+  const createBatch = () =>
+    new OpenAIBatch({
+      provider: `${providerName}.batch`,
+      config: {
+        provider: `${providerName}.responses`,
+        baseURL,
+        url: ({ path }) => `${baseURL}${path}`,
+        headers: getHeaders,
+        fetch: options.fetch,
+        // Soft-deprecated. TODO: remove in v8
+        fileIdPrefixes: ['file-'],
+      },
+    });
+
   const createRealtimeModel = (modelId: string) =>
     new OpenAIRealtimeModel(modelId, {
       provider: `${providerName}.realtime`,
@@ -371,6 +391,7 @@ export function createOpenAI(
   provider.speechModel = createSpeechModel;
   provider.files = createFiles;
   provider.skills = createSkills;
+  provider.experimental_batch = createBatch;
 
   provider.experimental_realtime = experimentalRealtimeFactory;
 

package/src/openai-tools.ts

@@ -28,6 +28,7 @@ export const openaiTools = {
    * `input` field is a string matching the specified grammar.
    *
    * @param description - An optional description of the tool.
+   * @param async - Whether the model can continue without waiting for the tool result.
    * @param format - The output format constraint (grammar type, syntax, and definition).
    */
   customTool,
@@ -76,7 +77,7 @@ export const openaiTools = {
    * @param outputCompression - Compression level for the output image (0-100).
    * @param outputFormat - The output format of the generated image. One of 'png', 'jpeg', or 'webp'.
    * @param partialImages - Number of partial images to generate in streaming mode (0-3).
-   * @param quality - The quality of the generated image. One of 'auto', 'low', 'medium', or 'high'.
+   * @param quality - The quality of the generated image. One of 'auto', 'low', 'medium', 'high', 'xhigh', or 'max'. 'xhigh' and 'max' require a GPT Image 2.5 model.
    * @param size - The size of the generated image. One of 'auto', '1024x1024', '1024x1536', or '1536x1024'.
    */
   imageGeneration,

package/src/responses/convert-to-openai-responses-input.ts

@@ -677,6 +677,17 @@ export async function convertToOpenAIResponsesInput({
                 ).providerMetadata?.[providerOptionsName]?.namespace) as
                 | string
                 | undefined;
+              const isAsync = (part.providerOptions?.[providerOptionsName]
+                ?.async ??
+                (
+                  part as {
+                    providerMetadata?: {
+                      [providerOptionsName]?: { async?: boolean };
+                    };
+                  }
+                ).providerMetadata?.[providerOptionsName]?.async) as
+                | boolean
+                | undefined;
               const caller = part.providerOptions?.[providerOptionsName]
                 ?.caller as
                 | { type: 'direct' }
@@ -904,6 +915,7 @@ export async function convertToOpenAIResponsesInput({
                     typeof part.input === 'string'
                       ? part.input
                       : JSON.stringify(part.input),
+                  ...(isAsync != null && { async: isAsync }),
                   id,
                 });
                 break;
@@ -914,6 +926,7 @@ export async function convertToOpenAIResponsesInput({
                 call_id: part.toolCallId,
                 name: resolvedToolName,
                 arguments: serializeToolCallArguments(part.input),
+                ...(isAsync != null && { async: isAsync }),
                 ...(namespace != null && { namespace }),
                 ...(caller != null && {
                   caller: mapToolCaller(caller),