@ai-sdk/openai 4.0.56 → 4.0.57

package/package.json

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

package/src/openai-responses-batch.ts

@@ -20,6 +20,7 @@ import {
   getFromApi,
   lazySchema,
   normalizeBatchRequestCounts,
+  parseProviderOptions,
   postJsonToApi,
   postToApi,
   safeValidateTypes,
@@ -52,7 +53,25 @@ import type { OpenAIResponsesModelId } from './responses/openai-responses-langua
 import type { ResponsesReasoningProviderMetadata } from './responses/openai-responses-provider-metadata';
 
 const openaiBatchEndpoint = '/v1/responses';
-const openaiBatchInputFileExpiresAfterSeconds = 48 * 60 * 60;
+const openaiBatchInputFileDefaultExpiresAfterSeconds = 48 * 60 * 60;
+
+const openaiBatchProviderOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * TTL in seconds for the uploaded batch input file, measured from
+       * upload time. OpenAI accepts integers between 3600 (1 hour) and
+       * 2592000 (30 days) inclusive. Defaults to 48 hours.
+       */
+      inputFileExpiresAfter: z
+        .number()
+        .int()
+        .min(3600)
+        .max(2_592_000)
+        .optional(),
+    }),
+  ),
+);
 
 type OpenAIBatchRequest = Parameters<
   BatchLanguageModelV4['experimental_doStartBatch']
@@ -153,6 +172,13 @@ class OpenAIResponsesBatch {
             },
           ];
 
+    const batchOptions = await this.parseBatchProviderOptions(
+      options.providerOptions,
+    );
+    const inputFileExpiresAfterSeconds =
+      batchOptions?.inputFileExpiresAfter ??
+      openaiBatchInputFileDefaultExpiresAfterSeconds;
+
     for (const request of options.requests) {
       const preparedRequest = await this.options.prepareRequest(request);
 
@@ -200,7 +226,7 @@ class OpenAIResponsesBatch {
     formData.append('expires_after[anchor]', 'created_at');
     formData.append(
       'expires_after[seconds]',
-      String(openaiBatchInputFileExpiresAfterSeconds),
+      String(inputFileExpiresAfterSeconds),
     );
 
     const { value: uploadedFile } = await postToApi({
@@ -211,9 +237,7 @@ class OpenAIResponsesBatch {
         values: {
           purpose: 'batch',
           'expires_after[anchor]': 'created_at',
-          'expires_after[seconds]': String(
-            openaiBatchInputFileExpiresAfterSeconds,
-          ),
+          'expires_after[seconds]': String(inputFileExpiresAfterSeconds),
           file: {
             name: filename,
             type: file.type,
@@ -245,13 +269,44 @@ class OpenAIResponsesBatch {
       fetch: this.options.config.fetch,
     });
 
+    const inputFileExpiresAt = convertUnixTimestamp(uploadedFile.expires_at);
+
     return {
       batchId: batch.id,
       ...convertOpenAIBatchStatus(batch),
+      providerMetadata: {
+        openai: {
+          inputFileId: uploadedFile.id,
+          ...(inputFileExpiresAt != null ? { inputFileExpiresAt } : {}),
+        },
+      },
       warnings,
     };
   }
 
+  private async parseBatchProviderOptions(
+    providerOptions: BatchV4StartOptions<OpenAIBatchRequest>['providerOptions'],
+  ) {
+    const providerOptionsName = this.options.config.provider.includes('azure')
+      ? 'azure'
+      : 'openai';
+    let batchOptions = await parseProviderOptions({
+      provider: providerOptionsName,
+      providerOptions,
+      schema: openaiBatchProviderOptionsSchema,
+    });
+
+    if (batchOptions == null && providerOptionsName !== 'openai') {
+      batchOptions = await parseProviderOptions({
+        provider: 'openai',
+        providerOptions,
+        schema: openaiBatchProviderOptionsSchema,
+      });
+    }
+
+    return batchOptions;
+  }
+
   async getBatchStatus(
     options: BatchV4OperationOptions,
   ): Promise<BatchV4Status> {

package/src/responses/convert-openai-responses-usage.ts

@@ -1,19 +1,24 @@
-import type { LanguageModelV4Usage } from '@ai-sdk/provider';
+import type { JSONObject, LanguageModelV4Usage } from '@ai-sdk/provider';
 import { createNullLanguageModelUsage } from '@ai-sdk/provider-utils';
 
-export type OpenAIResponsesUsage = {
+export type OpenAIResponsesUsage = JSONObject & {
   input_tokens: number;
   output_tokens: number;
-  input_tokens_details?: {
-    cached_tokens?: number | null;
-    cache_write_tokens?: number | null;
-    orchestration_input_tokens?: number | null;
-    orchestration_input_cached_tokens?: number | null;
-  } | null;
-  output_tokens_details?: {
-    reasoning_tokens?: number | null;
-    orchestration_output_tokens?: number | null;
-  } | null;
+  total_tokens?: number;
+  input_tokens_details?:
+    | (JSONObject & {
+        cached_tokens?: number | null;
+        cache_write_tokens?: number | null;
+        orchestration_input_tokens?: number | null;
+        orchestration_input_cached_tokens?: number | null;
+      })
+    | null;
+  output_tokens_details?:
+    | (JSONObject & {
+        reasoning_tokens?: number | null;
+        orchestration_output_tokens?: number | null;
+      })
+    | null;
 };
 
 export function convertOpenAIResponsesUsage(

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

@@ -18,6 +18,37 @@ const jsonValueSchema: z.ZodType<JSONValue> = z.lazy(() =>
   ]),
 );
 
+const jsonObjectSchema = z.record(z.string(), jsonValueSchema.optional());
+
+const openaiResponsesUsageSchema = z.intersection(
+  jsonObjectSchema,
+  z.object({
+    input_tokens: z.number(),
+    input_tokens_details: z
+      .intersection(
+        jsonObjectSchema,
+        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
+      .intersection(
+        jsonObjectSchema,
+        z.object({
+          reasoning_tokens: z.number().nullish(),
+          orchestration_output_tokens: z.number().nullish(),
+        }),
+      )
+      .nullish(),
+    total_tokens: z.number().optional(),
+  }),
+);
+
 const openaiResponsesComputerSafetyCheckSchema = z.object({
   id: z.string(),
   code: z.string().nullish(),
@@ -831,26 +862,7 @@ 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(),
-            })
-            .nullish(),
+          usage: openaiResponsesUsageSchema.nullish(),
           reasoning: z
             .object({
               context: z.string().nullish(),
@@ -870,26 +882,7 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
             })
             .nullish(),
           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(),
-            })
-            .nullish(),
+          usage: openaiResponsesUsageSchema.nullish(),
           reasoning: z
             .object({
               context: z.string().nullish(),
@@ -1745,26 +1738,7 @@ export const openaiResponsesResponseSchema = lazySchema(() =>
         })
         .nullish(),
       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(),
-        })
-        .nullish(),
+      usage: openaiResponsesUsageSchema.nullish(),
     }),
   ),
 );