@ai-sdk/openai 3.0.123 → 3.0.125

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "3.0.123",
+  "version": "3.0.125",
   "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/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/convert-to-openai-responses-input.ts

@@ -12,6 +12,7 @@ import {
   isNonNullable,
   parseJSON,
   parseProviderOptions,
+  safeValidateTypes,
   validateTypes,
   type ToolNameMapping,
 } from '@ai-sdk/provider-utils';
@@ -30,11 +31,13 @@ import {
   toolSearchInputSchema,
   toolSearchOutputSchema,
 } from '../tool/tool-search';
+import { webSearchOutputSchema } from '../tool/web-search';
 import type {
   OpenAIResponsesCustomToolCallOutput,
   OpenAIResponsesFunctionCallOutput,
   OpenAIResponsesInput,
   OpenAIResponsesReasoning,
+  OpenAIResponsesWebSearchCall,
 } from './openai-responses-api';
 import {
   getParallelToolCallMetadata,
@@ -45,6 +48,65 @@ function serializeToolCallArguments(input: unknown): string {
   return JSON.stringify(input === undefined ? {} : input);
 }
 
+async function convertWebSearchToolResultOutput({
+  output,
+  id,
+}: {
+  output: LanguageModelV3ToolResultOutput;
+  id: string;
+}): Promise<OpenAIResponsesWebSearchCall | undefined> {
+  if (output.type !== 'json') {
+    return undefined;
+  }
+
+  const validation = await safeValidateTypes({
+    value: output.value,
+    schema: webSearchOutputSchema,
+  });
+
+  if (!validation.success || validation.value.action == null) {
+    return undefined;
+  }
+
+  const { action, sources } = validation.value;
+
+  switch (action.type) {
+    case 'search':
+      return {
+        type: 'web_search_call',
+        id,
+        status: 'completed',
+        action: {
+          type: 'search',
+          ...(action.query != null && { query: action.query }),
+          ...(action.queries != null && { queries: action.queries }),
+          ...(sources != null && { sources }),
+        },
+      };
+    case 'openPage':
+      return {
+        type: 'web_search_call',
+        id,
+        status: 'completed',
+        action: {
+          type: 'open_page',
+          url: action.url,
+        },
+      };
+    case 'findInPage':
+      return {
+        type: 'web_search_call',
+        id,
+        status: 'completed',
+        action: {
+          type: 'find_in_page',
+          url: action.url,
+          pattern: action.pattern,
+        },
+      };
+  }
+}
+
 async function convertFunctionToolResultOutput({
   output,
   promptCacheBreakpoint,
@@ -865,6 +927,33 @@ export async function convertToOpenAIResponsesInput({
                 part.toolName,
               );
 
+              if (
+                resolvedResultToolName === 'web_search' ||
+                resolvedResultToolName === 'web_search_preview'
+              ) {
+                const itemId =
+                  (
+                    part.providerOptions?.[providerOptionsName] as
+                      | { itemId?: string }
+                      | undefined
+                  )?.itemId ?? part.toolCallId;
+
+                if (store) {
+                  input.push({ type: 'item_reference', id: itemId });
+                  break;
+                }
+
+                const webSearchCall = await convertWebSearchToolResultOutput({
+                  output: part.output,
+                  id: itemId,
+                });
+
+                if (webSearchCall != null) {
+                  input.push(webSearchCall);
+                  break;
+                }
+              }
+
               if (part.toolName === toolSearchToolName) {
                 const itemId = (part.providerOptions?.[providerOptionsName]
                   ?.itemId ??

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

@@ -86,6 +86,7 @@ export type OpenAIResponsesInputItem =
   | OpenAIResponsesApplyPatchCallOutput
   | OpenAIResponsesToolSearchCall
   | OpenAIResponsesToolSearchOutput
+  | OpenAIResponsesWebSearchCall
   | OpenAIResponsesReasoning
   | OpenAIResponsesItemReference
   | OpenAIResponsesConfigurationUpdate;
@@ -228,6 +229,13 @@ export type OpenAIResponsesFunctionCallOutput = {
       >;
 };
 
+export type OpenAIResponsesWebSearchCall = {
+  type: 'web_search_call';
+  id: string;
+  status: 'completed';
+  action: OpenAIResponsesWebSearchAction;
+};
+
 export type OpenAIResponsesCustomToolCall = {
   type: 'custom_tool_call';
   id?: string;
@@ -612,7 +620,7 @@ const openaiResponsesNestedErrorChunkSchema = z.object({
   sequence_number: z.number(),
   error: z.object({
     type: z.string(),
-    code: z.string(),
+    code: z.string().nullish(),
     message: z.string(),
     param: z.string().nullish(),
   }),

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' },
           }),