@ai-sdk/openai 4.0.110 → 4.0.113

package/package.json

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

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

@@ -19,8 +19,8 @@ import {
   createJsonResponseHandler,
   generateId,
   isCustomReasoning,
-  parseProviderOptions,
   postJsonToApi,
+  resolveProviderOptions,
   serializeModelOptions,
   WORKFLOW_DESERIALIZE,
   WORKFLOW_SERIALIZE,
@@ -123,13 +123,20 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
   }: LanguageModelV4CallOptions) {
     const warnings: SharedV4Warning[] = [];
 
-    // Parse provider options
+    // `openai` and the Azure key are merged; the Azure key wins (like Azure
+    // completion models).
+    const providerOptionsNames = this.config.provider.includes('azure')
+      ? (['openai', 'azure'] as const)
+      : (['openai'] as const);
     const openaiOptions =
-      (await parseProviderOptions({
-        provider: 'openai',
-        providerOptions,
-        schema: openaiLanguageModelChatOptions,
-      })) ?? {};
+      (
+        await resolveProviderOptions({
+          providerOptions,
+          namespaces: providerOptionsNames,
+          resolution: 'merge',
+          schema: openaiLanguageModelChatOptions,
+        })
+      ).options ?? {};
 
     const {
       capabilities: { language: modelCapabilities },
@@ -178,7 +185,11 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
 
     // reasoningSummary is a Responses API option that the chat options schema strips,
     // so check the raw provider options to avoid silently ignoring it:
-    if (providerOptions?.openai?.reasoningSummary != null) {
+    if (
+      providerOptionsNames.some(
+        name => providerOptions?.[name]?.reasoningSummary != null,
+      )
+    ) {
       warnings.push({
         type: 'unsupported',
         feature: 'reasoningSummary',

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

@@ -14,8 +14,8 @@ import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
-  parseProviderOptions,
   postJsonToApi,
+  resolveProviderOptions,
   serializeModelOptions,
   WORKFLOW_DESERIALIZE,
   WORKFLOW_SERIALIZE,
@@ -111,18 +111,16 @@ export class OpenAICompletionLanguageModel implements LanguageModelV4 {
     const warnings: SharedV4Warning[] = [];
 
     // Parse provider options
-    const openaiOptions = {
-      ...(await parseProviderOptions({
-        provider: 'openai',
-        providerOptions,
-        schema: openaiLanguageModelCompletionOptions,
-      })),
-      ...(await parseProviderOptions({
-        provider: this.providerOptionsName,
-        providerOptions,
-        schema: openaiLanguageModelCompletionOptions,
-      })),
-    };
+    // `openai` and the provider key are merged; the provider key wins.
+    const openaiOptions =
+      (
+        await resolveProviderOptions({
+          providerOptions,
+          namespaces: ['openai', this.providerOptionsName],
+          resolution: 'merge',
+          schema: openaiLanguageModelCompletionOptions,
+        })
+      ).options ?? {};
 
     if (topK != null) {
       warnings.push({ type: 'unsupported', feature: 'topK' });

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

@@ -100,71 +100,82 @@ export type OpenAIImageModelOptions = InferSchema<
   typeof openaiImageModelOptions
 >;
 
+/**
+ * Shape of the OpenAI image generation options. Exported so that routers
+ * that also call the OpenAI image API (e.g. Azure) can accept these options
+ * under their own providerOptions key.
+ */
+export const openaiImageModelGenerationOptionsShape = () =>
+  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(),
+
+    /**
+     * 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.
+     */
+    moderation: z.enum(['auto', 'low']).optional(),
+  }).shape;
+
 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(),
-
-      /**
-       * 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.
-       */
-      moderation: z.enum(['auto', 'low']).optional(),
-    }),
-  ),
+  zodSchema(z.object(openaiImageModelGenerationOptionsShape())),
 );
 
 export type OpenAIImageModelGenerationOptions = InferSchema<
   typeof openaiImageModelGenerationOptions
 >;
 
+/**
+ * Shape of the OpenAI image edit options. Exported so that routers can accept
+ * these options under their own providerOptions key.
+ */
+export const openaiImageModelEditOptionsShape = () =>
+  baseImageModelOptionsObject().extend({
+    /**
+     * 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(),
+  }).shape;
+
 export const openaiImageModelEditOptions = lazySchema(() =>
-  zodSchema(
-    baseImageModelOptionsObject().extend({
-      /**
-       * 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(),
-    }),
-  ),
+  zodSchema(z.object(openaiImageModelEditOptionsShape())),
 );
 
 export type OpenAIImageModelEditOptions = InferSchema<

package/src/redact-openai-tool-credentials.ts

@@ -0,0 +1,64 @@
+import { withTelemetryRedaction } from '@ai-sdk/provider-utils';
+
+/** OpenAI owns both the SDK configuration paths and their wire equivalents. */
+export function redactOpenAIToolArgs(
+  type: unknown,
+  args: Record<string, unknown>,
+  wireFormat = false,
+): Record<string, unknown> {
+  if (type === 'mcp') {
+    return {
+      ...args,
+      ...(args.authorization != null ? { authorization: '[redacted]' } : {}),
+      ...(isRecord(args.headers)
+        ? {
+            headers: Object.fromEntries(
+              Object.keys(args.headers).map(name => [name, '[redacted]']),
+            ),
+          }
+        : {}),
+    };
+  }
+
+  const key =
+    type === 'code_interpreter'
+      ? 'container'
+      : type === 'shell'
+        ? 'environment'
+        : undefined;
+  if (key == null || !isRecord(args[key])) return args;
+  const container = args[key];
+  const policyKey = wireFormat ? 'network_policy' : 'networkPolicy';
+  const secretsKey = wireFormat ? 'domain_secrets' : 'domainSecrets';
+  const policy = container[policyKey];
+  if (!isRecord(policy) || !Array.isArray(policy[secretsKey])) return args;
+  return {
+    ...args,
+    [key]: {
+      ...container,
+      [policyKey]: {
+        ...policy,
+        [secretsKey]: policy[secretsKey].map(secret =>
+          isRecord(secret) && 'value' in secret
+            ? { ...secret, value: '[redacted]' }
+            : secret,
+        ),
+      },
+    },
+  };
+}
+
+/** Preserve raw request/response bodies while providing a safe telemetry view. */
+export function withOpenAIResponseRedaction<T>(value: T): T {
+  if (!isRecord(value) || !Array.isArray(value.tools)) return value;
+  return withTelemetryRedaction(value, body => ({
+    ...body,
+    tools: (body.tools as unknown[]).map(tool =>
+      isRecord(tool) ? redactOpenAIToolArgs(tool.type, tool, true) : tool,
+    ),
+  }));
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}

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

@@ -311,7 +311,7 @@ async function convertFunctionToolResultOutput({
 }
 
 type ParallelToolResultGroup = {
-  metadata: ParallelToolCallMetadata;
+  metadata: ParallelToolCallMetadata & { input: string };
   results: Array<LanguageModelV4ToolResultPart>;
 };
 
@@ -323,7 +323,9 @@ function hasSameParallelToolCall(
     first.itemId === second.itemId &&
     first.toolCallId === second.toolCallId &&
     first.toolName === second.toolName &&
-    first.input === second.input &&
+    (first.input === undefined ||
+      second.input === undefined ||
+      first.input === second.input) &&
     first.count === second.count
   );
 }
@@ -381,6 +383,12 @@ function collectCompleteParallelToolResultGroups({
         continue;
       }
 
+      if (
+        existing.metadata.input === undefined &&
+        metadata.input !== undefined
+      ) {
+        existing.metadata = metadata;
+      }
       existing.results.set(metadata.index, part);
     }
   }
@@ -388,7 +396,11 @@ function collectCompleteParallelToolResultGroups({
   const completeGroups = new Map<string, ParallelToolResultGroup>();
 
   for (const [toolCallId, group] of pendingGroups) {
-    if (group.invalid || group.results.size !== group.metadata.count) {
+    if (
+      group.invalid ||
+      group.results.size !== group.metadata.count ||
+      group.metadata.input === undefined
+    ) {
       continue;
     }
 
@@ -398,7 +410,7 @@ function collectCompleteParallelToolResultGroups({
 
     if (results.every(isNonNullable)) {
       completeGroups.set(toolCallId, {
-        metadata: group.metadata,
+        metadata: { ...group.metadata, input: group.metadata.input },
         results,
       });
     }

package/src/responses/expand-parallel-tool-call.ts

@@ -17,7 +17,8 @@ export type ParallelToolCallMetadata = {
   itemId: string;
   toolCallId: string;
   toolName: string;
-  input: string;
+  /** Retained only on the first child; older histories may repeat it. */
+  input?: string;
   index: number;
   count: number;
 };
@@ -36,7 +37,7 @@ export function getParallelToolCallMetadata({
     typeof metadata.itemId !== 'string' ||
     typeof metadata.toolCallId !== 'string' ||
     typeof metadata.toolName !== 'string' ||
-    typeof metadata.input !== 'string' ||
+    (metadata.input !== undefined && typeof metadata.input !== 'string') ||
     typeof metadata.index !== 'number' ||
     !Number.isInteger(metadata.index) ||
     typeof metadata.count !== 'number' ||
@@ -129,7 +130,7 @@ export async function expandParallelToolCall({
             itemId,
             toolCallId: toolCall.toolCallId,
             toolName: toolCall.toolName,
-            input: toolCall.input,
+            ...(index === 0 && { input: toolCall.input }),
             index,
             count: toolUses.length,
           } satisfies ParallelToolCallMetadata,

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

@@ -23,8 +23,8 @@ import {
   createJsonResponseHandler,
   createToolNameMapping,
   generateId,
-  parseProviderOptions,
   postJsonToApi,
+  resolveProviderOptions,
   serializeModelOptions,
   WORKFLOW_DESERIALIZE,
   WORKFLOW_SERIALIZE,
@@ -32,6 +32,7 @@ import {
   type ParseResult,
 } from '@ai-sdk/provider-utils';
 import { normalizeOpenAIJsonSchema } from '../normalize-openai-json-schema';
+import { withOpenAIResponseRedaction } from '../redact-openai-tool-credentials';
 import {
   prepareOpenAIConfigForWorkflowDeserialize,
   type OpenAIConfig,
@@ -331,20 +332,15 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     const providerOptionsName = config.provider.includes('azure')
       ? 'azure'
       : 'openai';
-    let openaiOptions = await parseProviderOptions({
-      provider: providerOptionsName,
+    // The provider key (`azure`) and `openai` are alternatives: the first
+    // present one is used as a whole.
+    const { options: openaiOptions } = await resolveProviderOptions({
       providerOptions,
+      namespaces: [providerOptionsName, 'openai'],
+      resolution: 'first',
       schema: openaiLanguageModelResponsesOptionsSchema,
     });
 
-    if (openaiOptions == null && providerOptionsName !== 'openai') {
-      openaiOptions = await parseProviderOptions({
-        provider: 'openai',
-        providerOptions,
-        schema: openaiLanguageModelResponsesOptionsSchema,
-      });
-    }
-
     const resolvedReasoningEffort = resolveOpenAIReasoningEffort({
       providerReasoningEffort: openaiOptions?.reasoningEffort,
       reasoning,
@@ -814,11 +810,11 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
 
     return {
       webSearchToolName,
-      args: {
+      args: withOpenAIResponseRedaction({
         ...baseArgs,
         tools: openaiTools,
         tool_choice: openaiToolChoice,
-      },
+      }),
       warnings: [...warnings, ...toolWarnings],
       store,
       toolNameMapping,
@@ -1564,7 +1560,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
         timestamp: new Date(response.created_at! * 1000),
         modelId: response.model,
         headers: responseHeaders,
-        body: rawResponse,
+        body: withOpenAIResponseRedaction(rawResponse),
       },
       providerMetadata,
       warnings,
@@ -1595,10 +1591,10 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
         await resolve(this.config.headers),
         options.headers,
       ),
-      body: {
+      body: withOpenAIResponseRedaction({
         ...body,
         stream: true,
-      },
+      }),
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(
         openaiResponsesChunkSchema,

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

@@ -16,13 +16,18 @@ export type OpenAISpeechModelId =
   | (string & {});
 
 // https://platform.openai.com/docs/api-reference/audio/createSpeech
+/**
+ * Shape of the OpenAI speech model options. Exported so that routers that
+ * also call the OpenAI speech API (e.g. Azure) can accept these options under
+ * their own providerOptions key.
+ */
+export const openaiSpeechModelOptionsShape = () => ({
+  instructions: z.string().nullish(),
+  speed: z.number().min(0.25).max(4.0).nullish(),
+});
+
 export const openaiSpeechModelOptionsSchema = lazySchema(() =>
-  zodSchema(
-    z.object({
-      instructions: z.string().nullish(),
-      speed: z.number().min(0.25).max(4.0).nullish(),
-    }),
-  ),
+  zodSchema(z.object(openaiSpeechModelOptionsShape())),
 );
 
 export type OpenAISpeechModelOptions = InferSchema<

package/src/tool/code-interpreter.ts

@@ -4,6 +4,7 @@ import {
   zodSchema,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
+import { redactOpenAIToolArgs } from '../redact-openai-tool-credentials';
 
 export const codeInterpreterInputSchema = lazySchema(() =>
   zodSchema(
@@ -128,6 +129,7 @@ export const codeInterpreterToolFactory = createProviderExecutedToolFactory<
   CodeInterpreterArgs
 >({
   id: 'openai.code_interpreter',
+  redactArgs: args => redactOpenAIToolArgs('code_interpreter', args),
   inputSchema: codeInterpreterInputSchema,
   outputSchema: codeInterpreterOutputSchema,
 });

package/src/tool/mcp.ts

@@ -5,6 +5,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import type { JSONValue } from '@ai-sdk/provider';
 import { z } from 'zod/v4';
+import { redactOpenAIToolArgs } from '../redact-openai-tool-credentials';
 
 let cachedJsonValueSchema: z.ZodType<JSONValue> | undefined;
 const jsonValueSchema = (): z.ZodType<JSONValue> =>
@@ -139,6 +140,7 @@ export const mcpToolFactory = createProviderExecutedToolFactory<
   McpArgs
 >({
   id: 'openai.mcp',
+  redactArgs: args => redactOpenAIToolArgs('mcp', args),
   inputSchema: mcpInputSchema,
   outputSchema: mcpOutputSchema,
 });

package/src/tool/shell.ts

@@ -5,6 +5,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import type { SharedV4ProviderReference } from '@ai-sdk/provider';
 import { z } from 'zod/v4';
+import { redactOpenAIToolArgs } from '../redact-openai-tool-credentials';
 
 export const shellInputSchema = lazySchema(() =>
   zodSchema(
@@ -210,6 +211,7 @@ export const shell = createProviderDefinedToolFactoryWithOutputSchema<
   ShellArgs
 >({
   id: 'openai.shell',
+  redactArgs: args => redactOpenAIToolArgs('shell', args),
   inputSchema: shellInputSchema,
   outputSchema: shellOutputSchema,
 });