@ai-sdk/openai 3.0.130 → 3.0.132

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

@@ -6,65 +6,79 @@ import {
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
-const jsonValueSchema: z.ZodType<JSONValue> = z.lazy(() =>
-  z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(jsonValueSchema),
-    z.record(z.string(), jsonValueSchema.optional()),
-  ]),
-);
+let cachedJsonValueSchema: z.ZodType<JSONValue> | undefined;
+const jsonValueSchema = (): z.ZodType<JSONValue> =>
+  (cachedJsonValueSchema ??= z.lazy(() =>
+    z.union([
+      z.string(),
+      z.number(),
+      z.boolean(),
+      z.null(),
+      z.array(jsonValueSchema()),
+      z.record(z.string(), jsonValueSchema().optional()),
+    ]),
+  ));
 
-const jsonObjectSchema = z.record(z.string(), jsonValueSchema.optional());
+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 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(),
+            cache_write_tokens_details: z
+              .intersection(
+                jsonObjectSchema(),
+                z.object({
+                  ttl_30m_tokens: z.number().nullish(),
+                  ttl_12h_tokens: z.number().nullish(),
+                }),
+              )
+              .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(),
+    }),
+  );
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return value != null && typeof value === 'object' && !Array.isArray(value);
 }
 
-const openaiResponsesLocalShellCallSchema = z.object({
-  type: z.literal('local_shell_call'),
-  id: z.string(),
-  call_id: z.string(),
-  action: z.object({
-    type: z.literal('exec'),
-    command: z.array(z.string()),
-    timeout_ms: z.number().optional(),
-    user: z.string().optional(),
-    working_directory: z.string().optional(),
-    env: z.record(z.string(), z.string()).optional(),
-  }),
-});
+const openaiResponsesLocalShellCallSchema = () =>
+  z.object({
+    type: z.literal('local_shell_call'),
+    id: z.string(),
+    call_id: z.string(),
+    action: z.object({
+      type: z.literal('exec'),
+      command: z.array(z.string()),
+      timeout_ms: z.number().optional(),
+      user: z.string().optional(),
+      working_directory: z.string().optional(),
+      env: z.record(z.string(), z.string()).optional(),
+    }),
+  });
 
 export type OpenAIResponsesInput = Array<OpenAIResponsesInputItem>;
 
@@ -121,6 +135,11 @@ export type OpenAIResponsesApplyPatchOperationDiffDoneChunk = {
   diff: string;
 };
 
