@ai-sdk/openai 4.0.56 → 4.0.58

package/docs/03-openai.mdx

@@ -217,12 +217,13 @@ The following provider options are available:
   `.nullable()`.
 </Note>
 
-- **serviceTier** _'auto' | 'flex' | 'priority' | 'fast' | 'default'_
+- **serviceTier** _'auto' | 'flex' | 'priority' | 'fast' | 'ultrafast' | 'default'_
   Service tier for the request. Set to 'flex' for 50% cheaper processing
   at the cost of increased latency (available for o3, o4-mini, and gpt-5 models).
   Set to 'priority' for faster processing with Enterprise access (available for gpt-4, gpt-5, gpt-5-mini, o3, o4-mini; gpt-5-nano is not supported).
   'fast' is OpenAI's newer name for the 'priority' tier; the two are interchangeable, and responses from
   gpt-5.6 and earlier report `serviceTier: 'priority'` for either.
+  Set to 'ultrafast' for access-controlled Ultrafast processing (available only for gpt-5.6-sol).
 
   Defaults to 'auto'.
 
@@ -2106,13 +2107,14 @@ The following optional provider options are available for OpenAI chat models:
 
   Parameters for prediction mode.
 
-- **serviceTier** _'auto' | 'flex' | 'priority' | 'fast' | 'default'_
+- **serviceTier** _'auto' | 'flex' | 'priority' | 'fast' | 'ultrafast' | 'default'_
 
   Service tier for the request. Set to 'flex' for 50% cheaper processing
   at the cost of increased latency (available for o3, o4-mini, and gpt-5 models).
   Set to 'priority' for faster processing with Enterprise access (available for gpt-4, gpt-5, gpt-5-mini, o3, o4-mini; gpt-5-nano is not supported).
   'fast' is OpenAI's newer name for the 'priority' tier; the two are interchangeable, and responses from
   gpt-5.6 and earlier report `serviceTier: 'priority'` for either.
+  Set to 'ultrafast' for access-controlled Ultrafast processing (available only for gpt-5.6-sol).
 
   Defaults to 'auto'.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.56",
+  "version": "4.0.58",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

package/src/chat/openai-chat-language-model-options.ts

@@ -139,12 +139,13 @@ export const openaiLanguageModelChatOptions = lazySchema(() =>
        * - 'flex': 50% cheaper processing at the cost of increased latency. Only available for o3 and o4-mini models.
        * - 'priority': Higher-speed processing with predictably low latency at premium cost. Available for Enterprise customers.
        * - 'fast': OpenAI's newer name for the 'priority' tier. Interchangeable with it.
+       * - 'ultrafast': Access-controlled Ultrafast processing. Only available for gpt-5.6-sol.
        * - 'default': The request will be processed with the standard pricing and performance for the selected model.
        *
        * @default 'auto'
        */
       serviceTier: z
-        .enum(['auto', 'flex', 'priority', 'fast', 'default'])
+        .enum(['auto', 'flex', 'priority', 'fast', 'ultrafast', 'default'])
         .optional(),
 
       /**

package/src/openai-responses-batch.ts

@@ -20,6 +20,7 @@ import {
   getFromApi,
   lazySchema,
   normalizeBatchRequestCounts,
+  parseProviderOptions,
   postJsonToApi,
   postToApi,
   safeValidateTypes,
@@ -52,7 +53,25 @@ import type { OpenAIResponsesModelId } from './responses/openai-responses-langua
 import type { ResponsesReasoningProviderMetadata } from './responses/openai-responses-provider-metadata';
 
 const openaiBatchEndpoint = '/v1/responses';
-const openaiBatchInputFileExpiresAfterSeconds = 48 * 60 * 60;
+const openaiBatchInputFileDefaultExpiresAfterSeconds = 48 * 60 * 60;
+
+const openaiBatchProviderOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * TTL in seconds for the uploaded batch input file, measured from
+       * upload time. OpenAI accepts integers between 3600 (1 hour) and
+       * 2592000 (30 days) inclusive. Defaults to 48 hours.
+       */
+      inputFileExpiresAfter: z
+        .number()
+        .int()
+        .min(3600)
+        .max(2_592_000)
+        .optional(),
+    }),
+  ),
+);
 
 type OpenAIBatchRequest = Parameters<
   BatchLanguageModelV4['experimental_doStartBatch']
@@ -153,6 +172,13 @@ class OpenAIResponsesBatch {
             },
           ];
 
