openai 6.44.0 → 6.45.0

package/src/_vendor/zod-to-json-schema/parsers/default.ts

@@ -2,9 +2,13 @@ import { ZodDefaultDef } from 'zod/v3';
 import { JsonSchema7Type, parseDef } from '../parseDef';
 import { Refs } from '../Refs';
 
-export function parseDefaultDef(_def: ZodDefaultDef, refs: Refs): JsonSchema7Type & { default: any } {
+export function parseDefaultDef(
+  _def: ZodDefaultDef,
+  refs: Refs,
+  forceResolution: boolean,
+): JsonSchema7Type & { default: any } {
   return {
-    ...parseDef(_def.innerType._def, refs),
+    ...parseDef(_def.innerType._def, refs, forceResolution),
     default: _def.defaultValue(),
   };
 }

package/src/_vendor/zod-to-json-schema/parsers/nullable.ts

@@ -12,7 +12,11 @@ export type JsonSchema7NullableType =
       type: [string, 'null'];
     };
 
-export function parseNullableDef(def: ZodNullableDef, refs: Refs): JsonSchema7NullableType | undefined {
+export function parseNullableDef(
+  def: ZodNullableDef,
+  refs: Refs,
+  forceResolution: boolean,
+): JsonSchema7NullableType | undefined {
   if (
     ['ZodString', 'ZodNumber', 'ZodBigInt', 'ZodBoolean', 'ZodNull'].includes(def.innerType._def.typeName) &&
     (!def.innerType._def.checks || !def.innerType._def.checks.length)
@@ -30,10 +34,14 @@ export function parseNullableDef(def: ZodNullableDef, refs: Refs): JsonSchema7Nu
   }
 
   if (refs.target === 'openApi3') {
-    const base = parseDef(def.innerType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath],
-    });
+    const base = parseDef(
+      def.innerType._def,
+      {
+        ...refs,
+        currentPath: [...refs.currentPath],
+      },
+      forceResolution,
+    );
 
     if (base && '$ref' in base) return { allOf: [base], nullable: true } as any;
 

package/src/_vendor/zod-to-json-schema/parsers/optional.ts

@@ -2,18 +2,26 @@ import { ZodOptionalDef } from 'zod/v3';
 import { JsonSchema7Type, parseDef } from '../parseDef';
 import { Refs } from '../Refs';
 
-export const parseOptionalDef = (def: ZodOptionalDef, refs: Refs): JsonSchema7Type | undefined => {
+export const parseOptionalDef = (
+  def: ZodOptionalDef,
+  refs: Refs,
+  forceResolution: boolean,
+): JsonSchema7Type | undefined => {
   if (
     refs.propertyPath &&
     refs.currentPath.slice(0, refs.propertyPath.length).toString() === refs.propertyPath.toString()
   ) {
-    return parseDef(def.innerType._def, { ...refs, currentPath: refs.currentPath });
+    return parseDef(def.innerType._def, { ...refs, currentPath: refs.currentPath }, forceResolution);
   }
 
-  const innerSchema = parseDef(def.innerType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, 'anyOf', '1'],
-  });
+  const innerSchema = parseDef(
+    def.innerType._def,
+    {
+      ...refs,
+      currentPath: [...refs.currentPath, 'anyOf', '1'],
+    },
+    forceResolution,
+  );
 
   return innerSchema ?
       {

package/src/_vendor/zod-to-json-schema/parsers/pipeline.ts

@@ -6,11 +6,12 @@ import { JsonSchema7AllOfType } from './intersection';
 export const parsePipelineDef = (
   def: ZodPipelineDef<any, any>,
   refs: Refs,
+  forceResolution: boolean,
 ): JsonSchema7AllOfType | JsonSchema7Type | undefined => {
   if (refs.pipeStrategy === 'input') {
-    return parseDef(def.in._def, refs);
+    return parseDef(def.in._def, refs, forceResolution);
   } else if (refs.pipeStrategy === 'output') {
-    return parseDef(def.out._def, refs);
+    return parseDef(def.out._def, refs, forceResolution);
   }
 
   const a = parseDef(def.in._def, {

package/src/_vendor/zod-to-json-schema/parsers/promise.ts

@@ -2,6 +2,10 @@ import { ZodPromiseDef } from 'zod/v3';
 import { JsonSchema7Type, parseDef } from '../parseDef';
 import { Refs } from '../Refs';
 
-export function parsePromiseDef(def: ZodPromiseDef, refs: Refs): JsonSchema7Type | undefined {
-  return parseDef(def.type._def, refs);
+export function parsePromiseDef(
+  def: ZodPromiseDef,
+  refs: Refs,
+  forceResolution: boolean,
+): JsonSchema7Type | undefined {
+  return parseDef(def.type._def, refs, forceResolution);
 }

package/src/_vendor/zod-to-json-schema/parsers/readonly.ts

@@ -2,6 +2,6 @@ import { ZodReadonlyDef } from 'zod/v3';
 import { parseDef } from '../parseDef';
 import { Refs } from '../Refs';
 
-export const parseReadonlyDef = (def: ZodReadonlyDef<any>, refs: Refs) => {
-  return parseDef(def.innerType._def, refs);
+export const parseReadonlyDef = (def: ZodReadonlyDef<any>, refs: Refs, forceResolution: boolean) => {
+  return parseDef(def.innerType._def, refs, forceResolution);
 };

package/src/auth/workload-identity-auth.ts

@@ -1,7 +1,7 @@
 import type { WorkloadIdentity, TokenExchangeResponse } from './types';
 import type { Fetch } from '../internal/builtin-types';
 import * as Shims from '../internal/shims';
-import { APIError, OAuthError } from '../core/error';
+import { APIError, OAuthError, OpenAIError } from '../core/error';
 
 interface CachedToken {
   token: string;
@@ -93,16 +93,27 @@ export class WorkloadIdentityAuth {
       );
     }
 
-    const tokenResponse = (await response.json()) as TokenExchangeResponse;
-    const expiresIn = tokenResponse.expires_in || 3600;
+    const tokenResponse: unknown = await response.json();
+    if (
+      typeof tokenResponse !== 'object' ||
+      tokenResponse === null ||
+      !('access_token' in tokenResponse) ||
+      typeof tokenResponse.access_token !== 'string' ||
+      tokenResponse.access_token.trim().length === 0
+    ) {
+      throw new OpenAIError("Token exchange response missing 'access_token' field");
+    }
+
+    const accessToken = tokenResponse.access_token;
+    const expiresIn = (tokenResponse as Partial<TokenExchangeResponse>).expires_in ?? 3600;
     const expiresAt = Date.now() + expiresIn * 1000;
 
     this.cachedToken = {
-      token: tokenResponse.access_token,
+      token: accessToken,
       expiresAt,
     };
 
-    return tokenResponse.access_token;
+    return accessToken;
   }
 
   private isTokenExpired(cachedToken: CachedToken): boolean {

package/src/azure.ts

@@ -8,7 +8,10 @@ import { OpenAI } from './client';
 import type { ClientOptions } from './client';
 
 /** API Client for interfacing with the Azure OpenAI API. */
-export interface AzureClientOptions extends ClientOptions {
+export interface AzureClientOptions extends Omit<ClientOptions, 'provider'> {
+  /** AzureOpenAI does not support third-party provider configuration. */
+  provider?: never;
+
   /**
    * Defaults to process.env['OPENAI_API_VERSION'].
    */

package/src/beta/realtime/internal-base.ts

@@ -78,16 +78,54 @@ export function isAzure(client: Pick<OpenAI, 'apiKey' | 'baseURL'>): client is A
   return client instanceof AzureOpenAI;
 }
 
-export function buildRealtimeURL(client: Pick<OpenAI, 'apiKey' | 'baseURL'>, model: string): URL {
-  const path = '/realtime';
+export type RealtimeConnectionConfig =
+  | {
+      /**
+       * Start a new Realtime session using the given model.
+       */
+      model: string;
+      callID?: undefined;
+    }
+  | {
+      model?: undefined;
+      /**
+       * Attach to an in-progress Realtime call over a sideband control connection.
+       */
+      callID: string;
+    };
+
+export function buildRealtimeURL(
+  client: Pick<OpenAI, 'apiKey' | 'baseURL'>,
+  connection: string | RealtimeConnectionConfig,
+): URL {
+  const config: RealtimeConnectionConfig =
+    typeof connection === 'string' ? { model: connection } : connection;
   const baseURL = client.baseURL;
+  const azure = isAzure(client);
+  const hasModel = !!config.model;
+  const hasCallID = !!config.callID;
+
+  const path = '/realtime';
   const url = new URL(baseURL + (baseURL.endsWith('/') ? path.slice(1) : path));
+
+  if (hasModel === hasCallID) {
+    throw new Error('Pass exactly one of `model` or `callID` when opening a Realtime WebSocket.');
+  }
+
   url.protocol = 'wss';
-  if (isAzure(client)) {
+  // Sideband control connections attach to an existing call via `call_id`.
+  if (azure) {
+    if (hasCallID) {
+      throw new Error('Azure `callID` connections require the stable Realtime helpers.');
+    }
     url.searchParams.set('api-version', client.apiVersion);
-    url.searchParams.set('deployment', model);
+    url.searchParams.set('deployment', config.model!);
   } else {
-    url.searchParams.set('model', model);
+    if (hasCallID) {
+      url.searchParams.set('call_id', config.callID!);
+    } else {
+      url.searchParams.set('model', config.model!);
+    }
   }
   return url;
 }

package/src/beta/realtime/websocket.ts

@@ -1,7 +1,12 @@
 import { AzureOpenAI, OpenAI } from '../../index';
 import { OpenAIError } from '../../error';
 import type { RealtimeClientEvent, RealtimeServerEvent } from '../../resources/beta/realtime/realtime';
-import { OpenAIRealtimeEmitter, buildRealtimeURL, isAzure } from './internal-base';
+import {
+  OpenAIRealtimeEmitter,
+  buildRealtimeURL,
+  isAzure,
+  type RealtimeConnectionConfig,
+} from './internal-base';
 import { isRunningInBrowser } from '../../internal/detect-platform';
 
 interface MessageEvent {
@@ -23,8 +28,7 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
   socket: _WebSocket;
 
   constructor(
-    props: {
-      model: string;
+    props: RealtimeConnectionConfig & {
       dangerouslyAllowBrowser?: boolean;
       /**
        * Callback to mutate the URL, needed for Azure.
@@ -54,13 +58,12 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
       throw new Error(
         [
           'Cannot open Realtime WebSocket with a function-based apiKey.',
-          'Use the .create() method so that the key is resolved before connecting:',
-          'await OpenAIRealtimeWebSocket.create(client, { model })',
+          'Use the .create() method so that the key is resolved before connecting.',
         ].join('\n'),
       );
     }
 
-    this.url = buildRealtimeURL(client, props.model);
+    this.url = buildRealtimeURL(client, props);
     props.onURL?.(this.url);
 
     // @ts-ignore
@@ -107,7 +110,7 @@ export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
 
   static async create(
     client: Pick<OpenAI, 'apiKey' | 'baseURL' | '_callApiKey'>,
-    props: { model: string; dangerouslyAllowBrowser?: boolean },
+    props: RealtimeConnectionConfig & { dangerouslyAllowBrowser?: boolean },
   ): Promise<OpenAIRealtimeWebSocket> {
     return new OpenAIRealtimeWebSocket({ ...props, __resolvedApiKey: await client._callApiKey() }, client);
   }

package/src/beta/realtime/ws.ts

@@ -1,15 +1,19 @@
 import * as WS from 'ws';
 import { AzureOpenAI, OpenAI } from '../../index';
 import type { RealtimeClientEvent, RealtimeServerEvent } from '../../resources/beta/realtime/realtime';
-import { OpenAIRealtimeEmitter, buildRealtimeURL, isAzure } from './internal-base';
+import {
+  OpenAIRealtimeEmitter,
+  buildRealtimeURL,
+  isAzure,
+  type RealtimeConnectionConfig,
+} from './internal-base';
 
 export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
   url: URL;
   socket: WS.WebSocket;
 
   constructor(
-    props: {
-      model: string;
+    props: RealtimeConnectionConfig & {
       options?: WS.ClientOptions | undefined;
       /** @internal */ __resolvedApiKey?: boolean;
     },
@@ -22,12 +26,11 @@ export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
       throw new Error(
         [
           'Cannot open Realtime WebSocket with a function-based apiKey.',
-          'Use the .create() method so that the key is resolved before connecting:',
-          'await OpenAIRealtimeWS.create(client, { model })',
+          'Use the .create() method so that the key is resolved before connecting.',
         ].join('\n'),
       );
     }
-    this.url = buildRealtimeURL(client, props.model);
+    this.url = buildRealtimeURL(client, props);
     this.socket = new WS.WebSocket(this.url, {
       ...props.options,
       headers: {
@@ -66,7 +69,7 @@ export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
 
   static async create(
     client: Pick<OpenAI, 'apiKey' | 'baseURL' | '_callApiKey'>,
-    props: { model: string; options?: WS.ClientOptions | undefined },
+    props: RealtimeConnectionConfig & { options?: WS.ClientOptions | undefined },
   ): Promise<OpenAIRealtimeWS> {
     return new OpenAIRealtimeWS({ ...props, __resolvedApiKey: await client._callApiKey() }, client);
   }

package/src/client.ts

@@ -233,6 +233,7 @@ import {
 import { type Fetch } from './internal/builtin-types';
 import { isRunningInBrowser } from './internal/detect-platform';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
+import { configureProvider, type Provider, type ProviderRuntime } from './internal/provider';
 import { FinalRequestOptions, RequestOptions } from './internal/request-options';
 import { readEnv } from './internal/utils/env';
 import {
@@ -363,6 +364,12 @@ export interface ClientOptions {
    * Mutually exclusive with `apiKey`.
    */
   workloadIdentity?: WorkloadIdentity | undefined;
+
+  /**
+   * Configure this client to use a third-party API provider.
+   * Mutually exclusive with top-level authentication and `baseURL` options.
+   */
+  provider?: Provider | undefined;
 }
 
 /**
@@ -386,6 +393,7 @@ export class OpenAI {
   #encoder: Opts.RequestEncoder;
   protected idempotencyHeader?: string;
   protected _options: ClientOptions;
+  private _provider: ProviderRuntime | undefined;
   private _workloadIdentityAuth?: WorkloadIdentityAuth;
 
   /**
@@ -397,6 +405,7 @@ export class OpenAI {
    * @param {string | null | undefined} [opts.project=process.env['OPENAI_PROJECT_ID'] ?? null]
    * @param {string | null | undefined} [opts.webhookSecret=process.env['OPENAI_WEBHOOK_SECRET'] ?? null]
    * @param {string} [opts.baseURL=process.env['OPENAI_BASE_URL'] ?? https://api.openai.com/v1] - Override the default base URL for the API.
+   * @param {Provider} [opts.provider] - Configure a third-party API provider. Mutually exclusive with top-level authentication and base URL options.
    * @param {number} [opts.timeout=10 minutes] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
    * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
    * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
@@ -405,16 +414,32 @@ export class OpenAI {
    * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
    * @param {boolean} [opts.dangerouslyAllowBrowser=false] - By default, client-side use of this library is not allowed, as it risks exposing your secret API credentials to attackers.
    */
-  constructor({
-    baseURL = readEnv('OPENAI_BASE_URL'),
-    apiKey = readEnv('OPENAI_API_KEY') ?? null,
-    adminAPIKey = readEnv('OPENAI_ADMIN_KEY') ?? null,
-    organization = readEnv('OPENAI_ORG_ID') ?? null,
-    project = readEnv('OPENAI_PROJECT_ID') ?? null,
-    webhookSecret = readEnv('OPENAI_WEBHOOK_SECRET') ?? null,
-    workloadIdentity,
-    ...opts
-  }: ClientOptions = {}) {
+  constructor(clientOptions: ClientOptions = {}) {
+    const provider = clientOptions.provider;
+    if (provider) {
+      const conflictingOptions = (['apiKey', 'adminAPIKey', 'workloadIdentity', 'baseURL'] as const).filter(
+        (key) => clientOptions[key] != null,
+      );
+      if (conflictingOptions.length) {
+        throw new Errors.OpenAIError(
+          `The \`provider\` option cannot be used with ${conflictingOptions
+            .map((key) => `\`${key}\``)
+            .join(', ')}. Configure authentication and the base URL through the provider instead.`,
+        );
+      }
+    }
+
+    const {
+      baseURL = provider ? null : readEnv('OPENAI_BASE_URL'),
+      apiKey = provider ? null : readEnv('OPENAI_API_KEY') ?? null,
+      adminAPIKey = provider ? null : readEnv('OPENAI_ADMIN_KEY') ?? null,
+      organization = provider ? null : readEnv('OPENAI_ORG_ID') ?? null,
+      project = provider ? null : readEnv('OPENAI_PROJECT_ID') ?? null,
+      webhookSecret = readEnv('OPENAI_WEBHOOK_SECRET') ?? null,
+      workloadIdentity,
+      ...opts
+    } = clientOptions;
+    const providerRuntime = provider ? configureProvider(provider) : undefined;
     const options: ClientOptions = {
       apiKey,
       adminAPIKey,
@@ -422,15 +447,16 @@ export class OpenAI {
       project,
       webhookSecret,
       workloadIdentity,
+      provider,
       ...opts,
-      baseURL: baseURL || `https://api.openai.com/v1`,
+      baseURL: providerRuntime?.baseURL ?? (baseURL || `https://api.openai.com/v1`),
     };
 
     if (apiKey && workloadIdentity) {
       throw new Errors.OpenAIError('The `apiKey` and `workloadIdentity` options are mutually exclusive');
     }
 
-    if (!apiKey && !adminAPIKey && !workloadIdentity) {
+    if (!providerRuntime && !apiKey && !adminAPIKey && !workloadIdentity) {
       throw new Errors.OpenAIError(
         'Missing credentials. Please pass an `apiKey`, `workloadIdentity`, `adminAPIKey`, or set the `OPENAI_API_KEY` or `OPENAI_ADMIN_KEY` environment variable.',
       );
@@ -457,7 +483,7 @@ export class OpenAI {
     this.fetch = options.fetch ?? Shims.getDefaultFetch();
     this.#encoder = Opts.FallbackEncoder;
 
-    const customHeadersEnv = readEnv('OPENAI_CUSTOM_HEADERS');
+    const customHeadersEnv = provider ? undefined : readEnv('OPENAI_CUSTOM_HEADERS');
     if (customHeadersEnv) {
       const parsed: Record<string, string> = {};
       for (const line of customHeadersEnv.split('\n')) {
@@ -470,6 +496,7 @@ export class OpenAI {
     }
 
     this._options = options;
+    this._provider = providerRuntime;
 
     if (workloadIdentity) {
       this._workloadIdentityAuth = new WorkloadIdentityAuth(workloadIdentity, this.fetch);
@@ -486,7 +513,9 @@ export class OpenAI {
    * Create a new client instance re-using the same options given to the current client with optional overriding.
    */
   withOptions(options: Partial<ClientOptions>): this {
-    const client = new (this.constructor as any as new (props: ClientOptions) => typeof this)({
+    const inheritedProvider = this._options.provider;
+    const provider = options.provider ?? inheritedProvider;
+    const inheritedOptions: ClientOptions = {
       ...this._options,
       baseURL: this.baseURL,
       maxRetries: this.maxRetries,
@@ -501,7 +530,23 @@ export class OpenAI {
       organization: this.organization,
       project: this.project,
       webhookSecret: this.webhookSecret,
+    };
+    if (provider) {
+      delete inheritedOptions.apiKey;
+      delete inheritedOptions.adminAPIKey;
+      delete inheritedOptions.workloadIdentity;
+      delete inheritedOptions.baseURL;
+      if (provider !== inheritedProvider) {
+        delete inheritedOptions.organization;
+        delete inheritedOptions.project;
+        delete inheritedOptions.defaultHeaders;
+      }
+    }
+
+    const client = new (this.constructor as any as new (props: ClientOptions) => typeof this)({
+      ...inheritedOptions,
       ...options,
+      provider,
     });
     return client;
   }
@@ -510,7 +555,7 @@ export class OpenAI {
    * Check whether the base URL is set to its default.
    */
   #baseURLOverridden(): boolean {
-    return this.baseURL !== 'https://api.openai.com/v1';
+    return this._provider !== undefined || this.baseURL !== 'https://api.openai.com/v1';
   }
 
   protected defaultQuery(): Record<string, string | undefined> | undefined {
@@ -592,6 +637,8 @@ export class OpenAI {
   }
 
   async _callApiKey(): Promise<boolean> {
+    if (this._provider) return false;
+
     const apiKey = this._options.apiKey;
     if (typeof apiKey !== 'function') return false;
 
@@ -644,6 +691,8 @@ export class OpenAI {
    * Used as a callback for mutating the given `FinalRequestOptions` object.
    */
   protected async prepareOptions(options: FinalRequestOptions): Promise<void> {
+    if (this._provider) return;
+
     const security = options.__security ?? { bearerAuth: true };
     if (security.bearerAuth) {
       await this._callApiKey();
@@ -718,6 +767,7 @@ export class OpenAI {
     });
 
     await this.prepareRequest(req, { url, options });
+    await this._provider?.prepareRequest?.(req, { url, options });
 
     /** Not an API request ID, just for correlating local log entries. */
     const requestLogID = 'log_' + ((Math.random() * (1 << 24)) | 0).toString(16).padStart(6, '0');
@@ -1115,13 +1165,17 @@ export class OpenAI {
         'OpenAI-Organization': this.organization,
         'OpenAI-Project': this.project,
       },
-      await this.authHeaders(options, options.__security ?? { bearerAuth: true }),
+      this._provider ? undefined : (
+        await this.authHeaders(options, options.__security ?? { bearerAuth: true })
+      ),
       this._options.defaultHeaders,
       bodyHeaders,
       options.headers,
     ]);
 
-    this.validateHeaders(headers, options.__security ?? { bearerAuth: true });
+    if (!this._provider) {
+      this.validateHeaders(headers, options.__security ?? { bearerAuth: true });
+    }
 
     return headers.values;
   }
@@ -1132,12 +1186,20 @@ export class OpenAI {
     return () => controller.abort();
   }
 
-  private buildBody({ options: { body, headers: rawHeaders } }: { options: FinalRequestOptions }): {
+  private buildBody({ options }: { options: FinalRequestOptions }): {
     bodyHeaders: HeadersLike;
     body: BodyInit | undefined;
     isStreamingBody: boolean;
   } {
+    const { body, headers: rawHeaders } = options;
     if (!body) {
+      // A resource method always passes a `body` key when its operation defines a
+      // request body, even if the caller omitted an optional body param. Keep the
+      // content-type for those, and only elide it for operations with no body at
+      // all (e.g. GET/DELETE).
+      if (body === undefined && 'body' in options) {
+        return { ...this.#encoder({ body, headers: buildHeaders([rawHeaders]) }), isStreamingBody: false };
+      }
       return { bodyHeaders: undefined, body: undefined, isStreamingBody: false };
     }
     const headers = buildHeaders([rawHeaders]);

package/src/helpers/zod.ts

@@ -34,6 +34,22 @@ function zodV4ToJsonSchema(schema: z4.ZodType): Record<string, unknown> {
   return toStrictJsonSchema(
     z4.toJSONSchema(schema, {
       target: 'draft-7',
+      override: ({ zodSchema, jsonSchema }) => {
+        const def = zodSchema._zod.def;
+
+        if (def.type === 'union' && 'discriminator' in def && Array.isArray(jsonSchema.oneOf)) {
+          if (jsonSchema.anyOf !== undefined) {
+            throw new Error(
+              'Zod discriminated union generated both `anyOf` and `oneOf`, which cannot be represented in an OpenAI strict schema',
+            );
+          }
+
+          // Discriminator values are mutually exclusive, so anyOf preserves the
+          // union while staying inside the API's supported JSON Schema subset.
+          jsonSchema.anyOf = jsonSchema.oneOf;
+          delete jsonSchema.oneOf;
+        }
+      },
     }) as JSONSchema,
   ) as Record<string, unknown>;
 }