@ai-sdk/openai 4.0.53 → 4.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.53",
+  "version": "4.0.55",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.9",
-    "@ai-sdk/provider-utils": "5.0.34"
+    "@ai-sdk/provider": "4.0.10",
+    "@ai-sdk/provider-utils": "5.0.35"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.1",

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

@@ -15,3 +15,13 @@ export const openaiFilesResponseSchema = lazySchema(() =>
     }),
   ),
 );
+
+export const openaiFileDeleteResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      id: z.string(),
+      object: z.string().nullish(),
+      deleted: z.boolean(),
+    }),
+  ),
+);

package/src/files/openai-files.ts

@@ -1,22 +1,40 @@
-import type {
-  FilesV4,
-  FilesV4UploadFileCallOptions,
-  FilesV4UploadFileResult,
+import {
+  InvalidArgumentError,
+  type FilesV4,
+  type FilesV4DeleteFileCallOptions,
+  type FilesV4DeleteFileResult,
+  type FilesV4DownloadFileCallOptions,
+  type FilesV4DownloadFileResult,
+  type FilesV4GetFileMetadataCallOptions,
+  type FilesV4GetFileMetadataResult,
+  type FilesV4UploadFileCallOptions,
+  type FilesV4UploadFileResult,
+  type SharedV4ProviderReference,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
   convertInlineFileDataToUint8Array,
+  createBinaryStreamResponseHandler,
   createJsonResponseHandler,
+  deleteFromApi,
+  getFromApi,
   parseProviderOptions,
   postFormDataToApi,
+  postMultipartStreamToApi,
   type FetchFunction,
+  type InferSchema,
+  type MultipartStreamPart,
 } from '@ai-sdk/provider-utils';
 import { openaiFailedResponseHandler } from '../openai-error';
-import { openaiFilesResponseSchema } from './openai-files-api';
+import {
+  openaiFileDeleteResponseSchema,
+  openaiFilesResponseSchema,
+} from './openai-files-api';
 import {
   openaiFilesOptionsSchema,
   type OpenAIFilesOptions,
 } from './openai-files-options';
+
 interface OpenAIFilesConfig {
   provider: string;
   baseURL: string;
@@ -24,6 +42,19 @@ interface OpenAIFilesConfig {
   fetch?: FetchFunction;
 }
 
+type OpenAIFilesResponse = InferSchema<typeof openaiFilesResponseSchema>;
+
+function encodePathSegment(value: string): string {
+  const encodedValue = encodeURIComponent(value);
+
+  // URL parsing normalizes both literal and percent-encoded dot segments.
+  return encodedValue === '.'
+    ? '%252E'
+    : encodedValue === '..'
+      ? '%252E%252E'
+      : encodedValue;
+}
+
 export class OpenAIFiles implements FilesV4 {
   readonly specificationVersion = 'v4';
 
@@ -33,72 +64,245 @@ export class OpenAIFiles implements FilesV4 {
 
   constructor(private readonly config: OpenAIFilesConfig) {}
 
+  private getFileId(file: SharedV4ProviderReference): string {
+    const fileId = file.openai;
+    if (fileId == null || fileId.trim() === '') {
+      throw new InvalidArgumentError({
+        argument: 'file',
+        message: "file reference is missing an 'openai' file id.",
+      });
+    }
+    return fileId;
+  }
+
+  private getHeaders(
+    headers: Record<string, string | undefined> | undefined,
+  ): Record<string, string | undefined> {
+    return combineHeaders(this.config.headers(), headers);
+  }
+
   async uploadFile({
     data,
     mediaType,
     filename,
+    abortSignal,
+    headers,
     providerOptions,
   }: FilesV4UploadFileCallOptions): Promise<FilesV4UploadFileResult> {
-    const openaiOptions = (await parseProviderOptions({
-      provider: 'openai',
-      providerOptions,
-      schema: openaiFilesOptionsSchema,
-    })) as OpenAIFilesOptions | undefined;
+    let openaiOptions: OpenAIFilesOptions | undefined;
+    try {
+      openaiOptions = (await parseProviderOptions({
+        provider: 'openai',
+        providerOptions,
+        schema: openaiFilesOptionsSchema,
+      })) as OpenAIFilesOptions | undefined;
+    } catch (error) {
+      // rejected before any request: release the caller's stream
+      if (data.type === 'stream') {
+        await data.stream.cancel(error).catch(() => {});
+      }
+      throw error;
+    }
 
-    const fileBytes = convertInlineFileDataToUint8Array(data);
+    const purpose = openaiOptions?.purpose ?? 'assistants';
+    const requestHeaders = this.getHeaders(headers);
+    const url = `${this.config.baseURL}/files`;
 
-    const blob = new Blob([fileBytes], {
-      type: mediaType,
-    });
+    let response: OpenAIFilesResponse;
 
-    const formData = new FormData();
-    if (filename != null) {
-      formData.append('file', blob, filename);
+    if (data.type === 'stream') {
+      const parts: Array<MultipartStreamPart> = [
+        { type: 'field', name: 'purpose', value: purpose },
+      ];
+
+      if (openaiOptions?.expiresAfter != null) {
+        parts.push(
+          { type: 'field', name: 'expires_after[anchor]', value: 'created_at' },
+          {
+            type: 'field',
+            name: 'expires_after[seconds]',
+            value: String(openaiOptions.expiresAfter),
+          },
+        );
+      }
+
+      parts.push({
+        type: 'file',
+        name: 'file',
+        filename,
+        mediaType,
+        content: data.stream,
+      });
+
+      ({ value: response } = await postMultipartStreamToApi({
+        url,
+        headers: requestHeaders,
+        parts,
+        failedResponseHandler: openaiFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(
+          openaiFilesResponseSchema,
+        ),
+        abortSignal,
+        fetch: this.config.fetch,
+      }));
     } else {
-      formData.append('file', blob);
-    }
-    formData.append('purpose', openaiOptions?.purpose ?? 'assistants');
-
-    if (openaiOptions?.expiresAfter != null) {
-      formData.append('expires_after[anchor]', 'created_at');
-      formData.append(
-        'expires_after[seconds]',
-        String(openaiOptions.expiresAfter),
-      );
+      const fileBytes = convertInlineFileDataToUint8Array(data);
+
+      const blob = new Blob([fileBytes], {
+        type: mediaType,
+      });
+
+      const formData = new FormData();
+      if (filename != null) {
+        formData.append('file', blob, filename);
+      } else {
+        formData.append('file', blob);
+      }
+      formData.append('purpose', purpose);
+
+      if (openaiOptions?.expiresAfter != null) {
+        formData.append('expires_after[anchor]', 'created_at');
+        formData.append(
+          'expires_after[seconds]',
+          String(openaiOptions.expiresAfter),
+        );
+      }
+
+      ({ value: response } = await postFormDataToApi({
+        url,
+        headers: requestHeaders,
+        formData,
+        failedResponseHandler: openaiFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(
+          openaiFilesResponseSchema,
+        ),
+        abortSignal,
+        fetch: this.config.fetch,
+      }));
     }
 
-    const { value: response } = await postFormDataToApi({
-      url: `${this.config.baseURL}/files`,
-      headers: combineHeaders(this.config.headers()),
-      formData,
+    return {
+      warnings: [],
+      providerReference: { openai: response.id },
+      ...((response.filename ?? filename)
+        ? { filename: response.filename ?? filename }
+        : {}),
+      ...(mediaType != null ? { mediaType } : {}),
+      ...(response.bytes != null ? { byteSize: response.bytes } : {}),
+      ...(response.created_at != null
+        ? { createdAt: new Date(response.created_at * 1000) }
+        : {}),
+      ...(response.expires_at != null
+        ? { expiresAt: new Date(response.expires_at * 1000) }
+        : {}),
+      providerMetadata: {
+        openai: this.toFileMetadata(response),
+      },
+    };
+  }
+
+  async getFileMetadata({
+    file,
+    abortSignal,
+    headers,
+  }: FilesV4GetFileMetadataCallOptions): Promise<FilesV4GetFileMetadataResult> {
+    const fileId = this.getFileId(file);
+
+    const { value: response } = await getFromApi({
+      url: `${this.config.baseURL}/files/${encodePathSegment(fileId)}`,
+      headers: this.getHeaders(headers),
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
         openaiFilesResponseSchema,
       ),
+      abortSignal,
       fetch: this.config.fetch,
+      validateUrl: false,
     });
 
     return {
       warnings: [],
       providerReference: { openai: response.id },
-      ...((response.filename ?? filename)
-        ? { filename: response.filename ?? filename }
+      ...(response.filename != null ? { filename: response.filename } : {}),
+      ...(response.bytes != null ? { byteSize: response.bytes } : {}),
+      ...(response.created_at != null
+        ? { createdAt: new Date(response.created_at * 1000) }
+        : {}),
+      ...(response.expires_at != null
+        ? { expiresAt: new Date(response.expires_at * 1000) }
         : {}),
-      ...(mediaType != null ? { mediaType } : {}),
       providerMetadata: {
-        openai: {
-          ...(response.filename != null ? { filename: response.filename } : {}),
-          ...(response.purpose != null ? { purpose: response.purpose } : {}),
-          ...(response.bytes != null ? { bytes: response.bytes } : {}),
-          ...(response.created_at != null
-            ? { createdAt: response.created_at }
-            : {}),
-          ...(response.status != null ? { status: response.status } : {}),
-          ...(response.expires_at != null
-            ? { expiresAt: response.expires_at }
-            : {}),
-        },
+        openai: this.toFileMetadata(response),
       },
     };
   }
+
+  async downloadFile({
+    file,
+    abortSignal,
+    headers,
+  }: FilesV4DownloadFileCallOptions): Promise<FilesV4DownloadFileResult> {
+    const fileId = this.getFileId(file);
+
+    const { value: content, responseHeaders } = await getFromApi({
+      url: `${this.config.baseURL}/files/${encodePathSegment(fileId)}/content`,
+      headers: this.getHeaders(headers),
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createBinaryStreamResponseHandler(),
+      abortSignal,
+      fetch: this.config.fetch,
+      validateUrl: false,
+    });
+
+    // media type from the content endpoint's Content-Type, without parameters
+    const mediaType = responseHeaders?.['content-type']?.split(';')[0].trim();
+
+    return {
+      warnings: [],
+      content,
+      ...(mediaType ? { mediaType } : {}),
+    };
+  }
+
+  async deleteFile({
+    file,
+    abortSignal,
+    headers,
+  }: FilesV4DeleteFileCallOptions): Promise<FilesV4DeleteFileResult> {
+    const fileId = this.getFileId(file);
+
+    const { value: response } = await deleteFromApi({
+      url: `${this.config.baseURL}/files/${encodePathSegment(fileId)}`,
+      headers: this.getHeaders(headers),
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiFileDeleteResponseSchema,
+      ),
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    return {
+      warnings: [],
+      providerReference: { openai: response.id },
+      deleted: response.deleted,
+    };
+  }
+
+  private toFileMetadata(
+    response: OpenAIFilesResponse,
+  ): Record<string, string | number> {
+    return {
+      ...(response.filename != null ? { filename: response.filename } : {}),
+      ...(response.purpose != null ? { purpose: response.purpose } : {}),
+      ...(response.bytes != null ? { bytes: response.bytes } : {}),
+      ...(response.created_at != null
+        ? { createdAt: response.created_at }
+        : {}),
+      ...(response.status != null ? { status: response.status } : {}),
+      ...(response.expires_at != null
+        ? { expiresAt: response.expires_at }
+        : {}),
+    };
+  }
 }

package/src/openai-responses-batch.ts

@@ -44,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';
 
@@ -166,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';
@@ -385,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
@@ -580,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) {
@@ -615,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 {
@@ -658,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

@@ -2584,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;
               }
@@ -2915,7 +2915,7 @@ function isResponseOutputChunk(chunk: OpenAIResponsesChunk): boolean {
   );
 }
 
-function mapWebSearchOutput(
+export function mapWebSearchOutput(
   action: OpenAIResponsesWebSearchAction | null | undefined,
 ): InferSchema<typeof webSearchOutputSchema> {
   if (action == null) {