@ai-sdk/openai 4.0.64 → 4.0.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.64",
+  "version": "4.0.66",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.12",
-    "@ai-sdk/provider-utils": "5.0.38"
+    "@ai-sdk/provider": "4.0.14",
+    "@ai-sdk/provider-utils": "5.0.40"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.1",

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

@@ -48,6 +48,7 @@ import {
   type OpenAIChatModelId,
 } from './openai-chat-language-model-options';
 import { prepareChatTools } from './openai-chat-prepare-tools';
+import { normalizeOpenAIJsonSchema } from '../normalize-openai-json-schema';
 
 type OpenAIChatConfig = {
   provider: string;
@@ -159,6 +160,14 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
     warnings.push(...messageWarnings);
 
     const strictJsonSchema = openaiOptions.strictJsonSchema ?? true;
+    const normalizedResponseFormatSchema =
+      responseFormat?.type === 'json' && responseFormat.schema != null
+        ? normalizeOpenAIJsonSchema(responseFormat.schema)
+        : undefined;
+
+    if (normalizedResponseFormatSchema != null) {
+      warnings.push(...normalizedResponseFormatSchema.warnings);
+    }
 
     const baseArgs = {
       // model id:
@@ -190,11 +199,11 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
       presence_penalty: presencePenalty,
       response_format:
         responseFormat?.type === 'json'
-          ? responseFormat.schema != null
+          ? normalizedResponseFormatSchema != null
             ? {
                 type: 'json_schema',
                 json_schema: {
-                  schema: responseFormat.schema,
+                  schema: normalizedResponseFormatSchema.schema,
                   strict: strictJsonSchema,
                   name: responseFormat.name ?? 'response',
                   description: responseFormat.description,

package/src/chat/openai-chat-prepare-tools.ts

@@ -7,6 +7,7 @@ import type {
   OpenAIChatToolChoice,
   OpenAIChatFunctionTool,
 } from './openai-chat-api';
+import { normalizeOpenAIJsonSchema } from '../normalize-openai-json-schema';
 
 export function prepareChatTools({
   tools,
@@ -32,17 +33,23 @@ export function prepareChatTools({
 
   for (const tool of tools) {
     switch (tool.type) {
-      case 'function':
+      case 'function': {
+        const normalizedInputSchema = normalizeOpenAIJsonSchema(
+          tool.inputSchema,
+        );
+        toolWarnings.push(...normalizedInputSchema.warnings);
+
         openaiTools.push({
           type: 'function',
           function: {
             name: tool.name,
             description: tool.description,
-            parameters: tool.inputSchema,
+            parameters: normalizedInputSchema.schema,
             ...(tool.strict != null ? { strict: tool.strict } : {}),
           },
         });
         break;
+      }
       default:
         toolWarnings.push({
           type: 'unsupported',

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

@@ -0,0 +1,161 @@
+import {
+  UnsupportedFunctionalityError,
+  type JSONSchema7,
+  type JSONSchema7Definition,
+  type SharedV4Warning,
+} from '@ai-sdk/provider';
+
+/**
+ * Normalizes JSON Schema for OpenAI structured outputs.
+ *
+ * OpenAI does not support the JSON Schema `propertyNames` keyword. Property
+ * names in JSON objects are always strings, so string-based constraints can be
+ * left to client-side validation after removing the keyword. This
+ * compatibility layer does not rewrite non-string property name schemas.
+ */
+export function normalizeOpenAIJsonSchema(schema: JSONSchema7): {
+  schema: JSONSchema7;
+  warnings: SharedV4Warning[];
+} {
+  let removedPropertyNames = false;
+
+  const normalizedSchema = normalizeSchema(schema);
+
+  return {
+    schema: normalizedSchema,
+    warnings: removedPropertyNames
+      ? [
+          {
+            type: 'compatibility',
+            feature: 'JSON Schema propertyNames',
+            details:
+              'OpenAI does not support JSON Schema propertyNames. It was removed before sending the schema, so OpenAI will not enforce property-name constraints.',
+          },
+        ]
+      : [],
+  };
+
+  function normalizeSchema(schema: JSONSchema7): JSONSchema7 {
+    const propertyNames = schema.propertyNames;
+
+    if (propertyNames != null) {
+      if (
+        typeof propertyNames === 'boolean' ||
+        propertyNames.type !== 'string'
+      ) {
+        throw new UnsupportedFunctionalityError({
+          functionality:
+            'JSON Schema propertyNames that does not use a string schema',
+        });
+      }
+
+      removedPropertyNames = true;
+    }
+
+    const normalizedSchema = { ...schema };
+    delete normalizedSchema.propertyNames;
+
+    if (normalizedSchema.properties != null) {
+      normalizedSchema.properties = normalizeSchemaRecord(
+        normalizedSchema.properties,
+      );
+    }
+
+    if (normalizedSchema.patternProperties != null) {
+      normalizedSchema.patternProperties = normalizeSchemaRecord(
+        normalizedSchema.patternProperties,
+      );
+    }
+
+    if (normalizedSchema.additionalProperties != null) {
+      normalizedSchema.additionalProperties = normalizeDefinition(
+        normalizedSchema.additionalProperties,
+      );
+    }
+
+    if (normalizedSchema.additionalItems != null) {
+      normalizedSchema.additionalItems = normalizeDefinition(
+        normalizedSchema.additionalItems,
+      );
+    }
+
+    if (normalizedSchema.items != null) {
+      normalizedSchema.items = Array.isArray(normalizedSchema.items)
+        ? normalizedSchema.items.map(normalizeDefinition)
+        : normalizeDefinition(normalizedSchema.items);
+    }
+
+    if (normalizedSchema.contains != null) {
+      normalizedSchema.contains = normalizeDefinition(
+        normalizedSchema.contains,
+      );
+    }
+
+    if (normalizedSchema.not != null) {
+      normalizedSchema.not = normalizeDefinition(normalizedSchema.not);
+    }
+
+    if (normalizedSchema.allOf != null) {
+      normalizedSchema.allOf = normalizedSchema.allOf.map(normalizeDefinition);
+    }
+
+    if (normalizedSchema.anyOf != null) {
+      normalizedSchema.anyOf = normalizedSchema.anyOf.map(normalizeDefinition);
+    }
+
+    if (normalizedSchema.oneOf != null) {
+      normalizedSchema.oneOf = normalizedSchema.oneOf.map(normalizeDefinition);
+    }
+
+    if (normalizedSchema.definitions != null) {
+      normalizedSchema.definitions = normalizeSchemaRecord(
+        normalizedSchema.definitions,
+      );
+    }
+
+    if (normalizedSchema.$defs != null) {
+      normalizedSchema.$defs = normalizeSchemaRecord(normalizedSchema.$defs);
+    }
+
+    if (normalizedSchema.dependencies != null) {
+      normalizedSchema.dependencies = Object.fromEntries(
+        Object.entries(normalizedSchema.dependencies).map(
+          ([key, dependency]) => [
+            key,
+            Array.isArray(dependency)
+              ? dependency
+              : normalizeDefinition(dependency),
+          ],
+        ),
+      );
+    }
+
+    for (const keyword of ['if', 'then', 'else'] as const) {
+      const conditionalSchema = normalizedSchema[keyword];
+      if (conditionalSchema != null) {
+        normalizedSchema[keyword] = normalizeDefinition(conditionalSchema);
+      }
+    }
+
+    return normalizedSchema;
+  }
+
+  function normalizeSchemaRecord(
+    schemas: Record<string, JSONSchema7Definition>,
+  ): Record<string, JSONSchema7Definition> {
+    return Object.fromEntries(
+      Object.entries(schemas).map(([key, schema]) => [
+        key,
+        normalizeDefinition(schema),
+      ]),
+    );
+  }
+
+  function normalizeDefinition(
+    definition: JSONSchema7Definition,
+  ): JSONSchema7Definition {
+    return typeof definition === 'boolean'
+      ? definition
+      : normalizeSchema(definition);
+  }
+}

package/src/openai-batch.ts

@@ -1,11 +1,15 @@
 import {
   InvalidArgumentError,
   InvalidResponseDataError,
+  UnsupportedFunctionalityError,
   type Experimental_BatchV4 as BatchV4,
+  type Experimental_BatchV4CancelResult as BatchV4CancelResult,
   type Experimental_BatchV4StartResult as BatchV4StartResult,
   type Experimental_BatchV4Error as BatchV4Error,
   type Experimental_BatchV4ItemResult as BatchV4ItemResult,
   type Experimental_BatchV4OperationOptions as BatchV4OperationOptions,
+  type Experimental_BatchV4ListOptions as BatchV4ListOptions,
+  type Experimental_BatchV4ListResult as BatchV4ListResult,
   type Experimental_BatchV4Status as BatchV4Status,
   type Experimental_TextBatchV4ItemResult as TextBatchV4ItemResult,
   type Experimental_BatchV4StartOptions as BatchV4StartOptions,
@@ -86,36 +90,51 @@ type OpenAIBatchResultConversion =
   | { success: true; result: LanguageModelV4GenerateResult }
   | { success: false; error: BatchV4Error };
 
+function assertTextBatchRequests(
+  requests: BatchV4StartOptions['requests'],
+): asserts requests is ReadonlyArray<OpenAIBatchRequest> {
+  for (const request of requests) {
+    const requestType = request.type;
+    if (requestType !== 'text') {
+      throw new UnsupportedFunctionalityError({
+        functionality: `batch request type: ${requestType}`,
+        message: `The OpenAI Batch API does not support batch requests with type "${requestType}".`,
+      });
+    }
+  }
+}
+
+const openaiBatchResponseZodSchema = () =>
+  z.object({
+    id: z.string(),
+    status: z.string(),
+    output_file_id: z.string().nullish(),
+    error_file_id: z.string().nullish(),
+    created_at: z.number().nullish(),
+    expires_at: z.number().nullish(),
+    request_counts: z
+      .object({
+        total: z.number().nullish(),
+        completed: z.number().nullish(),
+        failed: z.number().nullish(),
+      })
+      .nullish(),
+    errors: z
+      .object({
+        data: z
+          .array(
+            z.object({
+              code: z.string().nullish(),
+              message: z.string().nullish(),
+            }),
+          )
+          .nullish(),
+      })
+      .nullish(),
+  });
+
 const openaiBatchResponseSchema = lazySchema(() =>
-  zodSchema(
-    z.object({
-      id: z.string(),
-      status: z.string(),
-      output_file_id: z.string().nullish(),
-      error_file_id: z.string().nullish(),
-      created_at: z.number().nullish(),
-      expires_at: z.number().nullish(),
-      request_counts: z
-        .object({
-          total: z.number().nullish(),
-          completed: z.number().nullish(),
-          failed: z.number().nullish(),
-        })
-        .nullish(),
-      errors: z
-        .object({
-          data: z
-            .array(
-              z.object({
-                code: z.string().nullish(),
-                message: z.string().nullish(),
-              }),
-            )
-            .nullish(),
-        })
-        .nullish(),
-    }),
-  ),
+  zodSchema(openaiBatchResponseZodSchema()),
 );
 
 type OpenAIBatchResponse = InferSchema<typeof openaiBatchResponseSchema>;
@@ -141,6 +160,16 @@ const openaiBatchResultLineSchema = lazySchema(() =>
   ),
 );
 
+const openaiBatchListResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      data: z.array(openaiBatchResponseZodSchema()),
+      has_more: z.boolean(),
+      last_id: z.string().nullish(),
+    }),
+  ),
+);
+
 type OpenAIBatchResultLine = InferSchema<typeof openaiBatchResultLineSchema>;
 
 export class OpenAIBatch implements BatchV4<OpenAIBatchModelIds> {
@@ -160,6 +189,7 @@ export class OpenAIBatch implements BatchV4<OpenAIBatchModelIds> {
   async doStartBatch(
     options: BatchV4StartOptions<OpenAIBatchModelIds>,
   ): Promise<BatchV4StartResult> {
+    assertTextBatchRequests(options.requests);
     validateSingleModel(options.requests);
 
     const fileParts: string[] = [];
@@ -319,6 +349,58 @@ export class OpenAIBatch implements BatchV4<OpenAIBatchModelIds> {
     return convertOpenAIBatchStatus(batch);
   }
 
+  async doCancelBatch(
+    options: BatchV4OperationOptions,
+  ): Promise<BatchV4CancelResult> {
+    await postJsonToApi({
+      url: this.getUrl(
+        `/batches/${encodeURIComponent(options.batchId)}/cancel`,
+      ),
+      headers: combineHeaders(this.options.config.headers?.(), options.headers),
+      body: {},
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiBatchResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.options.config.fetch,
+    });
+
+    return {};
+  }
+
+  async doListBatches(options: BatchV4ListOptions): Promise<BatchV4ListResult> {
+    const url = new URL(this.getUrl('/batches'));
+    if (options.limit != null) {
+      url.searchParams.set('limit', String(options.limit));
+    }
+    if (options.cursor != null) {
+      url.searchParams.set('after', options.cursor);
+    }
+
+    const { value: page } = await getFromApi({
+      url: url.toString(),
+      headers: combineHeaders(this.options.config.headers?.(), options.headers),
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiBatchListResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.options.config.fetch,
+      validateUrl: false,
+    });
+
+    return {
+      batches: page.data.map(batch => ({
+        batchId: batch.id,
+        ...convertOpenAIBatchStatus(batch),
+      })),
+      ...(page.has_more && page.last_id != null
+        ? { nextCursor: page.last_id }
+        : {}),
+    };
+  }
+
   async doGetBatchResults(
     options: BatchV4OperationOptions,
   ): Promise<ReadableStream<BatchV4ItemResult>> {

package/src/openai-config.ts

@@ -24,6 +24,13 @@ export type OpenAIConfig = {
    * @see https://github.com/vercel/ai/issues/20180
    */
   explicitMessageItemType?: boolean;
+  /**
+   * Whether the provider supports the
+   * `web_search_call.action.sources` Responses API include value.
+   *
+   * Defaults to `true`.
+   */
+  supportsWebSearchSourcesInclude?: boolean;
   /**
    * This is soft-deprecated. Use provider references (e.g. `{ openai: 'file-abc123' }`)
    * in file part data instead. File ID prefixes used to identify file IDs

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

@@ -179,6 +179,15 @@ export const openaiLanguageModelResponsesOptionsSchema = lazySchema(() =>
         )
         .nullish(),
 
+      /**
+       * Whether to automatically include web search action sources in the
+       * response. Disable this for OpenAI-compatible providers that do not
+       * support the `web_search_call.action.sources` include value.
+       *
+       * Defaults to `true`.
+       */
+      includeWebSearchSources: z.boolean().optional(),
+
       /**
        * Instructions for the model.
        * They can be used to change the system or developer message when continuing a conversation using the `previousResponseId` option.

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

@@ -70,6 +70,7 @@ import {
   isUndeclaredParallelToolCall,
 } from './expand-parallel-tool-call';
 import { mapOpenAIResponseFinishReason } from './map-openai-responses-finish-reason';
+import { normalizeOpenAIJsonSchema } from '../normalize-openai-json-schema';
 import {
   openaiResponsesChunkSchema,
   openaiResponsesResponseSchema,
@@ -444,6 +445,14 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     }
 
     const strictJsonSchema = openaiOptions?.strictJsonSchema ?? true;
+    const normalizedResponseFormatSchema =
+      responseFormat?.type === 'json' && responseFormat.schema != null
+        ? normalizeOpenAIJsonSchema(responseFormat.schema)
+        : undefined;
+
+    if (normalizedResponseFormatSchema != null) {
+      warnings.push(...normalizedResponseFormatSchema.warnings);
+    }
 
     let include: OpenAIResponsesIncludeOptions = openaiOptions?.include;
 
@@ -486,7 +495,11 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
       ) as LanguageModelV4ProviderTool | undefined
     )?.name;
 
-    if (webSearchToolName) {
+    if (
+      webSearchToolName &&
+      config.supportsWebSearchSourcesInclude !== false &&
+      openaiOptions?.includeWebSearchSources !== false
+    ) {
       addInclude('web_search_call.action.sources');
     }
 
@@ -513,13 +526,13 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
         text: {
           ...(responseFormat?.type === 'json' && {
             format:
-              responseFormat.schema != null
+              normalizedResponseFormatSchema != null
                 ? {
                     type: 'json_schema',
                     strict: strictJsonSchema,
                     name: responseFormat.name ?? 'response',
                     description: responseFormat.description,
-                    schema: responseFormat.schema,
+                    schema: normalizedResponseFormatSchema.schema,
                   }
                 : { type: 'json_object' },
           }),

package/src/responses/openai-responses-prepare-tools.ts

@@ -21,6 +21,7 @@ import { shellArgsSchema } from '../tool/shell';
 import { toolSearchArgsSchema } from '../tool/tool-search';
 import { webSearchArgsSchema } from '../tool/web-search';
 import { webSearchPreviewArgsSchema } from '../tool/web-search-preview';
+import { normalizeOpenAIJsonSchema } from '../normalize-openai-json-schema';
 import type {
   OpenAIResponsesAllowedTool,
   OpenAIResponsesFunctionTool,
@@ -147,6 +148,7 @@ export async function prepareResponsesTools({
         const openaiFunctionTool = prepareFunctionTool({
           tool,
           options: openaiOptions,
+          toolWarnings,
           async: resolveAsyncToolOption({
             value: openaiOptions?.async,
             supportsAsyncToolCalling,
@@ -627,19 +629,31 @@ function toAllowedToolResolution(
 function prepareFunctionTool({
   tool,
   options,
+  toolWarnings,
   async,
 }: {
   tool: LanguageModelV4FunctionTool;
   options: OpenAIToolOptions | undefined;
+  toolWarnings: SharedV4Warning[];
   async: boolean | undefined;
 }): OpenAIResponsesFunctionTool {
   const deferLoading = options?.deferLoading;
+  const normalizedInputSchema = normalizeOpenAIJsonSchema(tool.inputSchema);
+  const normalizedOutputSchema =
+    options?.outputSchema != null
+      ? normalizeOpenAIJsonSchema(options.outputSchema as JSONSchema7)
+      : undefined;
+
+  toolWarnings.push(
+    ...normalizedInputSchema.warnings,
+    ...(normalizedOutputSchema?.warnings ?? []),
+  );
 
   return {
     type: 'function',
     name: tool.name,
     description: tool.description,
-    parameters: tool.inputSchema,
+    parameters: normalizedInputSchema.schema,
     ...(async != null ? { async } : {}),
     ...(tool.strict != null ? { strict: tool.strict } : {}),
     ...(deferLoading != null ? { defer_loading: deferLoading } : {}),
@@ -647,7 +661,7 @@ function prepareFunctionTool({
       ? { allowed_callers: options.allowedCallers }
       : {}),
     ...(options?.outputSchema != null
-      ? { output_schema: options.outputSchema as JSONSchema7 }
+      ? { output_schema: normalizedOutputSchema?.schema }
       : {}),
   };
 }