@ai-sdk/openai 4.0.0-beta.6 → 4.0.0-beta.74

package/src/files/openai-files.ts

@@ -0,0 +1,100 @@
+import type {
+  FilesV4,
+  FilesV4UploadFileCallOptions,
+  FilesV4UploadFileResult,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertInlineFileDataToUint8Array,
+  createJsonResponseHandler,
+  parseProviderOptions,
+  postFormDataToApi,
+  type FetchFunction,
+} from '@ai-sdk/provider-utils';
+import { openaiFailedResponseHandler } from '../openai-error';
+import { openaiFilesResponseSchema } from './openai-files-api';
+import {
+  openaiFilesOptionsSchema,
+  type OpenAIFilesOptions,
+} from './openai-files-options';
+interface OpenAIFilesConfig {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+}
+
+export class OpenAIFiles implements FilesV4 {
+  readonly specificationVersion = 'v4';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(private readonly config: OpenAIFilesConfig) {}
+
+  async uploadFile({
+    data,
+    mediaType,
+    filename,
+    providerOptions,
+  }: FilesV4UploadFileCallOptions): Promise<FilesV4UploadFileResult> {
+    const openaiOptions = (await parseProviderOptions({
+      provider: 'openai',
+      providerOptions,
+      schema: openaiFilesOptionsSchema,
+    })) as OpenAIFilesOptions | undefined;
+
+    const fileBytes = convertInlineFileDataToUint8Array(data);
+
+    const blob = new Blob([fileBytes], {
+      type: mediaType,
+    });
+
+    const formData = new FormData();
+    if (filename != null) {
+      formData.append('file', blob, filename);
+    } else {
+      formData.append('file', blob);
+    }
+    formData.append('purpose', openaiOptions?.purpose ?? 'assistants');
+
+    if (openaiOptions?.expiresAfter != null) {
+      formData.append('expires_after', String(openaiOptions.expiresAfter));
+    }
+
+    const { value: response } = await postFormDataToApi({
+      url: `${this.config.baseURL}/files`,
+      headers: combineHeaders(this.config.headers()),
+      formData,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiFilesResponseSchema,
+      ),
+      fetch: this.config.fetch,
+    });
+
+    return {
+      warnings: [],
+      providerReference: { openai: response.id },
+      ...((response.filename ?? filename)
+        ? { filename: response.filename ?? filename }
+        : {}),
+      ...(mediaType != null ? { mediaType } : {}),
+      providerMetadata: {
+        openai: {
+          ...(response.filename != null ? { filename: response.filename } : {}),
+          ...(response.purpose != null ? { purpose: response.purpose } : {}),
+          ...(response.bytes != null ? { bytes: response.bytes } : {}),
+          ...(response.created_at != null
+            ? { createdAt: response.created_at }
+            : {}),
+          ...(response.status != null ? { status: response.status } : {}),
+          ...(response.expires_at != null
+            ? { expiresAt: response.expires_at }
+            : {}),
+        },
+      },
+    };
+  }
+}

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

