@ai-sdk/openai 3.0.135 → 3.0.137

package/docs/03-openai.mdx

@@ -2755,6 +2755,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        |
@@ -2802,6 +2804,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
@@ -2847,6 +2871,30 @@ const result = await transcribe({
 });
 ```
 
+For `gpt-transcribe`, use `languages` for expected languages and `keywords` for
+names, acronyms, and domain vocabulary. These hints are sent as repeated
+`languages[]` and `keywords[]` multipart fields:
+
+```ts
+import { transcribe } from 'ai';
+import { openai, type OpenAITranscriptionModelOptions } from '@ai-sdk/openai';
+
+const result = await transcribe({
+  model: openai.transcription('gpt-transcribe'),
+  audio: new Uint8Array([1, 2, 3, 4]),
+  providerOptions: {
+    openai: {
+      languages: ['en', 'fr'],
+      keywords: ['premium plan', 'AC-42'],
+      prompt: 'A customer support call.',
+    } satisfies OpenAITranscriptionModelOptions,
+  },
+});
+```
+
+Use `languages` instead of `language` with `gpt-transcribe`; do not send both.
+The API validates model support and language codes. These options apply to REST transcription.
+
 To get word-level timestamps, specify the granularity:
 
 ```ts highlight="8-9"
@@ -2880,6 +2928,16 @@ The following provider options are available:
   The language of the input audio. Supplying the input language in ISO-639-1 format (e.g. 'en') will improve accuracy and latency.
   Optional.
 
+- **languages** _string[]_
+  Expected languages for REST transcription, such as `['en', 'fr']` for `gpt-transcribe`.
+  Use this instead of `language`; do not send both. The API validates model support.
+  Optional.
+
+- **keywords** _string[]_
+  Vocabulary hints for REST transcription, such as product names, acronyms, or technical terms.
+  Supported by `gpt-transcribe`; the API validates support for other models.
+  Optional.
+
 - **prompt** _string_
   An optional text to guide the model's style or continue a previous audio segment. The prompt should match the audio language.
   Optional.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "3.0.135",
