@ai-sdk/openai 3.0.135 → 3.0.137

package/dist/internal/index.mjs

@@ -362,9 +362,24 @@ function convertOpenAIChatUsage(usage) {
 import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
-import { convertToBase64 } from "@ai-sdk/provider-utils";
+import {
+  secureJsonParse,
+  stringifyWithBigIntAndCycles,
+  convertToBase64
+} from "@ai-sdk/provider-utils";
 function serializeToolCallArguments(input) {
-  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 (e) {
+      return "{}";
+    }
+  }
+  return stringifyWithBigIntAndCycles(
     typeof input === "object" && input !== null && !Array.isArray(input) ? input : {}
   );
 }
@@ -592,7 +607,7 @@ function convertToOpenAIChatMessages({
             case "content":
             case "json":
             case "error-json":
-              contentValue = JSON.stringify(output.value);
+              contentValue = stringifyWithBigIntAndCycles(output.value);
               break;
           }
           messages.push({
@@ -2073,6 +2088,9 @@ var OpenAIEmbeddingModel = class {
 };
 
 // src/image/openai-image-model.ts
+import {
+  InvalidArgumentError
+} from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders4,
   convertBase64ToUint8Array,
@@ -2127,6 +2145,8 @@ var modelMaxImagesPerCall = {
   "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,
@@ -2162,6 +2182,11 @@ var baseImageModelOptionsObject = () => z9.object({
    * Format in which the generated image(s) are returned.
    */
   outputFormat: z9.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: z9.enum(["low", "medium", "high"]).optional(),
   /**
    * Compression level (0-100) for the generated image(s). Applies to the
    * `jpeg` and `webp` output formats.
@@ -2171,7 +2196,13 @@ var baseImageModelOptionsObject = () => z9.object({
    * A unique identifier representing your end-user, which can help OpenAI
    * to monitor and detect abuse.
    */
-  user: z9.string().optional()
+  user: z9.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: z9.string().max(128).optional()
 });
 var openaiImageModelOptions = lazySchema9(
   () => zodSchema9(baseImageModelOptionsObject())
@@ -2185,6 +2216,22 @@ var openaiImageModelGenerationOptions = lazySchema9(
        * looking images.
        */
       style: z9.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: z9.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: z9.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: z9.number().int().min(20).max(2e3).optional(),
       /**
        * Content moderation level for the generated image(s). `low` applies
        * less restrictive filtering.
@@ -2199,7 +2246,14 @@ var openaiImageModelEditOptions = lazySchema9(
       /**
        * Fidelity of the output image(s) to the input image(s).
        */
-      inputFidelity: z9.enum(["high", "low"]).optional()
+      inputFidelity: z9.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: z9.string().optional()
     })
   )
 );
@@ -2248,6 +2302,12 @@ var OpenAIImageModel = class {
         providerOptions,
         schema: openaiImageModelEditOptions
       })) != null ? _d : {};
