@ai-sdk/openai 4.0.97 → 4.0.99

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

@@ -250,12 +250,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-language-model.ts

@@ -1045,6 +1045,8 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
             input: JSON.stringify({
               action: {
                 commands: part.action.commands,
+                timeoutMs: part.action.timeout_ms ?? undefined,
+                maxOutputLength: part.action.max_output_length ?? undefined,
               },
             } satisfies InferSchema<typeof shellInputSchema>),
             ...(isShellProviderExecuted && { providerExecuted: true }),
@@ -1064,6 +1066,9 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
             toolCallId: part.call_id,
             toolName: toolNameMapping.toCustomToolName('shell'),
             result: {
+              ...(part.max_output_length != null && {
+                maxOutputLength: part.max_output_length,
+              }),
               output: part.output.map(item => ({
                 stdout: item.stdout,
                 stderr: item.stderr,
@@ -2530,6 +2535,9 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
                   input: JSON.stringify({
                     action: {
                       commands: value.item.action.commands,
+                      timeoutMs: value.item.action.timeout_ms ?? undefined,
+                      maxOutputLength:
+                        value.item.action.max_output_length ?? undefined,
                     },
                   } satisfies InferSchema<typeof shellInputSchema>),
                   ...(isShellProviderExecuted && {
@@ -2545,6 +2553,9 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
                   toolCallId: value.item.call_id,
                   toolName: toolNameMapping.toCustomToolName('shell'),
                   result: {
+                    ...(value.item.max_output_length != null && {
+                      maxOutputLength: value.item.max_output_length,
+                    }),
                     output: value.item.output.map(
                       (item: {
                         stdout: string;

package/src/tool/computer.ts

@@ -5,66 +5,68 @@ import {
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
-const safetyCheckSchema = z.object({
-  id: z.string(),
-  code: z.string().optional(),
-  message: z.string().optional(),
-});
-
-const computerActionSchema = z.discriminatedUnion('type', [
-  z.object({
-    type: z.literal('click'),
-    button: z.enum(['left', 'right', 'wheel', 'back', 'forward']),
-    x: z.number(),
-    y: z.number(),
-    keys: z.array(z.string()).optional(),
-  }),
-  z.object({
-    type: z.literal('double_click'),
-    x: z.number(),
-    y: z.number(),
-    keys: z.array(z.string()).optional(),
-  }),
-  z.object({
-    type: z.literal('drag'),
-    path: z.array(z.object({ x: z.number(), y: z.number() })),
-    keys: z.array(z.string()).optional(),
-  }),
-  z.object({
-    type: z.literal('keypress'),
-    keys: z.array(z.string()),
-  }),
-  z.object({
-    type: z.literal('move'),
-    x: z.number(),
-    y: z.number(),
-    keys: z.array(z.string()).optional(),
-  }),
-  z.object({
-    type: z.literal('screenshot'),
-  }),
+const safetyCheckSchema = () =>
   z.object({
-    type: z.literal('scroll'),
-    x: z.number(),
-    y: z.number(),
-    scrollX: z.number(),
-    scrollY: z.number(),
-    keys: z.array(z.string()).optional(),
-  }),
-  z.object({
-    type: z.literal('type'),
-    text: z.string(),
-  }),
-  z.object({
-    type: z.literal('wait'),
-  }),
-]);
+    id: z.string(),
+    code: z.string().optional(),
+    message: z.string().optional(),
+  });
+
+const computerActionSchema = () =>
+  z.discriminatedUnion('type', [
+    z.object({
+      type: z.literal('click'),
+      button: z.enum(['left', 'right', 'wheel', 'back', 'forward']),
+      x: z.number(),
+      y: z.number(),
+      keys: z.array(z.string()).optional(),
+    }),
+    z.object({
+      type: z.literal('double_click'),
+      x: z.number(),
+      y: z.number(),
+      keys: z.array(z.string()).optional(),
+    }),
+    z.object({
+      type: z.literal('drag'),
+      path: z.array(z.object({ x: z.number(), y: z.number() })),
+      keys: z.array(z.string()).optional(),
+    }),
+    z.object({
+      type: z.literal('keypress'),
+      keys: z.array(z.string()),
+    }),
+    z.object({
+      type: z.literal('move'),
+      x: z.number(),
+      y: z.number(),
+      keys: z.array(z.string()).optional(),
+    }),
+    z.object({
+      type: z.literal('screenshot'),
+    }),
+    z.object({
+      type: z.literal('scroll'),
+      x: z.number(),
+      y: z.number(),
+      scrollX: z.number(),
+      scrollY: z.number(),
+      keys: z.array(z.string()).optional(),
+    }),
+    z.object({
+      type: z.literal('type'),
+      text: z.string(),
+    }),
+    z.object({
+      type: z.literal('wait'),
+    }),
+  ]);
 
 export const computerInputSchema = lazySchema(() =>
   zodSchema(
     z.object({
-      actions: z.array(computerActionSchema),
-      pendingSafetyChecks: z.array(safetyCheckSchema),
+      actions: z.array(computerActionSchema()),
+      pendingSafetyChecks: z.array(safetyCheckSchema()),
       status: z.enum(['in_progress', 'completed', 'incomplete']),
     }),
   ),
@@ -87,13 +89,17 @@ export const computerOutputSchema = lazySchema(() =>
           detail: z.enum(['auto', 'low', 'high', 'original']).optional(),
         }),
       ]),
-      acknowledgedSafetyChecks: z.array(safetyCheckSchema).optional(),
+      acknowledgedSafetyChecks: z.array(safetyCheckSchema()).optional(),
     }),
   ),
 );
 
-export type OpenAIComputerAction = z.infer<typeof computerActionSchema>;
-export type OpenAIComputerSafetyCheck = z.infer<typeof safetyCheckSchema>;
+export type OpenAIComputerAction = z.infer<
+  ReturnType<typeof computerActionSchema>
+>;
+export type OpenAIComputerSafetyCheck = z.infer<
+  ReturnType<typeof safetyCheckSchema>
+>;
 
 const computerToolFactory = createProviderDefinedToolFactoryWithOutputSchema<
   {

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

@@ -21,6 +21,7 @@ export const shellInputSchema = lazySchema(() =>
 export const shellOutputSchema = lazySchema(() =>
   zodSchema(
     z.object({
+      maxOutputLength: z.number().optional(),
       output: z.array(
         z.object({
           stdout: z.string(),
@@ -35,27 +36,28 @@ export const shellOutputSchema = lazySchema(() =>
   ),
 );
 
-const shellSkillsSchema = z
-  .array(
-    z.discriminatedUnion('type', [
-      z.object({
-        type: z.literal('skillReference'),
-        providerReference: z.record(z.string(), 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'),
+          providerReference: z.record(z.string(), 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(
@@ -84,7 +86,7 @@ export const shellArgsSchema = lazySchema(() =>
                 }),
               ])
               .optional(),
-            skills: shellSkillsSchema,
+            skills: shellSkillsSchema(),
           }),
           z.object({
             type: z.literal('containerReference'),
@@ -180,6 +182,11 @@ export const shell = createProviderDefinedToolFactoryWithOutputSchema<
     };
   },
   {
+    /**
+     * Optional maximum number of characters that was applied to each command's output.
+     */
+    maxOutputLength?: number;
+
     /**
      * An array of shell call output contents.
      */

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

@@ -6,6 +6,7 @@ export const openaiTranscriptionResponseSchema = lazySchema(() =>
     z.object({
       text: z.string(),
       language: z.string().nullish(),
+      languages: z.array(z.object({ code: z.string() })).nullish(),
       duration: z.number().nullish(),
       words: z
         .array(

package/src/transcription/openai-transcription-model.ts

@@ -136,6 +136,12 @@ const languageMap = {
   welsh: 'cy',
 };
 
+function isLanguageCode(
+  language: string | null | undefined,
+): language is string {
+  return language != null && /^[a-z]{2}$/.test(language);
+}
+
 export class OpenAITranscriptionModel implements TranscriptionModelV4 {
   readonly specificationVersion = 'v4';
 
@@ -299,9 +305,16 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
     });
 
     const language =
-      response.language != null && response.language in languageMap
-        ? languageMap[response.language as keyof typeof languageMap]
-        : undefined;
+      (isLanguageCode(response.language)
+        ? response.language
+        : response.language != null &&
+            Object.prototype.hasOwnProperty.call(languageMap, response.language)
+          ? languageMap[response.language as keyof typeof languageMap]
+          : undefined) ??
+      (response.languages?.length === 1 &&
+      isLanguageCode(response.languages[0].code)
+        ? response.languages[0].code
+        : undefined);
 
     const diarizedSegments = response.segments?.flatMap(segment =>
       'speaker' in segment
@@ -340,14 +353,20 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
         headers: responseHeaders,
         body: rawResponse,
       },
-      ...(diarizedSegments != null &&
-        diarizedSegments.length > 0 && {
-          providerMetadata: {
-            openai: {
-              segments: diarizedSegments,
-            },
+      ...(((diarizedSegments != null && diarizedSegments.length > 0) ||
+        response.languages != null) && {
+        providerMetadata: {
+          openai: {
+            ...(diarizedSegments != null &&
+              diarizedSegments.length > 0 && {
+                segments: diarizedSegments,
+              }),
+            ...(response.languages != null && {
+              languages: response.languages,
+            }),
           },
-        }),
+        },
+      }),
     };
   }