@ai-sdk/openai 4.0.52 → 4.0.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.52",
+  "version": "4.0.54",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

package/src/openai-config.ts

@@ -3,10 +3,17 @@ import type {
   WebSocketConstructor,
 } from '@ai-sdk/provider-utils';
 
+type OpenAIHeaders = Record<string, string | undefined>;
+
+type SerializedOpenAIConfig = Omit<Partial<OpenAIConfig>, 'headers'> & {
+  headers?: (() => OpenAIHeaders) | OpenAIHeaders;
+};
+
 export type OpenAIConfig = {
   provider: string;
+  baseURL?: string;
   url: (options: { modelId: string; path: string }) => string;
-  headers?: () => Record<string, string | undefined>;
+  headers?: () => OpenAIHeaders;
   fetch?: FetchFunction;
   webSocket?: WebSocketConstructor;
   generateId?: () => string;
@@ -20,3 +27,36 @@ export type OpenAIConfig = {
    */
   fileIdPrefixes?: readonly string[];
 };
+
+export function prepareOpenAIConfigForWorkflowDeserialize(
+  config: SerializedOpenAIConfig,
+): OpenAIConfig {
+  if (config.provider == null) {
+    throw new Error(
+      'OpenAI model is missing provider after workflow deserialization.',
+    );
+  }
+
+  return {
+    ...config,
+    provider: config.provider,
+    url:
+      typeof config.url === 'function'
+        ? config.url
+        : ({ path }) => {
+            if (config.baseURL == null) {
+              throw new Error(
+                'OpenAI model is missing baseURL after workflow deserialization.',
+              );
+            }
+
+            return `${config.baseURL}${path}`;
+          },
+    headers:
+      typeof config.headers === 'function'
+        ? config.headers
+        : config.headers == null
+          ? undefined
+          : () => config.headers as OpenAIHeaders,
+  };
+}

package/src/openai-provider.ts

@@ -308,6 +308,7 @@ export function createOpenAI(
   const createResponsesModel = (modelId: OpenAIResponsesModelId) => {
     return new OpenAIResponsesBatchLanguageModel(modelId, {
       provider: `${providerName}.responses`,
+      baseURL,
       url: ({ path }) => `${baseURL}${path}`,
       headers: getHeaders,
       fetch: options.fetch,

package/src/openai-responses-batch.ts

@@ -33,7 +33,10 @@ import {
   openaiErrorDataSchema,
   openaiFailedResponseHandler,
 } from './openai-error';
-import type { OpenAIConfig } from './openai-config';
+import {
+  prepareOpenAIConfigForWorkflowDeserialize,
+  type OpenAIConfig,
+} from './openai-config';
 import { openaiFilesResponseSchema } from './files/openai-files-api';
 import { convertOpenAIResponsesUsage } from './responses/convert-openai-responses-usage';
 import { mapOpenAIResponseFinishReason } from './responses/map-openai-responses-finish-reason';
@@ -41,7 +44,10 @@ import {
   openaiResponsesResponseSchema,
   type OpenAIResponsesLogprobs,
 } from './responses/openai-responses-api';
-import { OpenAIResponsesLanguageModel } from './responses/openai-responses-language-model';
+import {
+  mapWebSearchOutput,
+  OpenAIResponsesLanguageModel,
+} from './responses/openai-responses-language-model';
 import type { OpenAIResponsesModelId } from './responses/openai-responses-language-model-options';
 import type { ResponsesReasoningProviderMetadata } from './responses/openai-responses-provider-metadata';
 
@@ -163,6 +169,23 @@ class OpenAIResponsesBatch {
       for (const warning of preparedRequest.warnings) {
         warnings.push({ requestId: request.id, warning });
       }
+
+      for (const tool of request.options.tools ?? []) {
+        if (
+          tool.type === 'provider' &&
+          !openAIBatchConvertibleProviderToolIds.has(tool.id)
+        ) {
+          warnings.push({
+            requestId: request.id,
+            warning: {
+              type: 'unsupported',
+              feature: `batch result conversion for tool "${tool.name}"`,
+              details:
+                'OpenAI may return output for this tool that AI SDK text batches cannot currently convert.',
+            },
+          });
+        }
+      }
     }
 
     const filename = 'batch.jsonl';
@@ -382,6 +405,14 @@ class OpenAIResponsesBatch {
   }
 }
 
+const openAIBatchConvertibleProviderToolIds = new Set([
+  'openai.code_interpreter',
+  'openai.custom',
+  'openai.file_search',
+  'openai.web_search',
+  'openai.web_search_preview',
+]);
+
 export class OpenAIResponsesBatchLanguageModel
   extends OpenAIResponsesLanguageModel
   implements BatchLanguageModelV4
@@ -393,12 +424,12 @@ export class OpenAIResponsesBatchLanguageModel
   }
 
   static [WORKFLOW_DESERIALIZE](options: {
-    modelId: OpenAIResponsesModelId;
-    config: OpenAIConfig;
+    modelId: string;
+    config: Parameters<typeof prepareOpenAIConfigForWorkflowDeserialize>[0];
   }) {
     return new OpenAIResponsesBatchLanguageModel(
-      options.modelId,
-      options.config,
+      options.modelId as OpenAIResponsesModelId,
+      prepareOpenAIConfigForWorkflowDeserialize(options.config),
     );
   }
 
@@ -577,6 +608,7 @@ async function convertOpenAIResponsesBatchResponse(
 
   const content: LanguageModelV4GenerateResult['content'] = [];
   const logprobs: Array<NonNullable<OpenAIResponsesLogprobs>> = [];
+  let hasFunctionCall = false;
 
   for (const part of response.output) {
     switch (part.type) {
@@ -612,15 +644,104 @@ async function convertOpenAIResponsesBatchResponse(
       }
 
       case 'function_call':
+        hasFunctionCall = true;
+        content.push({
+          type: 'tool-call',
+          toolCallId: part.call_id,
+          toolName: part.name,
+          input: part.arguments,
+          providerMetadata: {
+            openai: {
+              itemId: part.id,
+              ...(part.namespace != null && { namespace: part.namespace }),
+              ...(part.caller != null && {
+                caller:
+                  part.caller.type === 'program'
+                    ? { type: 'program', callerId: part.caller.caller_id }
+                    : part.caller,
+              }),
+            },
+          },
+        });
+        break;
+
       case 'custom_tool_call':
-        return {
-          success: false,
-          error: {
-            message:
-              'OpenAI returned a tool call, but tool calls are not supported in AI SDK text batches.',
-            code: 'unsupported_content',
+        hasFunctionCall = true;
+        content.push({
+          type: 'tool-call',
+          toolCallId: part.call_id,
+          toolName: part.name,
+          input: JSON.stringify(part.input),
+          providerMetadata: { openai: { itemId: part.id } },
+        });
+        break;
+
+      case 'web_search_call':
+        content.push({
+          type: 'tool-call',
+          toolCallId: part.id,
+          toolName: 'web_search',
+          input: '{}',
+          providerExecuted: true,
+          dynamic: true,
+        });
+        content.push({
+          type: 'tool-result',
+          toolCallId: part.id,
+          toolName: 'web_search',
+          result: mapWebSearchOutput(part.action),
+          dynamic: true,
+        });
+        break;
+
+      case 'file_search_call':
+        content.push({
+          type: 'tool-call',
+          toolCallId: part.id,
+          toolName: 'file_search',
+          input: '{}',
+          providerExecuted: true,
+          dynamic: true,
+        });
+        content.push({
+          type: 'tool-result',
+          toolCallId: part.id,
+          toolName: 'file_search',
+          result: {
+            queries: part.queries,
+            results:
+              part.results?.map(result => ({
+                attributes: result.attributes,
+                fileId: result.file_id,
+                filename: result.filename,
+                score: result.score,
+                text: result.text,
+              })) ?? null,
           },
-        };
+          dynamic: true,
+        });
+        break;
+
+      case 'code_interpreter_call':
+        content.push({
+          type: 'tool-call',
+          toolCallId: part.id,
+          toolName: 'code_interpreter',
+          input: JSON.stringify({
+            code: part.code,
+            containerId: part.container_id,
+          }),
+          providerExecuted: true,
+          dynamic: true,
+        });
+        content.push({
+          type: 'tool-result',
+          toolCallId: part.id,
+          toolName: 'code_interpreter',
+          result: { outputs: part.outputs },
+          dynamic: true,
+        });
+        break;
 
       default:
         return {
@@ -655,7 +776,7 @@ async function convertOpenAIResponsesBatchResponse(
       finishReason: {
         unified: mapOpenAIResponseFinishReason({
           finishReason: response.incomplete_details?.reason,
-          hasFunctionCall: false,
+          hasFunctionCall,
         }),
         raw: response.incomplete_details?.reason ?? undefined,
       },

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

@@ -831,24 +831,26 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
         type: z.enum(['response.completed', 'response.incomplete']),
         response: z.object({
           incomplete_details: z.object({ reason: z.string() }).nullish(),
-          usage: z.object({
-            input_tokens: z.number(),
-            input_tokens_details: z
-              .object({
-                cached_tokens: z.number().nullish(),
-                cache_write_tokens: z.number().nullish(),
-                orchestration_input_tokens: z.number().nullish(),
-                orchestration_input_cached_tokens: z.number().nullish(),
-              })
-              .nullish(),
-            output_tokens: z.number(),
-            output_tokens_details: z
-              .object({
-                reasoning_tokens: z.number().nullish(),
-                orchestration_output_tokens: z.number().nullish(),
-              })
-              .nullish(),
-          }),
+          usage: z
+            .object({
+              input_tokens: z.number(),
+              input_tokens_details: z
+                .object({
+                  cached_tokens: z.number().nullish(),
+                  cache_write_tokens: z.number().nullish(),
+                  orchestration_input_tokens: z.number().nullish(),
+                  orchestration_input_cached_tokens: z.number().nullish(),
+                })
+                .nullish(),
+              output_tokens: z.number(),
+              output_tokens_details: z
+                .object({
+                  reasoning_tokens: z.number().nullish(),
+                  orchestration_output_tokens: z.number().nullish(),
+                })
+                .nullish(),
+            })
+            .nullish(),
           reasoning: z
             .object({
               context: z.string().nullish(),
@@ -1762,7 +1764,7 @@ export const openaiResponsesResponseSchema = lazySchema(() =>
             })
             .nullish(),
         })
-        .optional(),
+        .nullish(),
     }),
   ),
 );

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

@@ -30,7 +30,10 @@ import {
   type InferSchema,
   type ParseResult,
 } from '@ai-sdk/provider-utils';
-import type { OpenAIConfig } from '../openai-config';
+import {
+  prepareOpenAIConfigForWorkflowDeserialize,
+  type OpenAIConfig,
+} from '../openai-config';
 import { openaiFailedResponseHandler } from '../openai-error';
 import { getOpenAILanguageModelCapabilities } from '../openai-language-model-capabilities';
 import {
@@ -214,10 +217,13 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
   }
 
   static [WORKFLOW_DESERIALIZE](options: {
-    modelId: OpenAIResponsesModelId;
-    config: OpenAIConfig;
+    modelId: string;
+    config: Parameters<typeof prepareOpenAIConfigForWorkflowDeserialize>[0];
   }) {
-    return new OpenAIResponsesLanguageModel(options.modelId, options.config);
+    return new OpenAIResponsesLanguageModel(
+      options.modelId as OpenAIResponsesModelId,
+      prepareOpenAIConfigForWorkflowDeserialize(options.config),
+    );
   }
 
   constructor(modelId: OpenAIResponsesModelId, config: OpenAIConfig) {
@@ -2578,7 +2584,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
                   raw: value.response.incomplete_details?.reason ?? undefined,
                 };
               }
-              usage = value.response.usage;
+              usage = value.response.usage ?? undefined;
               if (typeof value.response.service_tier === 'string') {
                 serviceTier = value.response.service_tier;
               }
@@ -2909,7 +2915,7 @@ function isResponseOutputChunk(chunk: OpenAIResponsesChunk): boolean {
   );
 }
 
-function mapWebSearchOutput(
+export function mapWebSearchOutput(
   action: OpenAIResponsesWebSearchAction | null | undefined,
 ): InferSchema<typeof webSearchOutputSchema> {
   if (action == null) {