+      if (mask != null && openaiOptions2.markup != null) {
+        throw new InvalidArgumentError({
+          argument: "providerOptions.openai.markup",
+          message: "`markup` cannot be combined with `mask`."
+        });
+      }
       const { value: response2, responseHeaders: responseHeaders2 } = await postFormDataToApi({
         url: this.config.url({
           path: "/images/edits",
@@ -2272,14 +2332,17 @@ var OpenAIImageModel = class {
             )
           ),
           mask: mask != null ? await fileToBlob(mask) : void 0,
+          markup: openaiOptions2.markup != null ? await markupToBlob(openaiOptions2.markup) : void 0,
           n,
           size,
           quality: openaiOptions2.quality,
           background: openaiOptions2.background,
           output_format: openaiOptions2.outputFormat,
           output_compression: openaiOptions2.outputCompression,
+          complexity: openaiOptions2.complexity,
           input_fidelity: openaiOptions2.inputFidelity,
-          user: openaiOptions2.user
+          user: openaiOptions2.user,
+          safety_identifier: openaiOptions2.safetyIdentifier
         }),
         failedResponseHandler: openaiFailedResponseHandler,
         successfulResponseHandler: createJsonResponseHandler4(
@@ -2345,7 +2408,11 @@ var OpenAIImageModel = class {
         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" } : {}
       },
       failedResponseHandler: openaiFailedResponseHandler,
@@ -2408,6 +2475,21 @@ function distributeTokenDetails(details, index, total) {
   }
   return result;
 }
+async function markupToBlob(markup) {
+  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])], {
+    type: dataUrl[1] || "image/png"
+  });
+}
 async function fileToBlob(file) {
   if (!file) return void 0;
   if (file.type === "url") {
@@ -2483,6 +2565,16 @@ var openAITranscriptionModelOptions = lazySchema11(
        * The language of the input audio in ISO-639-1 format.
        */
       language: z11.string().optional(),
+      /**
+       * Expected languages for REST transcription, e.g. with gpt-transcribe.
+       * Use this instead of language. The API validates model support.
+       */
+      languages: z11.array(z11.string()).optional(),
+      /**
+       * Vocabulary hints for REST transcription, e.g. names or technical terms.
+       * The API validates model support.
+       */
+      keywords: z11.array(z11.string()).optional(),
       /**
        * An optional text to guide the model's style or continue a previous audio segment.
        */
@@ -2594,6 +2686,8 @@ var OpenAITranscriptionModel = class {
       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
@@ -2853,6 +2947,8 @@ import {
   UnsupportedFunctionalityError as UnsupportedFunctionalityError4
 } from "@ai-sdk/provider";
 import {
+  secureJsonParse as secureJsonParse2,
+  stringifyWithBigIntAndCycles as stringifyWithBigIntAndCycles2,
   lazySchema as lazySchema19,
   zodSchema as zodSchema19,
   convertToBase64 as convertToBase642,
@@ -3527,7 +3623,15 @@ async function expandParallelToolCall({
 
 // src/responses/convert-to-openai-responses-input.ts
 function serializeToolCallArguments2(input) {
-  return JSON.stringify(input === void 0 ? {} : input);
+  if (typeof input === "string") {
+    try {
+      secureJsonParse2(input);
+      return input;
+    } catch (e) {
+      return stringifyWithBigIntAndCycles2(input);
+    }
+  }
+  return stringifyWithBigIntAndCycles2(input === void 0 ? {} : input);
 }
 async function convertWebSearchToolResultOutput({
   output,
@@ -3605,7 +3709,7 @@ async function convertFunctionToolResultOutput({
     }
     case "json":
     case "error-json":
-      return convertScalarOutput(JSON.stringify(output.value));
+      return convertScalarOutput(stringifyWithBigIntAndCycles2(output.value));
     case "content":
       return output.value.map((item) => {
         var _a3, _b, _c, _d, _e, _f, _g;
@@ -4108,7 +4212,7 @@ async function convertToOpenAIResponsesInput({
                   type: "custom_tool_call",
                   call_id: part.toolCallId,
                   name: resolvedToolName,
-                  input: typeof part.input === "string" ? part.input : JSON.stringify(part.input),
+                  input: typeof part.input === "string" ? part.input : stringifyWithBigIntAndCycles2(part.input),
                   ...isAsync != null && { async: isAsync },
                   id
                 });
@@ -4234,7 +4338,7 @@ async function convertToOpenAIResponsesInput({
                   } else if (reasoningMessage !== void 0) {
                     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: ${stringifyWithBigIntAndCycles2(part)}.`
                     });
                   }
                   if (reasoningMessage === void 0) {
@@ -4270,7 +4374,7 @@ 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: ${stringifyWithBigIntAndCycles2(part)}.`
                   });
                 }
               }
@@ -4336,7 +4440,7 @@ async function convertToOpenAIResponsesInput({
                 })
               );
               const serializedToolOutputs = toolOutputs.map(
-                ({ output: output2 }) => typeof output2 === "string" ? output2 : JSON.stringify(output2)
+                ({ output: output2 }) => typeof output2 === "string" ? output2 : stringifyWithBigIntAndCycles2(output2)
               );
               const hasPromptCacheBreakpoint = toolOutputs.some(
                 ({ promptCacheBreakpoint }) => promptCacheBreakpoint != null
@@ -4452,7 +4556,9 @@ ${text}`,
                 break;
               case "json":
               case "error-json":
-                outputValue = convertScalarOutput(JSON.stringify(output.value));
+                outputValue = convertScalarOutput(
+                  stringifyWithBigIntAndCycles2(output.value)
+                );
                 break;
               case "content":
                 outputValue = output.value.map((item) => {