+export type OpenAIResponsesPromptCacheBreakpoint = {
+  mode: 'explicit';
+  ttl?: '30m' | '12h';
+};
+
 export type OpenAIResponsesSystemMessage = {
   type?: 'message';
   role: 'system' | 'developer';
@@ -129,7 +148,7 @@ export type OpenAIResponsesSystemMessage = {
     | Array<{
         type: 'input_text';
         text: string;
-        prompt_cache_breakpoint?: { mode: 'explicit' };
+        prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
       }>;
 };
 
@@ -140,33 +159,33 @@ export type OpenAIResponsesUserMessage = {
     | {
         type: 'input_text';
         text: string;
-        prompt_cache_breakpoint?: { mode: 'explicit' };
+        prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
       }
     | {
         type: 'input_image';
         image_url: string;
-        prompt_cache_breakpoint?: { mode: 'explicit' };
+        prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
       }
     | {
         type: 'input_image';
         file_id: string;
-        prompt_cache_breakpoint?: { mode: 'explicit' };
+        prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
       }
     | {
         type: 'input_file';
         file_url: string;
-        prompt_cache_breakpoint?: { mode: 'explicit' };
+        prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
       }
     | {
         type: 'input_file';
         filename: string;
         file_data: string;
-        prompt_cache_breakpoint?: { mode: 'explicit' };
+        prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
       }
     | {
         type: 'input_file';
         file_id: string;
-        prompt_cache_breakpoint?: { mode: 'explicit' };
+        prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
       }
   >;
 };
@@ -198,33 +217,33 @@ export type OpenAIResponsesFunctionCallOutput = {
         | {
             type: 'input_text';
             text: string;
-            prompt_cache_breakpoint?: { mode: 'explicit' };
+            prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
           }
         | {
             type: 'input_image';
             image_url: string;
-            prompt_cache_breakpoint?: { mode: 'explicit' };
+            prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
           }
         | {
             type: 'input_image';
             file_id: string;
-            prompt_cache_breakpoint?: { mode: 'explicit' };
+            prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
           }
         | {
             type: 'input_file';
             filename: string;
             file_data: string;
-            prompt_cache_breakpoint?: { mode: 'explicit' };
+            prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
           }
         | {
             type: 'input_file';
             file_url: string;
-            prompt_cache_breakpoint?: { mode: 'explicit' };
+            prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
           }
         | {
             type: 'input_file';
             file_id: string;
-            prompt_cache_breakpoint?: { mode: 'explicit' };
+            prompt_cache_breakpoint?: OpenAIResponsesPromptCacheBreakpoint;
           }
       >;
 };
@@ -264,7 +283,7 @@ export type OpenAIResponsesComputerCall = {
 };
 
 export type OpenAIResponsesLocalShellCall = InferSchema<
-  typeof openaiResponsesLocalShellCallSchema
+  ReturnType<typeof openaiResponsesLocalShellCallSchema>
 >;
 
 export type OpenAIResponsesLocalShellCallOutput = {
@@ -615,27 +634,29 @@ export type OpenAIResponsesConfigurationUpdate = {
 // Captured from the Responses API when OpenAI returned an early
 // insufficient_quota stream error after HTTP 200. This shape differs from the
 // currently documented ResponseErrorEvent below.
-const openaiResponsesNestedErrorChunkSchema = z.object({
-  type: z.literal('error'),
-  sequence_number: z.number(),
-  error: z.object({
-    type: z.string(),
-    code: z.string().nullish(),
-    message: z.string(),
-    param: z.string().nullish(),
-  }),
-});
+const openaiResponsesNestedErrorChunkSchema = () =>
+  z.object({
+    type: z.literal('error'),
+    sequence_number: z.number(),
+    error: z.object({
+      type: z.string(),
+      code: z.string().nullish(),
+      message: z.string(),
+      param: z.string().nullish(),
+    }),
+  });
 
 // Current OpenAI OpenAPI docs define ResponseErrorEvent with top-level
 // code/message/param fields:
 // https://developers.openai.com/api/reference/resources/responses/streaming-events
-const openaiResponsesErrorChunkSchema = z.object({
-  type: z.literal('error'),
-  sequence_number: z.number(),
-  code: z.string().nullish(),
-  message: z.string(),
-  param: z.string().nullish(),
-});
+const openaiResponsesErrorChunkSchema = () =>
+  z.object({
+    type: z.literal('error'),
+    sequence_number: z.number(),
+    code: z.string().nullish(),
+    message: z.string(),
+    param: z.string().nullish(),
+  });
 
 /**
  * Chunk types explicitly modeled by openaiResponsesChunkSchema. Keep this set
@@ -739,7 +760,7 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
         type: z.enum(['response.completed', 'response.incomplete']),
         response: z.object({
           incomplete_details: z.object({ reason: z.string() }).nullish(),
-          usage: openaiResponsesUsageSchema.nullish(),
+          usage: openaiResponsesUsageSchema().nullish(),
           reasoning: z
             .object({
               context: z.string().nullish(),
@@ -759,7 +780,7 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
             })
             .nullish(),
           incomplete_details: z.object({ reason: z.string() }).nullish(),
-          usage: openaiResponsesUsageSchema.nullish(),
+          usage: openaiResponsesUsageSchema().nullish(),
           reasoning: z
             .object({
               context: z.string().nullish(),
@@ -814,7 +835,7 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
             type: z.literal('file_search_call'),
             id: z.string(),
           }),
-          openaiResponsesLocalShellCallSchema,
+          openaiResponsesLocalShellCallSchema(),
           z.object({
             type: z.literal('image_generation_call'),
             id: z.string(),
@@ -920,7 +941,7 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
             execution: z.enum(['server', 'client']),
             call_id: z.string().nullable(),
             status: z.enum(['in_progress', 'completed', 'incomplete']),
-            tools: z.array(z.record(z.string(), jsonValueSchema.optional())),
+            tools: z.array(z.record(z.string(), jsonValueSchema().optional())),
           }),
         ]),
       }),
@@ -1026,7 +1047,7 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
               )
               .nullish(),
           }),
-          openaiResponsesLocalShellCallSchema,
+          openaiResponsesLocalShellCallSchema(),
           z.object({
             type: z.literal('computer_call'),
             id: z.string(),
@@ -1151,7 +1172,7 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
             execution: z.enum(['server', 'client']),
             call_id: z.string().nullable(),
             status: z.enum(['in_progress', 'completed', 'incomplete']),
-            tools: z.array(z.record(z.string(), jsonValueSchema.optional())),
+            tools: z.array(z.record(z.string(), jsonValueSchema().optional())),
           }),
         ]),
       }),
@@ -1253,8 +1274,8 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
         output_index: z.number(),
         diff: z.string(),
       }),
-      openaiResponsesNestedErrorChunkSchema,
-      openaiResponsesErrorChunkSchema,
+      openaiResponsesNestedErrorChunkSchema(),
+      openaiResponsesErrorChunkSchema(),
       z
         .object({ type: z.string() })
         .loose()
@@ -1432,7 +1453,7 @@ export const openaiResponsesResponseSchema = lazySchema(() =>
               id: z.string(),
               result: z.string(),
             }),
-            openaiResponsesLocalShellCallSchema,
+            openaiResponsesLocalShellCallSchema(),
             z.object({
               type: z.literal('function_call'),
               call_id: z.string(),
@@ -1585,7 +1606,9 @@ export const openaiResponsesResponseSchema = lazySchema(() =>
               execution: z.enum(['server', 'client']),
               call_id: z.string().nullable(),
               status: z.enum(['in_progress', 'completed', 'incomplete']),
-              tools: z.array(z.record(z.string(), jsonValueSchema.optional())),
+              tools: z.array(
+                z.record(z.string(), jsonValueSchema().optional()),
+              ),
             }),
           ]),
         )
@@ -1597,7 +1620,7 @@ export const openaiResponsesResponseSchema = lazySchema(() =>
         })
         .nullish(),
       incomplete_details: z.object({ reason: z.string() }).nullish(),
-      usage: openaiResponsesUsageSchema.nullish(),
+      usage: openaiResponsesUsageSchema().nullish(),
     }),
   ),
 );

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

@@ -271,6 +271,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
       toolNameMapping,
       customProviderToolNames,
       supportsAsyncToolCalling: modelCapabilities.supportsAsyncToolCalling,
+      providerOptionsName,
     });
 
     const configurationUpdateUnsupportedReason =

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

@@ -241,12 +241,14 @@ export const openaiLanguageModelResponsesOptionsSchema = lazySchema(() =>
       /**
        * Prompt cache behavior for GPT-5.6 and later models.
        * `mode` controls whether OpenAI also places an implicit breakpoint.
-       * `ttl` sets the minimum cache lifetime and currently only supports 30 minutes.
+       * `ttl` sets the minimum cache lifetime: `'30m'` (default) or `'12h'`.
+       * `prewarm` writes the prompt to the cache without generating output.
        */
       promptCacheOptions: z
         .object({
           mode: z.enum(['implicit', 'explicit']).optional(),
-          ttl: z.literal('30m').optional(),
+          ttl: z.enum(['30m', '12h']).optional(),
+          prewarm: z.boolean().optional(),
         })
         .optional(),
 

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

@@ -44,6 +44,7 @@ export async function prepareResponsesTools({
   toolNameMapping,
   customProviderToolNames,
   supportsAsyncToolCalling = true,
+  providerOptionsName = 'openai',
 }: {
   tools: LanguageModelV3CallOptions['tools'];
   toolChoice: LanguageModelV3CallOptions['toolChoice'] | undefined;
@@ -54,6 +55,7 @@ export async function prepareResponsesTools({
   toolNameMapping?: ToolNameMapping;
   customProviderToolNames?: Set<string>;
   supportsAsyncToolCalling?: boolean;
+  providerOptionsName?: string;
 }): Promise<{
   tools?: Array<OpenAIResponsesTool>;
   toolChoice?:
@@ -125,9 +127,8 @@ export async function prepareResponsesTools({
   for (const tool of tools) {
     switch (tool.type) {
       case 'function': {
-        const openaiOptions = tool.providerOptions?.openai as
-          | OpenAIToolOptions
-          | undefined;
+        const openaiOptions = (tool.providerOptions?.[providerOptionsName] ??
+          tool.providerOptions?.openai) as OpenAIToolOptions | undefined;
         const openaiFunctionTool = prepareFunctionTool({
           tool,
           options: openaiOptions,

package/src/tool/file-search.ts

@@ -9,18 +9,21 @@ import type {
   OpenAIResponsesFileSearchToolCompoundFilter,
 } from '../responses/openai-responses-api';
 
-const comparisonFilterSchema = z.object({
-  key: z.string(),
-  type: z.enum(['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin']),
-  value: z.union([z.string(), z.number(), z.boolean(), z.array(z.string())]),
-});
+const comparisonFilterSchema = () =>
+  z.object({
+    key: z.string(),
+    type: z.enum(['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin']),
+    value: z.union([z.string(), z.number(), z.boolean(), z.array(z.string())]),
+  });
 
-const compoundFilterSchema: z.ZodType<any> = z.object({
-  type: z.enum(['and', 'or']),
-  filters: z.array(
-    z.union([comparisonFilterSchema, z.lazy(() => compoundFilterSchema)]),
-  ),
-});
+let cachedCompoundFilterSchema: z.ZodType<any> | undefined;
+const compoundFilterSchema = (): z.ZodType<any> =>
+  (cachedCompoundFilterSchema ??= z.object({
+    type: z.enum(['and', 'or']),
+    filters: z.array(
+      z.union([comparisonFilterSchema(), z.lazy(() => compoundFilterSchema())]),
+    ),
+  }));
 
 export const fileSearchArgsSchema = lazySchema(() =>
   zodSchema(
@@ -34,7 +37,7 @@ export const fileSearchArgsSchema = lazySchema(() =>
         })
         .optional(),
       filters: z
-        .union([comparisonFilterSchema, compoundFilterSchema])
+        .union([comparisonFilterSchema(), compoundFilterSchema()])
         .optional(),
     }),
   ),

package/src/tool/mcp.ts

@@ -6,16 +6,18 @@ import {
 import type { JSONValue } from '@ai-sdk/provider';
 import { z } from 'zod/v4';
 
-const jsonValueSchema: z.ZodType<JSONValue> = z.lazy(() =>
-  z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(jsonValueSchema),
-    z.record(z.string(), jsonValueSchema),
-  ]),
-);
+let cachedJsonValueSchema: z.ZodType<JSONValue> | undefined;
+const jsonValueSchema = (): z.ZodType<JSONValue> =>
+  (cachedJsonValueSchema ??= z.lazy(() =>
+    z.union([
+      z.string(),
+      z.number(),
+      z.boolean(),
+      z.null(),
+      z.array(jsonValueSchema()),
+      z.record(z.string(), jsonValueSchema()),
+    ]),
+  ));
 
 export const mcpArgsSchema = lazySchema(() =>
   zodSchema(
@@ -67,7 +69,7 @@ export const mcpOutputSchema = lazySchema(() =>
       name: z.string(),
       arguments: z.string(),
       output: z.string().nullish(),
-      error: z.union([z.string(), jsonValueSchema]).optional(),
+      error: z.union([z.string(), jsonValueSchema()]).optional(),
     }),
   ),
 );

package/src/tool/shell.ts

@@ -34,27 +34,28 @@ export const shellOutputSchema = lazySchema(() =>
   ),
 );
 
-const shellSkillsSchema = z
-  .array(
-    z.discriminatedUnion('type', [
-      z.object({
-        type: z.literal('skillReference'),
-        skillId: z.string(),
-        version: z.string().optional(),
-      }),
-      z.object({
-        type: z.literal('inline'),
-        name: z.string(),
-        description: z.string(),
-        source: z.object({
-          type: z.literal('base64'),
-          mediaType: z.literal('application/zip'),
-          data: z.string(),
+const shellSkillsSchema = () =>
+  z
+    .array(
+      z.discriminatedUnion('type', [
+        z.object({
+          type: z.literal('skillReference'),
+          skillId: z.string(),
+          version: z.string().optional(),
         }),
-      }),
-    ]),
-  )
-  .optional();
+        z.object({
+          type: z.literal('inline'),
+          name: z.string(),
+          description: z.string(),
+          source: z.object({
+            type: z.literal('base64'),
+            mediaType: z.literal('application/zip'),
+            data: z.string(),
+          }),
+        }),
+      ]),
+    )
+    .optional();
 
 export const shellArgsSchema = lazySchema(() =>
   zodSchema(
@@ -83,7 +84,7 @@ export const shellArgsSchema = lazySchema(() =>
                 }),
               ])
               .optional(),
-            skills: shellSkillsSchema,
+            skills: shellSkillsSchema(),
           }),
           z.object({
             type: z.literal('containerReference'),