@ai-sdk/openai 3.0.122 → 3.0.124

package/docs/03-openai.mdx

@@ -246,12 +246,13 @@ The following provider options are available:
   `.nullable()`.
 </Note>
 
-- **serviceTier** _'auto' | 'flex' | 'priority' | 'fast' | 'default'_
+- **serviceTier** _'auto' | 'flex' | 'priority' | 'fast' | 'ultrafast' | 'default'_
   Service tier for the request. Set to 'flex' for 50% cheaper processing
   at the cost of increased latency (available for o3, o4-mini, and gpt-5 models).
   Set to 'priority' for faster processing with Enterprise access (available for gpt-4, gpt-5, gpt-5-mini, o3, o4-mini; gpt-5-nano is not supported).
   'fast' is OpenAI's newer name for the 'priority' tier; the two are interchangeable, and responses from
   gpt-5.6 and earlier report `serviceTier: 'priority'` for either.
+  Set to 'ultrafast' for access-controlled Ultrafast processing (available only for gpt-5.6-sol).
 
   Defaults to 'auto'.
 
@@ -1943,13 +1944,14 @@ The following optional provider options are available for OpenAI chat models:
 
   Parameters for prediction mode.
 
-- **serviceTier** _'auto' | 'flex' | 'priority' | 'fast' | 'default'_
+- **serviceTier** _'auto' | 'flex' | 'priority' | 'fast' | 'ultrafast' | 'default'_
 
   Service tier for the request. Set to 'flex' for 50% cheaper processing
   at the cost of increased latency (available for o3, o4-mini, and gpt-5 models).
   Set to 'priority' for faster processing with Enterprise access (available for gpt-4, gpt-5, gpt-5-mini, o3, o4-mini; gpt-5-nano is not supported).
   'fast' is OpenAI's newer name for the 'priority' tier; the two are interchangeable, and responses from
   gpt-5.6 and earlier report `serviceTier: 'priority'` for either.
+  Set to 'ultrafast' for access-controlled Ultrafast processing (available only for gpt-5.6-sol).
 
   Defaults to 'auto'.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "3.0.122",
+  "version": "3.0.124",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",

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

@@ -23,6 +23,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import { openaiFailedResponseHandler } from '../openai-error';
 import { getOpenAILanguageModelCapabilities } from '../openai-language-model-capabilities';