@@ -0,0 +1,123 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export type OpenAIImageModelId =
+  | 'dall-e-3'
+  | 'dall-e-2'
+  | 'gpt-image-1'
+  | 'gpt-image-1-mini'
+  | 'gpt-image-1.5'
+  | 'gpt-image-2'
+  | 'chatgpt-image-latest'
+  | (string & {});
+
+// https://platform.openai.com/docs/guides/images
+export const modelMaxImagesPerCall: Record<OpenAIImageModelId, number> = {
+  'dall-e-3': 1,
+  'dall-e-2': 10,
+  'gpt-image-1': 10,
+  'gpt-image-1-mini': 10,
+  'gpt-image-1.5': 10,
+  'gpt-image-2': 10,
+  'chatgpt-image-latest': 10,
+};
+
+const defaultResponseFormatPrefixes = [
+  'chatgpt-image-',
+  'gpt-image-1-mini',
+  'gpt-image-1.5',
+  'gpt-image-1',
+  'gpt-image-2',
+];
+
+export function hasDefaultResponseFormat(modelId: string): boolean {
+  return defaultResponseFormatPrefixes.some(prefix =>
+    modelId.startsWith(prefix),
+  );
+}
+
+const baseImageModelOptionsObject = z.object({
+  /**
+   * Quality of the generated image(s).
+   *
+   * Valid values: `standard`, `hd`, `low`, `medium`, `high`, `auto`.
+   */
+  quality: z
+    .enum(['standard', 'hd', 'low', 'medium', 'high', 'auto'])
+    .optional(),
+
+  /**
+   * Background behavior for the generated image(s).
+   *
+   * If `transparent`, the output format must support transparency
+   * (i.e. `png` or `webp`).
+   */
+  background: z.enum(['transparent', 'opaque', 'auto']).optional(),
+
+  /**
+   * Format in which the generated image(s) are returned.
+   */
+  outputFormat: z.enum(['png', 'jpeg', 'webp']).optional(),
+
+  /**
+   * Compression level (0-100) for the generated image(s). Applies to the
+   * `jpeg` and `webp` output formats.
+   */
+  outputCompression: z.number().int().min(0).max(100).optional(),
+
+  /**
+   * A unique identifier representing your end-user, which can help OpenAI
+   * to monitor and detect abuse.
+   */
+  user: z.string().optional(),
+});
+
+export const openaiImageModelOptions = lazySchema(() =>
+  zodSchema(baseImageModelOptionsObject),
+);
+
+export type OpenAIImageModelOptions = InferSchema<
+  typeof openaiImageModelOptions
+>;
+
+export const openaiImageModelGenerationOptions = lazySchema(() =>
+  zodSchema(
+    baseImageModelOptionsObject.extend({
+      /**
+       * Style of the generated image. `vivid` produces hyper-real and
+       * dramatic images; `natural` produces more subdued, less hyper-real
+       * looking images.
+       */
+      style: z.enum(['vivid', 'natural']).optional(),
+
+      /**
+       * Content moderation level for the generated image(s). `low` applies
+       * less restrictive filtering.
+       */
+      moderation: z.enum(['auto', 'low']).optional(),
+    }),
+  ),
+);
+
+export type OpenAIImageModelGenerationOptions = InferSchema<
+  typeof openaiImageModelGenerationOptions
+>;
+
+export const openaiImageModelEditOptions = lazySchema(() =>
+  zodSchema(
+    baseImageModelOptionsObject.extend({
+      /**
+       * Fidelity of the output image(s) to the input image(s).
+       */
+      inputFidelity: z.enum(['high', 'low']).optional(),
+    }),
+  ),
+);
+
+export type OpenAIImageModelEditOptions = InferSchema<
+  typeof openaiImageModelEditOptions
+>;

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