+  "version": "3.0.137",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -36,16 +36,16 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider-utils": "4.0.63",
-    "@ai-sdk/provider": "3.0.19"
+    "@ai-sdk/provider": "3.0.19",
+    "@ai-sdk/provider-utils": "4.0.64"
   },
   "devDependencies": {
     "@types/node": "20.17.24",
     "tsup": "^8",
     "typescript": "5.8.3",
     "zod": "3.25.76",
-    "@vercel/ai-tsconfig": "0.0.0",
-    "@ai-sdk/test-server": "1.0.6"
+    "@ai-sdk/test-server": "1.0.6",
+    "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "zod": "^3.25.76 || ^4.1.8"

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

@@ -5,10 +5,29 @@ import {
   type SharedV3ProviderOptions,
 } from '@ai-sdk/provider';
 import type { OpenAIChatPrompt } from './openai-chat-prompt';
-import { convertToBase64 } from '@ai-sdk/provider-utils';
+import {
+  secureJsonParse,
+  stringifyWithBigIntAndCycles,
+  convertToBase64,
+} from '@ai-sdk/provider-utils';
 
 function serializeToolCallArguments(input: unknown): string {
-  return JSON.stringify(
+  if (typeof input === 'string') {
+    try {
+      const parsed = secureJsonParse(input);
+      if (
+        typeof parsed !== 'object' ||
+        parsed === null ||
+        Array.isArray(parsed)
+      ) {
+        return '{}';
+      }
+      return input;
+    } catch {
+      return '{}';
+    }
+  }
+  return stringifyWithBigIntAndCycles(
     typeof input === 'object' && input !== null && !Array.isArray(input)
       ? input
       : {},
@@ -304,7 +323,7 @@ export function convertToOpenAIChatMessages({
             case 'content':
             case 'json':
             case 'error-json':
-              contentValue = JSON.stringify(output.value);
+              contentValue = stringifyWithBigIntAndCycles(output.value);
               break;
           }
 

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

@@ -12,6 +12,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'
@@ -27,6 +29,8 @@ export const modelMaxImagesPerCall: Record<OpenAIImageModelId, number> = {
   'gpt-image-1-mini': 10,
   'gpt-image-1.5': 10,
   'gpt-image-2': 10,
+  'gpt-image-2.6-flare': 10,
+  'gpt-image-2.6-sunburst': 10,
   'gpt-image-2.5-flare': 10,
   'gpt-image-2.5-flare-2026-09-08': 10,
   'gpt-image-2.5-sunburst': 10,
@@ -74,6 +78,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.
@@ -85,6 +95,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(() =>
@@ -105,6 +122,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.
@@ -125,6 +161,14 @@ 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(),
     }),
   ),
 );

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

@@ -1,7 +1,8 @@
-import type {
-  ImageModelV3,
-  ImageModelV3File,
-  SharedV3Warning,
+import {
+  InvalidArgumentError,
+  type ImageModelV3,
+  type ImageModelV3File,
+  type SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
@@ -86,6 +87,13 @@ export class OpenAIImageModel implements ImageModelV3 {
           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',
@@ -114,14 +122,20 @@ export class OpenAIImageModel implements ImageModelV3 {
             ),
           ),
           mask: mask != null ? await fileToBlob(mask) : undefined,
+          markup:
+            openaiOptions.markup != null
+              ? await markupToBlob(openaiOptions.markup)
+              : undefined,
           n,
           size,
           quality: openaiOptions.quality,
           background: openaiOptions.background,
           output_format: openaiOptions.outputFormat,
           output_compression: openaiOptions.outputCompression,
+          complexity: openaiOptions.complexity,
           input_fidelity: openaiOptions.inputFidelity,
           user: openaiOptions.user,
+          safety_identifier: openaiOptions.safetyIdentifier,
         }),
         failedResponseHandler: openaiFailedResponseHandler,
         successfulResponseHandler: createJsonResponseHandler(
@@ -193,7 +207,11 @@ export class OpenAIImageModel implements ImageModelV3 {
         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' }
           : {}),
@@ -284,16 +302,38 @@ 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'];
   user?: OpenAIImageModelEditOptions['user'];
+  safety_identifier?: OpenAIImageModelEditOptions['safetyIdentifier'];
 };
 
+async function markupToBlob(markup: string): Promise<Blob> {
+  const dataUrl = /^data:([^;,]*)(;base64)?,(.*)$/s.exec(markup);
+
+  if (dataUrl == null) {
+    return downloadBlob(markup);
+  }
+
+  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: ImageModelV3File | undefined,
 ): Promise<Blob | undefined> {

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

@@ -8,6 +8,8 @@ import {
   type SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
+  secureJsonParse,
+  stringifyWithBigIntAndCycles,
   lazySchema,
   zodSchema,
   type InferSchema,
@@ -49,7 +51,15 @@ import {
 } from './expand-parallel-tool-call';
 
 function serializeToolCallArguments(input: unknown): string {
-  return JSON.stringify(input === undefined ? {} : input);
+  if (typeof input === 'string') {
+    try {
+      secureJsonParse(input);
+      return input;
+    } catch {
+      return stringifyWithBigIntAndCycles(input);
+    }
+  }
+  return stringifyWithBigIntAndCycles(input === undefined ? {} : input);
 }
 
 async function convertWebSearchToolResultOutput({
@@ -146,7 +156,7 @@ async function convertFunctionToolResultOutput({
     }
     case 'json':
     case 'error-json':
-      return convertScalarOutput(JSON.stringify(output.value));
+      return convertScalarOutput(stringifyWithBigIntAndCycles(output.value));
     case 'content':
       return output.value
         .map(item => {
@@ -901,7 +911,7 @@ export async function convertToOpenAIResponsesInput({
                   input:
                     typeof part.input === 'string'
                       ? part.input
-                      : JSON.stringify(part.input),
+                      : stringifyWithBigIntAndCycles(part.input),
                   ...(isAsync != null && { async: isAsync }),
                   id,
                 });
@@ -1101,7 +1111,7 @@ export async function convertToOpenAIResponsesInput({
                   } else if (reasoningMessage !== undefined) {
                     warnings.push({
                       type: 'other',
-                      message: `Cannot append empty reasoning part to existing reasoning sequence. Skipping reasoning part: ${JSON.stringify(part)}.`,
+                      message: `Cannot append empty reasoning part to existing reasoning sequence. Skipping reasoning part: ${stringifyWithBigIntAndCycles(part)}.`,
                     });
                   }
 
@@ -1152,7 +1162,7 @@ export async function convertToOpenAIResponsesInput({
                 } else {
                   warnings.push({
                     type: 'other',
-                    message: `Non-OpenAI reasoning parts are not supported. Skipping reasoning part: ${JSON.stringify(part)}.`,
+                    message: `Non-OpenAI reasoning parts are not supported. Skipping reasoning part: ${stringifyWithBigIntAndCycles(part)}.`,
                   });
                 }
               }
@@ -1238,7 +1248,9 @@ export async function convertToOpenAIResponsesInput({
                 }),
               );
               const serializedToolOutputs = toolOutputs.map(({ output }) =>
-                typeof output === 'string' ? output : JSON.stringify(output),
+                typeof output === 'string'
+                  ? output
+                  : stringifyWithBigIntAndCycles(output),
               );
               const hasPromptCacheBreakpoint = toolOutputs.some(
                 ({ promptCacheBreakpoint }) => promptCacheBreakpoint != null,
@@ -1394,7 +1406,9 @@ export async function convertToOpenAIResponsesInput({
                 break;
               case 'json':
               case 'error-json':
-                outputValue = convertScalarOutput(JSON.stringify(output.value));
+                outputValue = convertScalarOutput(
+                  stringifyWithBigIntAndCycles(output.value),
+                );
                 break;
               case 'content':
                 outputValue = output.value

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

@@ -142,6 +142,8 @@ export class OpenAITranscriptionModel implements TranscriptionModelV3 {
       const transcriptionModelOptions = {
         include: openAIOptions.include,
         language: openAIOptions.language,
+        languages: openAIOptions.languages,
+        keywords: openAIOptions.keywords,
         prompt: openAIOptions.prompt,
         // https://platform.openai.com/docs/api-reference/audio/createTranscription#audio_createtranscription-response_format
         // prefer verbose_json to get segments for models that support it

package/src/transcription/openai-transcription-options.ts

@@ -29,6 +29,18 @@ export const openAITranscriptionModelOptions = lazySchema(() =>
        */
       language: z.string().optional(),
 
+      /**
+       * Expected languages for REST transcription, e.g. with gpt-transcribe.
+       * Use this instead of language. The API validates model support.
+       */
+      languages: z.array(z.string()).optional(),
+
+      /**
+       * Vocabulary hints for REST transcription, e.g. names or technical terms.
+       * The API validates model support.
+       */
+      keywords: z.array(z.string()).optional(),
+
       /**
        * An optional text to guide the model's style or continue a previous audio segment.
        */