+import { normalizeOpenAIJsonSchema } from '../normalize-openai-json-schema';
 import { throwIfOpenAIStreamErrorBeforeOutput } from '../openai-stream-error';
 import {
   convertOpenAIChatUsage,
@@ -168,7 +169,7 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
             ? {
                 type: 'json_schema',
                 json_schema: {
-                  schema: responseFormat.schema,
+                  schema: normalizeOpenAIJsonSchema(responseFormat.schema),
                   strict: strictJsonSchema,
                   name: responseFormat.name ?? 'response',
                   description: responseFormat.description,

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

@@ -144,12 +144,13 @@ export const openaiLanguageModelChatOptions = lazySchema(() =>
        * - 'flex': 50% cheaper processing at the cost of increased latency. Only available for o3 and o4-mini models.
        * - 'priority': Higher-speed processing with predictably low latency at premium cost. Available for Enterprise customers.
        * - 'fast': OpenAI's newer name for the 'priority' tier. Interchangeable with it.
+       * - 'ultrafast': Access-controlled Ultrafast processing. Only available for gpt-5.6-sol.
        * - 'default': The request will be processed with the standard pricing and performance for the selected model.
        *
        * @default 'auto'
        */
       serviceTier: z
-        .enum(['auto', 'flex', 'priority', 'fast', 'default'])
+        .enum(['auto', 'flex', 'priority', 'fast', 'ultrafast', 'default'])
         .optional(),
 
       /**

package/src/normalize-openai-json-schema.ts

@@ -0,0 +1,142 @@
+import type { JSONSchema7, JSONSchema7Definition } from '@ai-sdk/provider';
+
+/**
+ * OpenAI does not support `allOf`. Zod 4 uses a singleton `allOf` wrapper for
+ * recursive references, which can be rewritten to a direct reference.
+ */
+export function normalizeOpenAIJsonSchema(schema: JSONSchema7): JSONSchema7 {
+  const normalizedSchema = normalizeSchema(schema, true) as JSONSchema7;
+  const reference = getSingletonReference(normalizedSchema);
+
+  if (reference == null) {
+    return normalizedSchema;
+  }
+
+  const { allOf: _allOf, ...schemaWithoutAllOf } = normalizedSchema;
+  const referencedSchema = getLocalReferenceSchema(reference, normalizedSchema);
+
+  // OpenAI requires an object at the schema root, so expand local root refs.
+  return typeof referencedSchema !== 'object' || referencedSchema == null
+    ? normalizedSchema
+    : { ...referencedSchema, ...schemaWithoutAllOf };
+
+  function normalizeSchema(
+    schema: JSONSchema7Definition,
+    isRoot = false,
+  ): JSONSchema7Definition {
+    if (typeof schema !== 'object' || schema == null) {
+      return schema;
+    }
+
+    const normalizedSchema: JSONSchema7 = { ...schema };
+
+    if (normalizedSchema.properties != null) {
+      normalizedSchema.properties = normalizeSchemaRecord(
+        normalizedSchema.properties,
+      );
+    }
+
+    if (normalizedSchema.patternProperties != null) {
+      normalizedSchema.patternProperties = normalizeSchemaRecord(
+        normalizedSchema.patternProperties,
+      );
+    }
+
+    if (normalizedSchema.definitions != null) {
+      normalizedSchema.definitions = normalizeSchemaRecord(
+        normalizedSchema.definitions,
+      );
+    }
+
+    if (normalizedSchema.$defs != null) {
+      normalizedSchema.$defs = normalizeSchemaRecord(normalizedSchema.$defs);
+    }
+
+    if (normalizedSchema.items != null) {
+      normalizedSchema.items = Array.isArray(normalizedSchema.items)
+        ? normalizedSchema.items.map(item => normalizeSchema(item))
+        : normalizeSchema(normalizedSchema.items);
+    }
+
+    if (normalizedSchema.allOf != null) {
+      normalizedSchema.allOf = normalizedSchema.allOf.map(item =>
+        normalizeSchema(item),
+      );
+    }
+
+    if (normalizedSchema.anyOf != null) {
+      normalizedSchema.anyOf = normalizedSchema.anyOf.map(item =>
+        normalizeSchema(item),
+      );
+    }
+
+    if (normalizedSchema.oneOf != null) {
+      normalizedSchema.oneOf = normalizedSchema.oneOf.map(item =>
+        normalizeSchema(item),
+      );
+    }
+
+    if (
+      typeof normalizedSchema.additionalProperties === 'object' &&
+      normalizedSchema.additionalProperties != null
+    ) {
+      normalizedSchema.additionalProperties = normalizeSchema(
+        normalizedSchema.additionalProperties,
+      );
+    }
+
+    const reference = getSingletonReference(normalizedSchema);
+
+    if (reference == null || isRoot) {
+      return normalizedSchema;
+    }
+
+    const { allOf: _allOf, ...schemaWithoutAllOf } = normalizedSchema;
+    return { ...schemaWithoutAllOf, $ref: reference };
+  }
+
+  function normalizeSchemaRecord(
+    record: Record<string, JSONSchema7Definition>,
+  ): Record<string, JSONSchema7Definition> {
+    return Object.fromEntries(
+      Object.entries(record).map(([key, value]) => [
+        key,
+        normalizeSchema(value),
+      ]),
+    );
+  }
+
+  function getSingletonReference(schema: JSONSchema7): string | undefined {
+    if (schema.allOf?.length !== 1) {
+      return undefined;
+    }
+
+    const [allOfSchema] = schema.allOf;
+    return typeof allOfSchema === 'object' &&
+      allOfSchema != null &&
+      Object.keys(allOfSchema).length === 1 &&
+      typeof allOfSchema.$ref === 'string'
+      ? allOfSchema.$ref
+      : undefined;
+  }
+
+  function getLocalReferenceSchema(
+    reference: string,
+    schema: JSONSchema7,
+  ): JSONSchema7Definition | undefined {
+    const match = /^#\/(definitions|\$defs)\/(.+)$/.exec(reference);
+
+    if (match == null) {
+      return undefined;
+    }
+
+    const [, keyword, encodedName] = match;
+    const name = encodedName.replace(/~1/g, '/').replace(/~0/g, '~');
+    const definition =
+      keyword === 'definitions'
+        ? schema.definitions?.[name]
+        : schema.$defs?.[name];
+
+    return definition;
+  }
+}

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

@@ -30,6 +30,7 @@ import {
 import type { OpenAIConfig } from '../openai-config';
 import { openaiFailedResponseHandler } from '../openai-error';
 import { getOpenAILanguageModelCapabilities } from '../openai-language-model-capabilities';
+import { normalizeOpenAIJsonSchema } from '../normalize-openai-json-schema';
 import {
   createOpenAIProviderStreamError,
   throwIfOpenAIStreamErrorBeforeOutput,
@@ -422,7 +423,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                     strict: strictJsonSchema,
                     name: responseFormat.name ?? 'response',
                     description: responseFormat.description,
-                    schema: responseFormat.schema,
+                    schema: normalizeOpenAIJsonSchema(responseFormat.schema),
                   }
                 : { type: 'json_object' },
           }),

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

@@ -315,11 +315,12 @@ export const openaiLanguageModelResponsesOptionsSchema = lazySchema(() =>
        * Set to 'flex' for 50% cheaper processing at the cost of increased latency (available for o3, o4-mini, and gpt-5 models).
        * Set to 'priority' for faster processing with Enterprise access (available for gpt-4, gpt-5, gpt-5-mini, o3, o4-mini; gpt-5-nano is not supported).
        * Set to 'fast' for the same tier as 'priority' (OpenAI's newer name for it).
+       * Set to 'ultrafast' for access-controlled Ultrafast processing (available only for gpt-5.6-sol).
        *
        * Defaults to 'auto'.
        */
       serviceTier: z
-        .enum(['auto', 'flex', 'priority', 'fast', 'default'])
+        .enum(['auto', 'flex', 'priority', 'fast', 'ultrafast', 'default'])
         .nullish(),
 
       /**