@ai-sdk/openai 4.0.107 → 4.0.109

package/docs/03-openai.mdx

@@ -1005,7 +1005,20 @@ const result = await generateText({
 
 The code interpreter tool can be configured with:
 
-- **container**: Either a container ID string or an object with `fileIds` to specify uploaded files that should be available to the code interpreter
+- **container**: Either:
+  - a container ID (`string`) to reuse an existing container, or
+  - a configuration `object` to create and configure a new container.
+
+- **container configuration object**
+  - **fileIds** _string[]_ — File IDs to make available in the container at startup
+  - **memoryLimit** _'1g' | '4g' | '16g' | '64g'_ — Memory limit for the container
+  - **networkPolicy** — Network access policy for outbound requests:
+    - `{ type: 'disabled' }` — No outbound network access
+    - `{ type: 'allowlist', allowedDomains: string[], domainSecrets?: Array<{ domain, name, value }> }`
+      — Allow outbound access only to the specified domains, with optional per-domain secrets
+
+The organization's hosted tool settings must permit the requested network policy.
+An allowlist request cannot enable networking when the organization disables it.
 
 <Note>
   When working with files generated by the Code Interpreter, reference
@@ -1016,7 +1029,7 @@ The code interpreter tool can be configured with:
 
 #### MCP Tool
 
-The OpenAI responses API supports connecting to [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) servers through the `openai.tools.mcp` tool. This allows models to call tools exposed by remote MCP servers or service connectors.
+The OpenAI responses API supports connecting to [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) servers through the `openai.tools.mcp` tool. This allows models to call tools exposed by remote MCP servers, service connectors, or [Secure MCP tunnels](https://developers.openai.com/api/docs/guides/secure-mcp-tunnels).
 
 ```ts
 import { openai } from '@ai-sdk/openai';
@@ -1035,19 +1048,47 @@ const result = await generateText({
 });
 ```
 
+For a private MCP server exposed through an OpenAI Secure MCP tunnel, provide
+its tunnel ID instead of a server URL or connector ID. First configure the tunnel
+in OpenAI and run its tunnel client against your MCP server. The SDK uses the
+existing tunnel; it does not create or discover one:
+
+```ts
+const result = await generateText({
+  model: openai.responses('gpt-5-mini'),
+  prompt: 'Search the private knowledge base',
+  tools: {
+    mcp: openai.tools.mcp({
+      serverLabel: 'private-knowledge',
+      tunnelId: 'tunnel_0123456789abcdef0123456789abcdef',
+      serverDescription: 'A private knowledge base',
+      allowedTools: { readOnly: true },
+      requireApproval: 'always',
+    }),
+  },
+});
+```
+
+When reading a tunnel ID from an environment variable, check that it is defined
+before passing it to `tunnelId`, which requires a string.
+
 The MCP tool can be configured with:
 
 - **serverLabel** _string_ (required)
 
   A label to identify the MCP server. This label is used in tool calls to distinguish between multiple MCP servers.
 
-- **serverUrl** _string_ (required if `connectorId` is not provided)
+- **serverUrl** _string_ (required if `connectorId` and `tunnelId` are not provided)
+
+  The URL for the MCP server. Cannot be combined with `tunnelId`.
+
+- **connectorId** _string_ (required if `serverUrl` and `tunnelId` are not provided)
 
-  The URL for the MCP server. Either `serverUrl` or `connectorId` must be provided.
+  Identifier for a service connector. Cannot be combined with `tunnelId`.
 
-- **connectorId** _string_ (required if `serverUrl` is not provided)
+- **tunnelId** _string_ (required if `serverUrl` and `connectorId` are not provided)
 
-  Identifier for a service connector. Either `serverUrl` or `connectorId` must be provided.
+  Identifier for a configured OpenAI Secure MCP tunnel. Cannot be combined with `serverUrl` or `connectorId`. At least one target must be provided; existing URL and connector configurations remain compatible.
 
 - **serverDescription** _string_ (optional)
 
@@ -1067,7 +1108,7 @@ The MCP tool can be configured with:
 
 - **authorization** _string_ (optional)
 
-  OAuth access token for authenticating with the MCP server or connector.
+  OAuth access token for authenticating with the MCP server or connector (including tunneled servers).
 
 - **headers** _Record&lt;string, string&gt;_ (optional)
 
@@ -2501,6 +2542,49 @@ The following optional provider options are available for OpenAI chat models:
 
   Force treating this model as a reasoning model. This is useful for "stealth" reasoning models (e.g. via a custom baseURL) where the model ID is not recognized by the SDK's allowlist. When enabled, the SDK applies reasoning-model parameter compatibility rules and defaults `systemMessageMode` to `developer` unless overridden.
 
+#### Message Names
+
+Chat Completions accepts an optional participant name on each system, developer,
+user, or assistant message. Set `providerOptions.openai.name` on the message to
+help the model distinguish participants with the same role. Use pseudonyms instead
+of personal identifiers when possible; names are sent to the provider with the
+message.
+
+```ts
+import { openai, type OpenAIChatMessageProviderOptions } from '@ai-sdk/openai';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: openai.chat('gpt-4.1-mini'),
+  messages: [
+    {
+      role: 'user',
+      content: 'My favorite color is blue.',
+      providerOptions: {
+        openai: { name: 'alice' } satisfies OpenAIChatMessageProviderOptions,
+      },
+    },
+    {
+      role: 'user',
+      content: 'My favorite color is green. What are our favorite colors?',
+      providerOptions: {
+        openai: { name: 'bob' } satisfies OpenAIChatMessageProviderOptions,
+      },
+    },
+  ],
+});
+```
+
+Names also work with `streamText`. Configure them on the message, rather than on
+individual content parts or in the call-level provider options. Non-string values
+are rejected during provider option validation. Tool messages do not support
+participant names: a configured name is omitted with an `unsupported` warning.
+
+This option applies to Chat Completions through `openai.chat()`, including Azure
+Chat models using `providerOptions.openai.name`. The default OpenAI Responses
+model does not support message names. A name identifies a conversation participant;
+it is separate from the call-level `user` and `safetyIdentifier` options.
+
 #### Reasoning
 
 OpenAI has introduced the `o1`,`o3`, and `o4` series of [reasoning models](https://platform.openai.com/docs/guides/reasoning).
@@ -3164,6 +3248,8 @@ is supported.
 
 ## Realtime Models
 
+OpenAI Realtime also supports trusted [server-owned connections](/docs/ai-sdk-core/realtime#server-owned-connections) through `getServerWebSocketConfig({ intent })`, with conversation and transcription intents and normalized completion usage. Use the same intent for connection setup and event serialization. OpenAI Live retains its conversation-only server connection API and duration snapshots.
+
 <Note type="warning">Realtime is an experimental feature.</Note>
 
 Use `.experimental_realtime()` for both [OpenAI Realtime](https://platform.openai.com/docs/guides/realtime)
@@ -3422,6 +3508,31 @@ const { images } = await generateImage({
 });
 ```
 
+#### Moderation
+
+GPT Image models accept a `moderation` level on edits as well as on generations. The default, `auto`, is the standard filtering; `low` applies less restrictive filtering:
+
+```ts
+import { readFileSync } from 'node:fs';
+import { openai, type OpenAIImageModelEditOptions } from '@ai-sdk/openai';
+import { generateImage } from 'ai';
+
+const imageBuffer = readFileSync('./input-image.png');
+
+const { images } = await generateImage({
+  model: openai.image('gpt-image-2.5-flare'),
+  prompt: {
+    text: 'Draw the same scene at dusk',
+    images: [imageBuffer],
+  },
+  providerOptions: {
+    openai: {
+      moderation: 'low',
+    } satisfies OpenAIImageModelEditOptions,
+  },
+});
+```
+
 #### Multi-Image Combining
 
 Combine multiple reference images into a single output. `gpt-image-*` models support up to 16 input images:
@@ -3453,6 +3564,8 @@ const { images } = await generateImage({
 
 | Model                    | Sizes                                  |
 | ------------------------ | -------------------------------------- |
+| `gpt-image-2.6-flare`    | Standard presets and custom dimensions |
+| `gpt-image-2.6-sunburst` | Standard presets and custom dimensions |
 | `gpt-image-2.5-flare`    | Standard presets and custom dimensions |
 | `gpt-image-2.5-sunburst` | Standard presets and custom dimensions |
 | `gpt-image-2`            | 1024x1024, 1536x1024, 1024x1536        |
@@ -3499,6 +3612,28 @@ const { image } = await generateImage({
 });
 ```
 
+The `gpt-image-2.6-flare` and `gpt-image-2.6-sunburst` models support these additional options:
+
+- **complexity** _'low' | 'medium' | 'high'_ - how much detail the model puts into the image (generation and editing). The API defaults to `high`.
+- **outputFormat: 'gif'** _(generation only)_ - generates an animated GIF. Use **frameCount** (2-64, API default 9) and **frameDurationMs** (20-2000, API default 200) to control the animation.
+- **markup** _string_ _(editing only)_ - a transparent PNG (HTTPS URL or base64 data URL) overlaid on the first input image to mark up the regions to change. Supported by `gpt-image-2.5-*` and `gpt-image-2.6-*` models. It cannot be combined with `mask`; providing both throws an error.
+
+```ts
+const { image } = await generateImage({
+  model: openai.image('gpt-image-2.6-flare'),
+  prompt: 'A red panda waving hello, flat illustration',
+  providerOptions: {
+    openai: {
+      outputFormat: 'gif',
+      frameCount: 9,
+      frameDurationMs: 200,
+    } satisfies OpenAIImageModelGenerationOptions,
+  },
+});
+```
+
+All image options also accept `safetyIdentifier` (max 128 characters) to help OpenAI detect abuse by your end users.
+
 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
@@ -3569,27 +3704,30 @@ The API validates model support and language codes. These two options currently
 apply to REST transcription; the provider reports unsupported-option warnings
 if they are supplied to `experimental_streamTranscribe`.
 
-To get word-level timestamps, specify the granularity:
+To get word and caption timings together, use the shared setting with a
+model that supports `verbose_json`, such as Whisper:
 
-```ts highlight="8-9"
+```ts
 import { transcribe } from 'ai';
-import { openai, type OpenAITranscriptionModelOptions } from '@ai-sdk/openai';
+import { openai } from '@ai-sdk/openai';
 
 const result = await transcribe({
   model: openai.transcription('whisper-1'),
   audio: new Uint8Array([1, 2, 3, 4]),
-  providerOptions: {
-    openai: {
-      //timestampGranularities: ['word'],
-      timestampGranularities: ['segment'],
-    } satisfies OpenAITranscriptionModelOptions,
-  },
+  timestampGranularities: ['word', 'segment'],
 });
 
-// Access word-level timestamps
-console.log(result.segments); // Array of segments with startSecond/endSecond
+console.log(result.words);
+console.log(result.segments);
 ```
 
+`providerOptions.openai.timestampGranularities` takes precedence over the shared
+setting. If neither is set, `verbose_json` defaults to segment timings.
+`timestamp_granularities` is sent only for `verbose_json`; other formats warn
+about unavailable requested timings. `diarized_json` provides segment timings
+but does not provide word timings. Existing segment behavior is preserved:
+if the response has words but no segments, `segments` also contains those words.
+
 `gpt-4o-transcribe-diarize` identifies speakers in a recording. It defaults to
 the `diarized_json` response format and automatic chunking:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.107",
+  "version": "4.0.109",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.35",
-    "@ai-sdk/provider-utils": "5.0.73"
+    "@ai-sdk/provider": "4.0.36",
+    "@ai-sdk/provider-utils": "5.0.75"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.4",

package/src/chat/convert-to-openai-chat-messages.ts

@@ -6,6 +6,7 @@ import {
 } from '@ai-sdk/provider';
 import type { OpenAIChatPrompt } from './openai-chat-prompt';
 import {
+  parseProviderOptions,
   secureJsonParse,
   stringifyWithBigIntAndCycles,
   convertToBase64,
@@ -14,6 +15,8 @@ import {
   resolveProviderReference,
 } from '@ai-sdk/provider-utils';
 
+import { openaiChatMessageProviderOptions } from './openai-chat-language-model-options';
+
 function serializeToolCallArguments(input: unknown): string {
   if (typeof input === 'string') {
     try {
@@ -47,20 +50,27 @@ function getPromptCacheBreakpoint(
     | undefined;
 }
 
-export function convertToOpenAIChatMessages({
+export async function convertToOpenAIChatMessages({
   prompt,
   systemMessageMode = 'system',
 }: {
   prompt: LanguageModelV4Prompt;
   systemMessageMode?: 'system' | 'developer' | 'remove';
-}): {
+}): Promise<{
   messages: OpenAIChatPrompt;
   warnings: Array<SharedV4Warning>;
-} {
+}> {
   const messages: OpenAIChatPrompt = [];
   const warnings: Array<SharedV4Warning> = [];
 
   for (const { role, content, providerOptions } of prompt) {
+    const messageOptions = await parseProviderOptions({
+      provider: 'openai',
+      providerOptions,
+      schema: openaiChatMessageProviderOptions,
+    });
+    const name = messageOptions?.name;
+
     switch (role) {
       case 'system': {
         switch (systemMessageMode) {
@@ -69,6 +79,7 @@ export function convertToOpenAIChatMessages({
               getPromptCacheBreakpoint(providerOptions);
             messages.push({
               role: 'system',
+              ...(name != null && { name }),
               content:
                 promptCacheBreakpoint == null
                   ? content
@@ -87,6 +98,7 @@ export function convertToOpenAIChatMessages({
               getPromptCacheBreakpoint(providerOptions);
             messages.push({
               role: 'developer',
+              ...(name != null && { name }),
               content:
                 promptCacheBreakpoint == null
                   ? content
@@ -123,12 +135,17 @@ export function convertToOpenAIChatMessages({
           content[0].type === 'text' &&
           getPromptCacheBreakpoint(content[0].providerOptions) == null
         ) {
-          messages.push({ role: 'user', content: content[0].text });
+          messages.push({
+            role: 'user',
+            content: content[0].text,
+            ...(name != null && { name }),
+          });
           break;
         }
 
         messages.push({
           role: 'user',
+          ...(name != null && { name }),
           content: content.map((part, index) => {
             switch (part.type) {
               case 'text': {
@@ -311,6 +328,7 @@ export function convertToOpenAIChatMessages({
 
         messages.push({
           role: 'assistant',
+          ...(name != null && { name }),
           content: hasPromptCacheBreakpoint
             ? textParts
             : toolCalls.length > 0
@@ -323,6 +341,13 @@ export function convertToOpenAIChatMessages({
       }
 
       case 'tool': {
+        if (name != null) {
+          warnings.push({
+            type: 'unsupported',
+            feature: 'message name on tool messages',
+          });
+        }
+
         for (const toolResponse of content) {
           if (toolResponse.type === 'tool-approval-response') {
             continue;

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

@@ -232,3 +232,16 @@ export const openaiLanguageModelChatOptions = lazySchema(() =>
 export type OpenAILanguageModelChatOptions = InferSchema<
   typeof openaiLanguageModelChatOptions
 >;
+
+export const openaiChatMessageProviderOptions = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /** The participant name on a system, developer, user, or assistant message. */
+      name: z.string().optional(),
+    }),
+  ),
+);
+
+export type OpenAIChatMessageProviderOptions = InferSchema<
+  typeof openaiChatMessageProviderOptions
+>;

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

@@ -178,16 +178,15 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
       });
     }
 
-    const { messages, warnings: messageWarnings } = convertToOpenAIChatMessages(
-      {
+    const { messages, warnings: messageWarnings } =
+      await convertToOpenAIChatMessages({
         prompt,
         systemMessageMode:
           openaiOptions.systemMessageMode ??
           (isReasoningModel
             ? 'developer'
             : modelRequestConfig.systemMessageMode),
-      },
-    );
+      });
 
     warnings.push(...messageWarnings);
 
@@ -414,16 +413,17 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
     options: LanguageModelV4CallOptions,
   ): Promise<LanguageModelV4GenerateResult> {
     const { args: body, warnings } = await this.getArgs(options);
+    const url = this.config.url({
+      path: '/chat/completions',
+      modelId: this.config.requestModelId ?? this.modelId,
+    });
 
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse,
     } = await postJsonToApi({
-      url: this.config.url({
-        path: '/chat/completions',
-        modelId: this.config.requestModelId ?? this.modelId,
-      }),
+      url,
       headers: combineHeaders(
         await resolve(this.config.headers),
         options.headers,
@@ -499,7 +499,7 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
         raw: choice.finish_reason ?? undefined,
       },
       usage: convertOpenAIChatUsage(response.usage),
-      request: { body },
+      request: { body, url },
       response: {
         ...getResponseMetadata(response),
         headers: responseHeaders,
@@ -705,7 +705,7 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
           },
         }),
       ),
-      request: { body },
+      request: { body, url },
       response: { headers: responseHeaders },
     };
 

package/src/chat/openai-chat-prompt.ts

@@ -8,16 +8,19 @@ export type ChatCompletionMessage =
   | ChatCompletionToolMessage;
 
 export interface ChatCompletionSystemMessage {
+  name?: string;
   role: 'system';
   content: string | Array<ChatCompletionContentPartText>;
 }
 
 export interface ChatCompletionDeveloperMessage {
+  name?: string;
   role: 'developer';
   content: string | Array<ChatCompletionContentPartText>;
 }
 
 export interface ChatCompletionUserMessage {
+  name?: string;
   role: 'user';
   content: string | Array<ChatCompletionContentPart>;
 }
@@ -53,6 +56,7 @@ export interface ChatCompletionContentPartFile {
 }
 
 export interface ChatCompletionAssistantMessage {
+  name?: string;
   role: 'assistant';
   content?: string | null | Array<ChatCompletionContentPartText>;
   tool_calls?: Array<ChatCompletionMessageToolCall>;

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

@@ -16,6 +16,8 @@ export type OpenAIImageModelId =
   | 'gpt-image-1-mini'
   | 'gpt-image-1.5'
   | 'gpt-image-2'
+  | 'gpt-image-2.6-flare'
+  | 'gpt-image-2.6-sunburst'
   | 'gpt-image-2.5-flare'
   | 'gpt-image-2.5-flare-2026-09-08'
   | 'gpt-image-2.5-sunburst'
@@ -64,6 +66,12 @@ const baseImageModelOptionsObject = () =>
      */
     outputFormat: z.enum(['png', 'jpeg', 'webp']).optional(),
 
+    /**
+     * How much detail the model puts into the image. Supported by GPT Image
+     * 2.6 models. The API defaults to `high`.
+     */
+    complexity: z.enum(['low', 'medium', 'high']).optional(),
+
     /**
      * Compression level (0-100) for the generated image(s). Applies to the
      * `jpeg` and `webp` output formats.
@@ -75,6 +83,13 @@ const baseImageModelOptionsObject = () =>
      * to monitor and detect abuse.
      */
     user: z.string().optional(),
+
+    /**
+     * A stable identifier used to help detect users of your application that
+     * may be violating OpenAI's usage policies. Should be a hashed username
+     * or email address.
+     */
+    safetyIdentifier: z.string().max(128).optional(),
   });
 
 export const openaiImageModelOptions = lazySchema(() =>
@@ -95,6 +110,25 @@ export const openaiImageModelGenerationOptions = lazySchema(() =>
        */
       style: z.enum(['vivid', 'natural']).optional(),
 
+      /**
+       * Format in which the generated image(s) are returned. `gif` produces
+       * an animated GIF and is supported by GPT Image 2.6 models.
+       */
+      outputFormat: z.enum(['png', 'jpeg', 'webp', 'gif']).optional(),
+
+      /**
+       * Number of frames (2-64) of an animated GIF. Only applies to the `gif`
+       * output format. The API defaults to 9.
+       */
+      frameCount: z.number().int().min(2).max(64).optional(),
+
+      /**
+       * Duration of each frame in milliseconds (20-2000) of an animated GIF.
+       * The API rounds it to the nearest 10 ms. Only applies to the `gif`
+       * output format. The API defaults to 200.
+       */
+      frameDurationMs: z.number().int().min(20).max(2000).optional(),
+
       /**
        * Content moderation level for the generated image(s). `low` applies
        * less restrictive filtering.
@@ -115,6 +149,20 @@ export const openaiImageModelEditOptions = lazySchema(() =>
        * Fidelity of the output image(s) to the input image(s).
        */
       inputFidelity: z.enum(['high', 'low']).optional(),
+
+      /**
+       * A transparent PNG overlaid on the first input image to mark up the
+       * regions to change, as an HTTPS URL or a base64 data URL. It must match
+       * the dimensions of the first image. Supported by GPT Image 2.5 and 2.6
+       * models. Cannot be combined with a `mask`.
+       */
+      markup: z.string().optional(),
+
+      /**
+       * Content moderation level for the edited image(s). `low` applies
+       * less restrictive filtering. Supported by GPT Image models.
+       */
+      moderation: z.enum(['auto', 'low']).optional(),
     }),
   ),
 );

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

@@ -1,7 +1,8 @@
-import type {
-  ImageModelV4,
-  ImageModelV4File,
-  SharedV4Warning,
+import {
+  InvalidArgumentError,
+  type ImageModelV4,
+  type ImageModelV4File,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   resolve,
@@ -128,6 +129,13 @@ export class OpenAIImageModel implements ImageModelV4 {
           schema: openaiImageModelEditOptions,
         })) ?? {};
 
+      if (mask != null && openaiOptions.markup != null) {
+        throw new InvalidArgumentError({
+          argument: 'providerOptions.openai.markup',
+          message: '`markup` cannot be combined with `mask`.',
+        });
+      }
+
       const { value: response, responseHeaders } = await postFormDataToApi({
         url: this.config.url({
           path: '/images/edits',
@@ -156,14 +164,21 @@ export class OpenAIImageModel implements ImageModelV4 {
             ),
           ),
           mask: mask != null ? await fileToBlob(mask, abortSignal) : undefined,
+          markup:
+            openaiOptions.markup != null
+              ? await markupToBlob(openaiOptions.markup, abortSignal)
+              : undefined,
           n,
           size,
           quality: openaiOptions.quality,
           background: openaiOptions.background,
           output_format: openaiOptions.outputFormat,
           output_compression: openaiOptions.outputCompression,
+          complexity: openaiOptions.complexity,
           input_fidelity: openaiOptions.inputFidelity,
+          moderation: openaiOptions.moderation,
           user: openaiOptions.user,
+          safety_identifier: openaiOptions.safetyIdentifier,
         }),
         failedResponseHandler: openaiFailedResponseHandler,
         successfulResponseHandler: createJsonResponseHandler(
@@ -235,7 +250,11 @@ export class OpenAIImageModel implements ImageModelV4 {
         moderation: openaiOptions.moderation,
         output_format: openaiOptions.outputFormat,
         output_compression: openaiOptions.outputCompression,
+        complexity: openaiOptions.complexity,
+        frame_count: openaiOptions.frameCount,
+        frame_duration_ms: openaiOptions.frameDurationMs,
         user: openaiOptions.user,
+        safety_identifier: openaiOptions.safetyIdentifier,
         ...(!hasDefaultResponseFormat(this.modelId)
           ? { response_format: 'b64_json' }
           : {}),
@@ -326,16 +345,42 @@ type OpenAIImageEditInput = {
   prompt?: string;
   image: Blob | Blob[];
   mask?: Blob;
+  markup?: Blob;
   n?: number;
   size?: `${number}x${number}`;
   quality?: OpenAIImageModelEditOptions['quality'];
   background?: OpenAIImageModelEditOptions['background'];
   output_format?: OpenAIImageModelEditOptions['outputFormat'];
   output_compression?: OpenAIImageModelEditOptions['outputCompression'];
+  complexity?: OpenAIImageModelEditOptions['complexity'];
   input_fidelity?: OpenAIImageModelEditOptions['inputFidelity'];
+  moderation?: OpenAIImageModelEditOptions['moderation'];
   user?: OpenAIImageModelEditOptions['user'];
+  safety_identifier?: OpenAIImageModelEditOptions['safetyIdentifier'];
 };
 
+async function markupToBlob(
+  markup: string,
+  abortSignal: AbortSignal | undefined,
+): Promise<Blob> {
+  const dataUrl = /^data:([^;,]*)(;base64)?,(.*)$/s.exec(markup);
+
+  if (dataUrl == null) {
+    return downloadBlob(markup, { abortSignal });
+  }
+
+  if (dataUrl[2] == null) {
+    throw new InvalidArgumentError({
+      argument: 'providerOptions.openai.markup',
+      message: '`markup` data URLs must be base64 encoded.',
+    });
+  }
+
+  return new Blob([convertBase64ToUint8Array(dataUrl[3]) as BlobPart], {
+    type: dataUrl[1] || 'image/png',
+  });
+}
+
 async function fileToBlob(
   file: ImageModelV4File | undefined,
   abortSignal: AbortSignal | undefined,

package/src/index.ts

@@ -22,6 +22,7 @@ export type {
 export type { OpenAIToolOptions } from './responses/openai-responses-prepare-tools';
 export type {
   OpenAILanguageModelChatOptions,
+  OpenAIChatMessageProviderOptions,
   /** @deprecated Use `OpenAILanguageModelChatOptions` instead. */
   OpenAILanguageModelChatOptions as OpenAIChatLanguageModelOptions,
 } from './chat/openai-chat-language-model-options';