@@ -1,4 +1,4 @@
-import {
+import type {
   ImageModelV4,
   ImageModelV4File,
   SharedV4Warning,
@@ -9,18 +9,24 @@ import {
   convertToFormData,
   createJsonResponseHandler,
   downloadBlob,
+  parseProviderOptions,
   postFormDataToApi,
   postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE,
 } from '@ai-sdk/provider-utils';
-import { OpenAIConfig } from '../openai-config';
+import type { OpenAIConfig } from '../openai-config';
 import { openaiFailedResponseHandler } from '../openai-error';
 import { openaiImageResponseSchema } from './openai-image-api';
 import {
-  OpenAIImageModelId,
   hasDefaultResponseFormat,
   modelMaxImagesPerCall,
-} from './openai-image-options';
-
+  openaiImageModelEditOptions,
+  openaiImageModelGenerationOptions,
+  type OpenAIImageModelEditOptions,
+  type OpenAIImageModelId,
+} from './openai-image-model-options';
 interface OpenAIImageModelConfig extends OpenAIConfig {
   _internal?: {
     currentDate?: () => Date;
@@ -30,6 +36,20 @@ interface OpenAIImageModelConfig extends OpenAIConfig {
 export class OpenAIImageModel implements ImageModelV4 {
   readonly specificationVersion = 'v4';
 
+  static [WORKFLOW_SERIALIZE](model: OpenAIImageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: OpenAIImageModelId;
+    config: OpenAIImageModelConfig;
+  }) {
+    return new OpenAIImageModel(options.modelId, options.config);
+  }
+
   get maxImagesPerCall(): number {
     return modelMaxImagesPerCall[this.modelId] ?? 1;
   }
@@ -75,12 +95,19 @@ export class OpenAIImageModel implements ImageModelV4 {
     const currentDate = this.config._internal?.currentDate?.() ?? new Date();
 
     if (files != null) {
+      const openaiOptions =
+        (await parseProviderOptions({
+          provider: 'openai',
+          providerOptions,
+          schema: openaiImageModelEditOptions,
+        })) ?? {};
+
       const { value: response, responseHeaders } = await postFormDataToApi({
         url: this.config.url({
           path: '/images/edits',
           modelId: this.modelId,
         }),
-        headers: combineHeaders(this.config.headers(), headers),
+        headers: combineHeaders(this.config.headers?.(), headers),
         formData: convertToFormData<OpenAIImageEditInput>({
           model: this.modelId,
           prompt,
@@ -105,7 +132,12 @@ export class OpenAIImageModel implements ImageModelV4 {
           mask: mask != null ? await fileToBlob(mask) : undefined,
           n,
           size,
-          ...(providerOptions.openai ?? {}),
+          quality: openaiOptions.quality,
+          background: openaiOptions.background,
+          output_format: openaiOptions.outputFormat,
+          output_compression: openaiOptions.outputCompression,
+          input_fidelity: openaiOptions.inputFidelity,
+          user: openaiOptions.user,
         }),
         failedResponseHandler: openaiFailedResponseHandler,
         successfulResponseHandler: createJsonResponseHandler(
@@ -153,18 +185,31 @@ export class OpenAIImageModel implements ImageModelV4 {
       };
     }
 
+    const openaiOptions =
+      (await parseProviderOptions({
+        provider: 'openai',
+        providerOptions,
+        schema: openaiImageModelGenerationOptions,
+      })) ?? {};
+
     const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: '/images/generations',
         modelId: this.modelId,
       }),
-      headers: combineHeaders(this.config.headers(), headers),
+      headers: combineHeaders(this.config.headers?.(), headers),
       body: {
         model: this.modelId,
         prompt,
         n,
         size,
-        ...(providerOptions.openai ?? {}),
+        quality: openaiOptions.quality,
+        style: openaiOptions.style,
+        background: openaiOptions.background,
+        moderation: openaiOptions.moderation,
+        output_format: openaiOptions.outputFormat,
+        output_compression: openaiOptions.outputCompression,
+        user: openaiOptions.user,
         ...(!hasDefaultResponseFormat(this.modelId)
           ? { response_format: 'b64_json' }
           : {}),
@@ -251,84 +296,18 @@ function distributeTokenDetails(
 }
 
 type OpenAIImageEditInput = {
-  /**
-   * Allows to set transparency for the background of the generated image(s).
-   * This parameter is only supported for `gpt-image-1`. Must be one of
-   * `transparent`, `opaque` or `auto` (default value). When `auto` is used, the
-   * model will automatically determine the best background for the image.
-   *
-   * If `transparent`, the output format needs to support transparency, so it
-   * should be set to either `png` (default value) or `webp`.
-   *
-   */
-  background?: 'transparent' | 'opaque' | 'auto';
-  /**
-   * The image(s) to edit. Must be a supported image file or an array of images.
-   *
-   * For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less
-   * than 50MB. You can provide up to 16 images.
-   *
-   * For `dall-e-2`, you can only provide one image, and it should be a square
-   * `png` file less than 4MB.
-   *
-   */
+  model: OpenAIImageModelId;
+  prompt?: string;
   image: Blob | Blob[];
-  input_fidelity?: ('high' | 'low') | null;
-  /**
-   * An additional image whose fully transparent areas (e.g. where alpha is zero) indicate where `image` should be edited. If there are multiple images provided, the mask will be applied on the first image. Must be a valid PNG file, less than 4MB, and have the same dimensions as `image`.
-   */
   mask?: Blob;
-  /**
-   * The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1` is used.
-   */
-  model?: 'dall-e-2' | 'gpt-image-1' | 'gpt-image-1-mini' | (string & {});
-  /**
-   * The number of images to generate. Must be between 1 and 10.
-   */
   n?: number;
-  /**
-   * The compression level (0-100%) for the generated images. This parameter
-   * is only supported for `gpt-image-1` with the `webp` or `jpeg` output
-   * formats, and defaults to 100.
-   *
-   */
-  output_compression?: number;
-  /**
-   * The format in which the generated images are returned. This parameter is
-   * only supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
-   * The default value is `png`.
-   *
-   */
-  output_format?: 'png' | 'jpeg' | 'webp';
-  partial_images?: number | null;
-  /**
-   * A text description of the desired image(s). The maximum length is 1000 characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
-   */
-  prompt?: string;
-  /**
-   * The quality of the image that will be generated. `high`, `medium` and `low` are only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality. Defaults to `auto`.
-   *
-   */
-  quality?: 'standard' | 'low' | 'medium' | 'high' | 'auto';
-  /**
-   * The format in which the generated images are returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes after the image has been generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1` will always return base64-encoded images.
-   */
-  response_format?: 'url' | 'b64_json';
-  /**
-   * The size of the generated images. Must be one of `1024x1024`, `1536x1024` (landscape), `1024x1536` (portrait), or `auto` (default value) for `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
-   */
   size?: `${number}x${number}`;
-  /**
-   * Edit the image in streaming mode. Defaults to `false`. See the
-   * [Image generation guide](https://platform.openai.com/docs/guides/image-generation) for more information.
-   *
-   */
-  stream?: boolean;
-  /**
-   * A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse. [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
-   *
-   */
-  user?: string;
+  quality?: OpenAIImageModelEditOptions['quality'];
+  background?: OpenAIImageModelEditOptions['background'];
+  output_format?: OpenAIImageModelEditOptions['outputFormat'];
+  output_compression?: OpenAIImageModelEditOptions['outputCompression'];
+  input_fidelity?: OpenAIImageModelEditOptions['inputFidelity'];
+  user?: OpenAIImageModelEditOptions['user'];
 };
 
 async function fileToBlob(

package/src/index.ts

@@ -1,20 +1,29 @@
 export { createOpenAI, openai } from './openai-provider';
 export type { OpenAIProvider, OpenAIProviderSettings } from './openai-provider';
+export { OpenAIRealtimeModel as Experimental_OpenAIRealtimeModel } from './realtime/openai-realtime-model';
+export type { OpenAIRealtimeModelConfig as Experimental_OpenAIRealtimeModelConfig } from './realtime/openai-realtime-model';
 export type {
   OpenAILanguageModelResponsesOptions,
   /** @deprecated Use `OpenAILanguageModelResponsesOptions` instead. */
   OpenAILanguageModelResponsesOptions as OpenAIResponsesProviderOptions,
-} from './responses/openai-responses-options';
+} from './responses/openai-responses-language-model-options';
 export type {
   OpenAILanguageModelChatOptions,
   /** @deprecated Use `OpenAILanguageModelChatOptions` instead. */
   OpenAILanguageModelChatOptions as OpenAIChatLanguageModelOptions,
-} from './chat/openai-chat-options';
-export type { OpenAILanguageModelCompletionOptions } from './completion/openai-completion-options';
-export type { OpenAIEmbeddingModelOptions } from './embedding/openai-embedding-options';
-export type { OpenAISpeechModelOptions } from './speech/openai-speech-options';
-export type { OpenAITranscriptionModelOptions } from './transcription/openai-transcription-options';
+} from './chat/openai-chat-language-model-options';
 export type {
+  OpenAIImageModelOptions,
+  OpenAIImageModelGenerationOptions,
+  OpenAIImageModelEditOptions,
+} from './image/openai-image-model-options';
+export type { OpenAILanguageModelCompletionOptions } from './completion/openai-completion-language-model-options';
+export type { OpenAIEmbeddingModelOptions } from './embedding/openai-embedding-model-options';
+export type { OpenAISpeechModelOptions } from './speech/openai-speech-model-options';
+export type { OpenAITranscriptionModelOptions } from './transcription/openai-transcription-model-options';
+export type { OpenAIFilesOptions } from './files/openai-files-options';
+export type {
+  OpenaiResponsesCompactionProviderMetadata,
   OpenaiResponsesProviderMetadata,
   OpenaiResponsesReasoningProviderMetadata,
   OpenaiResponsesTextProviderMetadata,

package/src/internal/index.ts

@@ -1,19 +1,20 @@
 export * from '../chat/openai-chat-language-model';
-export * from '../chat/openai-chat-options';
+export * from '../chat/openai-chat-language-model-options';
 export * from '../completion/openai-completion-language-model';
-export * from '../completion/openai-completion-options';
+export * from '../completion/openai-completion-language-model-options';
 export * from '../embedding/openai-embedding-model';
-export * from '../embedding/openai-embedding-options';
+export * from '../embedding/openai-embedding-model-options';
 export * from '../image/openai-image-model';
-export * from '../image/openai-image-options';
+export * from '../image/openai-image-model-options';
 export * from '../transcription/openai-transcription-model';
-export * from '../transcription/openai-transcription-options';
+export * from '../transcription/openai-transcription-model-options';
 export * from '../speech/openai-speech-model';
-export * from '../speech/openai-speech-options';
+export * from '../speech/openai-speech-model-options';
 export * from '../responses/openai-responses-language-model';
 export * from '../responses/openai-responses-provider-metadata';
 export * from '../tool/apply-patch';
 export * from '../tool/code-interpreter';
 export * from '../tool/file-search';
 export * from '../tool/image-generation';
+export * from '../tool/web-search';
 export * from '../tool/web-search-preview';

package/src/openai-config.ts

@@ -1,18 +1,18 @@
-import { FetchFunction } from '@ai-sdk/provider-utils';
+import type { FetchFunction } from '@ai-sdk/provider-utils';
 
 export type OpenAIConfig = {
   provider: string;
   url: (options: { modelId: string; path: string }) => string;
-  headers: () => Record<string, string | undefined>;
+  headers?: () => Record<string, string | undefined>;
   fetch?: FetchFunction;
   generateId?: () => string;
   /**
-   * File ID prefixes used to identify file IDs in Responses API.
-   * When undefined, all file data is treated as base64 content.
+   * This is soft-deprecated. Use provider references (e.g. `{ openai: 'file-abc123' }`)
+   * in file part data instead. File ID prefixes used to identify file IDs
+   * in Responses API. When undefined, all string file data is treated as
+   * base64 content.
    *
-   * Examples:
-   * - OpenAI: ['file-'] for IDs like 'file-abc123'
-   * - Azure OpenAI: ['assistant-'] for IDs like 'assistant-abc123'
+   * TODO: remove in v8
    */
   fileIdPrefixes?: readonly string[];
 };

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

@@ -20,10 +20,10 @@ export function getOpenAILanguageModelCapabilities(
 
   const supportsPriorityProcessing =
     modelId.startsWith('gpt-4') ||
-    modelId.startsWith('gpt-5-mini') ||
     (modelId.startsWith('gpt-5') &&
       !modelId.startsWith('gpt-5-nano') &&
-      !modelId.startsWith('gpt-5-chat')) ||
+      !modelId.startsWith('gpt-5-chat') &&
+      !modelId.startsWith('gpt-5.4-nano')) ||
     modelId.startsWith('o3') ||
     modelId.startsWith('o4-mini');
 
@@ -36,12 +36,13 @@ export function getOpenAILanguageModelCapabilities(
     (modelId.startsWith('gpt-5') && !modelId.startsWith('gpt-5-chat'));
 
   // https://platform.openai.com/docs/guides/latest-model#gpt-5-1-parameter-compatibility
-  // GPT-5.1, GPT-5.2, and GPT-5.4 support temperature, topP, logProbs when reasoningEffort is none
+  // GPT-5.1 and later model families support temperature, topP, logProbs when reasoningEffort is none.
   const supportsNonReasoningParameters =
     modelId.startsWith('gpt-5.1') ||
     modelId.startsWith('gpt-5.2') ||
     modelId.startsWith('gpt-5.3') ||
-    modelId.startsWith('gpt-5.4');
+    modelId.startsWith('gpt-5.4') ||
+    modelId.startsWith('gpt-5.5');
 
   const systemMessageMode = isReasoningModel ? 'developer' : 'system';