+    const batchOptions = await this.parseBatchProviderOptions(
+      options.providerOptions,
+    );
+    const inputFileExpiresAfterSeconds =
+      batchOptions?.inputFileExpiresAfter ??
+      openaiBatchInputFileDefaultExpiresAfterSeconds;
+
     for (const request of options.requests) {
       const preparedRequest = await this.options.prepareRequest(request);
 
@@ -200,7 +226,7 @@ class OpenAIResponsesBatch {
     formData.append('expires_after[anchor]', 'created_at');
     formData.append(
       'expires_after[seconds]',
-      String(openaiBatchInputFileExpiresAfterSeconds),
+      String(inputFileExpiresAfterSeconds),
     );
 
     const { value: uploadedFile } = await postToApi({
@@ -211,9 +237,7 @@ class OpenAIResponsesBatch {
         values: {
           purpose: 'batch',
           'expires_after[anchor]': 'created_at',
-          'expires_after[seconds]': String(
-            openaiBatchInputFileExpiresAfterSeconds,
-          ),
+          'expires_after[seconds]': String(inputFileExpiresAfterSeconds),
           file: {
             name: filename,
             type: file.type,
@@ -245,13 +269,44 @@ class OpenAIResponsesBatch {
       fetch: this.options.config.fetch,
     });
 
+    const inputFileExpiresAt = convertUnixTimestamp(uploadedFile.expires_at);
+
     return {
       batchId: batch.id,
       ...convertOpenAIBatchStatus(batch),
+      providerMetadata: {
+        openai: {
+          inputFileId: uploadedFile.id,
+          ...(inputFileExpiresAt != null ? { inputFileExpiresAt } : {}),
+        },
+      },
       warnings,
     };
   }
 
+  private async parseBatchProviderOptions(
+    providerOptions: BatchV4StartOptions<OpenAIBatchRequest>['providerOptions'],
+  ) {
+    const providerOptionsName = this.options.config.provider.includes('azure')
+      ? 'azure'
+      : 'openai';
+    let batchOptions = await parseProviderOptions({
+      provider: providerOptionsName,
+      providerOptions,
+      schema: openaiBatchProviderOptionsSchema,
+    });
+
+    if (batchOptions == null && providerOptionsName !== 'openai') {
+      batchOptions = await parseProviderOptions({
+        provider: 'openai',
+        providerOptions,
+        schema: openaiBatchProviderOptionsSchema,
+      });
+    }
+
+    return batchOptions;
+  }
+
   async getBatchStatus(
     options: BatchV4OperationOptions,
   ): Promise<BatchV4Status> {

package/src/responses/convert-openai-responses-usage.ts

@@ -1,19 +1,24 @@
-import type { LanguageModelV4Usage } from '@ai-sdk/provider';
+import type { JSONObject, LanguageModelV4Usage } from '@ai-sdk/provider';
 import { createNullLanguageModelUsage } from '@ai-sdk/provider-utils';
 
-export type OpenAIResponsesUsage = {
+export type OpenAIResponsesUsage = JSONObject & {
   input_tokens: number;
   output_tokens: number;
-  input_tokens_details?: {
-    cached_tokens?: number | null;
-    cache_write_tokens?: number | null;
-    orchestration_input_tokens?: number | null;
-    orchestration_input_cached_tokens?: number | null;
-  } | null;
-  output_tokens_details?: {
-    reasoning_tokens?: number | null;
-    orchestration_output_tokens?: number | null;
-  } | null;
+  total_tokens?: number;
+  input_tokens_details?:
+    | (JSONObject & {
+        cached_tokens?: number | null;
+        cache_write_tokens?: number | null;
+        orchestration_input_tokens?: number | null;
+        orchestration_input_cached_tokens?: number | null;
+      })
+    | null;
+  output_tokens_details?:
+    | (JSONObject & {
+        reasoning_tokens?: number | null;
+        orchestration_output_tokens?: number | null;
+      })
+    | null;
 };
 
 export function convertOpenAIResponsesUsage(

package/src/responses/openai-responses-api.ts

@@ -18,6 +18,37 @@ const jsonValueSchema: z.ZodType<JSONValue> = z.lazy(() =>
   ]),
 );
 
+const jsonObjectSchema = z.record(z.string(), jsonValueSchema.optional());
+
+const openaiResponsesUsageSchema = z.intersection(
+  jsonObjectSchema,
+  z.object({
+    input_tokens: z.number(),
+    input_tokens_details: z
+      .intersection(
+        jsonObjectSchema,
+        z.object({
+          cached_tokens: z.number().nullish(),
+          cache_write_tokens: z.number().nullish(),
+          orchestration_input_tokens: z.number().nullish(),
+          orchestration_input_cached_tokens: z.number().nullish(),
+        }),
+      )
+      .nullish(),
+    output_tokens: z.number(),
+    output_tokens_details: z
+      .intersection(
+        jsonObjectSchema,
+        z.object({
+          reasoning_tokens: z.number().nullish(),
+          orchestration_output_tokens: z.number().nullish(),
+        }),
+      )
+      .nullish(),
+    total_tokens: z.number().optional(),
+  }),
+);
+
 const openaiResponsesComputerSafetyCheckSchema = z.object({
   id: z.string(),
   code: z.string().nullish(),
@@ -570,6 +601,7 @@ export type OpenAIResponsesTool =
     }
   | {
       type: 'image_generation';
+      action: 'generate' | 'edit' | 'auto' | undefined;
       background: 'auto' | 'opaque' | 'transparent' | undefined;
       input_fidelity: 'low' | 'high' | undefined;
       input_image_mask:
@@ -579,12 +611,18 @@ export type OpenAIResponsesTool =
           }
         | undefined;
       model: string | undefined;
-      moderation: 'auto' | undefined;
+      moderation: 'auto' | 'low' | undefined;
       output_compression: number | undefined;
       output_format: 'png' | 'jpeg' | 'webp' | undefined;
       partial_images: number | undefined;
       quality: 'auto' | 'low' | 'medium' | 'high' | undefined;
-      size: 'auto' | '1024x1024' | '1024x1536' | '1536x1024' | undefined;
+      size:
+        | 'auto'
+        | '1024x1024'
+        | '1024x1536'
+        | '1536x1024'
+        | (string & {})
+        | undefined;
     }
 
   /**
@@ -831,26 +869,7 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
         type: z.enum(['response.completed', 'response.incomplete']),
         response: z.object({
           incomplete_details: z.object({ reason: z.string() }).nullish(),
-          usage: z
-            .object({
-              input_tokens: z.number(),
-              input_tokens_details: z
-                .object({
-                  cached_tokens: z.number().nullish(),
-                  cache_write_tokens: z.number().nullish(),
-                  orchestration_input_tokens: z.number().nullish(),
-                  orchestration_input_cached_tokens: z.number().nullish(),
-                })
-                .nullish(),
-              output_tokens: z.number(),
-              output_tokens_details: z
-                .object({
-                  reasoning_tokens: z.number().nullish(),
-                  orchestration_output_tokens: z.number().nullish(),
-                })
-                .nullish(),
-            })
-            .nullish(),
+          usage: openaiResponsesUsageSchema.nullish(),
           reasoning: z
             .object({
               context: z.string().nullish(),
@@ -870,26 +889,7 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
             })
             .nullish(),
           incomplete_details: z.object({ reason: z.string() }).nullish(),
-          usage: z
-            .object({
-              input_tokens: z.number(),
-              input_tokens_details: z
-                .object({
-                  cached_tokens: z.number().nullish(),
-                  cache_write_tokens: z.number().nullish(),
-                  orchestration_input_tokens: z.number().nullish(),
-                  orchestration_input_cached_tokens: z.number().nullish(),
-                })
-                .nullish(),
-              output_tokens: z.number(),
-              output_tokens_details: z
-                .object({
-                  reasoning_tokens: z.number().nullish(),
-                  orchestration_output_tokens: z.number().nullish(),
-                })
-                .nullish(),
-            })
-            .nullish(),
+          usage: openaiResponsesUsageSchema.nullish(),
           reasoning: z
             .object({
               context: z.string().nullish(),
@@ -1745,26 +1745,7 @@ export const openaiResponsesResponseSchema = lazySchema(() =>
         })
         .nullish(),
       incomplete_details: z.object({ reason: z.string() }).nullish(),
-      usage: z
-        .object({
-          input_tokens: z.number(),
-          input_tokens_details: z
-            .object({
-              cached_tokens: z.number().nullish(),
-              cache_write_tokens: z.number().nullish(),
-              orchestration_input_tokens: z.number().nullish(),
-              orchestration_input_cached_tokens: z.number().nullish(),
-            })
-            .nullish(),
-          output_tokens: z.number(),
-          output_tokens_details: z
-            .object({
-              reasoning_tokens: z.number().nullish(),
-              orchestration_output_tokens: z.number().nullish(),
-            })
-            .nullish(),
-        })
-        .nullish(),
+      usage: openaiResponsesUsageSchema.nullish(),
     }),
   ),
 );

package/src/responses/openai-responses-language-model-options.ts

@@ -294,11 +294,12 @@ export const openaiLanguageModelResponsesOptionsSchema = lazySchema(() =>
        * Set to 'flex' for 50% cheaper processing at the cost of increased latency (available for o3, o4-mini, and gpt-5 models).
        * Set to 'priority' for faster processing with Enterprise access (available for gpt-4, gpt-5, gpt-5-mini, o3, o4-mini; gpt-5-nano is not supported).
        * Set to 'fast' for the same tier as 'priority' (OpenAI's newer name for it).
+       * Set to 'ultrafast' for access-controlled Ultrafast processing (available only for gpt-5.6-sol).
        *
        * Defaults to 'auto'.
        */
       serviceTier: z
-        .enum(['auto', 'flex', 'priority', 'fast', 'default'])
+        .enum(['auto', 'flex', 'priority', 'fast', 'ultrafast', 'default'])
         .nullish(),
 
       /**

package/src/responses/openai-responses-prepare-tools.ts

@@ -302,6 +302,7 @@ export async function prepareResponsesTools({
 
             openaiTools.push({
               type: 'image_generation',
+              action: args.action,
               background: args.background,
               input_fidelity: args.inputFidelity,
               input_image_mask: args.inputImageMask

package/src/tool/image-generation.ts

@@ -9,6 +9,7 @@ export const imageGenerationArgsSchema = lazySchema(() =>
   zodSchema(
     z
       .object({
+        action: z.enum(['generate', 'edit', 'auto']).optional(),
         background: z.enum(['auto', 'opaque', 'transparent']).optional(),
         inputFidelity: z.enum(['low', 'high']).optional(),
         inputImageMask: z
@@ -18,13 +19,16 @@ export const imageGenerationArgsSchema = lazySchema(() =>
           })
           .optional(),
         model: z.string().optional(),
-        moderation: z.enum(['auto']).optional(),
+        moderation: z.enum(['auto', 'low']).optional(),
         outputCompression: z.number().int().min(0).max(100).optional(),
         outputFormat: z.enum(['png', 'jpeg', 'webp']).optional(),
         partialImages: z.number().int().min(0).max(3).optional(),
         quality: z.enum(['auto', 'low', 'medium', 'high']).optional(),
         size: z
-          .enum(['1024x1024', '1024x1536', '1536x1024', 'auto'])
+          .union([
+            z.enum(['1024x1024', '1024x1536', '1536x1024', 'auto']),
+            z.string().regex(/^\d+x\d+$/),
+          ])
           .optional(),
       })
       .strict(),
@@ -38,6 +42,11 @@ export const imageGenerationOutputSchema = lazySchema(() =>
 );
 
 type ImageGenerationArgs = {
+  /**
+   * Whether to generate a new image or edit an existing image. Default: auto.
+   */
+  action?: 'generate' | 'edit' | 'auto';
+
   /**
    * Background type for the generated image. Default is 'auto'.
    */
@@ -70,9 +79,9 @@ type ImageGenerationArgs = {
   model?: string;
 
   /**
-   * Moderation level for the generated image. Default: auto.
+   * Moderation level for the generated image. One of auto or low. Default: auto.
    */
-  moderation?: 'auto';
+  moderation?: 'auto' | 'low';
 
   /**
    * Compression level for the output image. Default: 100.
@@ -98,10 +107,11 @@ type ImageGenerationArgs = {
 
   /**
    * The size of the generated image.
-   * One of 1024x1024, 1024x1536, 1536x1024, or auto.
+   * One of 1024x1024, 1024x1536, 1536x1024, or auto. gpt-image-2 also accepts
+   * arbitrary WIDTHxHEIGHT sizes where both are divisible by 16, e.g. 1536x864.
    * Default: auto.
    */
-  size?: 'auto' | '1024x1024' | '1024x1536' | '1536x1024';
+  size?: 'auto' | '1024x1024' | '1024x1536' | '1536x1024' | (string & {});
 };
 
 const imageGenerationToolFactory = createProviderExecutedToolFactory<