@ai-sdk/openai 4.0.98 → 4.0.100

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

@@ -36,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(
@@ -85,7 +86,7 @@ export const shellArgsSchema = lazySchema(() =>
                 }),
               ])
               .optional(),
-            skills: shellSkillsSchema,
+            skills: shellSkillsSchema(),
           }),
           z.object({
             type: z.literal('containerReference'),