@ai-sdk/openai 4.0.13 → 4.0.15

package/dist/index.js

@@ -2525,31 +2525,128 @@ var codeInterpreter = (args = {}) => {
   return codeInterpreterToolFactory(args);
 };
 
-// src/tool/custom.ts
+// src/tool/computer.ts
 import {
-  createProviderDefinedToolFactory,
+  createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema2,
   lazySchema as lazySchema13,
   zodSchema as zodSchema13
 } from "@ai-sdk/provider-utils";
 import { z as z14 } from "zod/v4";
-var customArgsSchema = lazySchema13(
+var safetyCheckSchema = z14.object({
+  id: z14.string(),
+  code: z14.string().optional(),
+  message: z14.string().optional()
+});
+var computerActionSchema = z14.discriminatedUnion("type", [
+  z14.object({
+    type: z14.literal("click"),
+    button: z14.enum(["left", "right", "wheel", "back", "forward"]),
+    x: z14.number(),
+    y: z14.number(),
+    keys: z14.array(z14.string()).optional()
+  }),
+  z14.object({
+    type: z14.literal("double_click"),
+    x: z14.number(),
+    y: z14.number(),
+    keys: z14.array(z14.string()).optional()
+  }),
+  z14.object({
+    type: z14.literal("drag"),
+    path: z14.array(z14.object({ x: z14.number(), y: z14.number() })),
+    keys: z14.array(z14.string()).optional()
+  }),
+  z14.object({
+    type: z14.literal("keypress"),
+    keys: z14.array(z14.string())
+  }),
+  z14.object({
+    type: z14.literal("move"),
+    x: z14.number(),
+    y: z14.number(),
+    keys: z14.array(z14.string()).optional()
+  }),
+  z14.object({
+    type: z14.literal("screenshot")
+  }),
+  z14.object({
+    type: z14.literal("scroll"),
+    x: z14.number(),
+    y: z14.number(),
+    scrollX: z14.number(),
+    scrollY: z14.number(),
+    keys: z14.array(z14.string()).optional()
+  }),
+  z14.object({
+    type: z14.literal("type"),
+    text: z14.string()
+  }),
+  z14.object({
+    type: z14.literal("wait")
+  })
+]);
+var computerInputSchema = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      actions: z14.array(computerActionSchema),
+      pendingSafetyChecks: z14.array(safetyCheckSchema),
+      status: z14.enum(["in_progress", "completed", "incomplete"])
+    })
+  )
+);
+var computerOutputSchema = lazySchema13(
   () => zodSchema13(
     z14.object({
-      description: z14.string().optional(),
-      format: z14.union([
+      output: z14.union([
         z14.object({
-          type: z14.literal("grammar"),
-          syntax: z14.enum(["regex", "lark"]),
-          definition: z14.string()
+          type: z14.literal("computer_screenshot"),
+          imageUrl: z14.string(),
+          fileId: z14.string().optional(),
+          detail: z14.enum(["auto", "low", "high", "original"]).optional()
         }),
         z14.object({
-          type: z14.literal("text")
+          type: z14.literal("computer_screenshot"),
+          fileId: z14.string(),
+          imageUrl: z14.string().optional(),
+          detail: z14.enum(["auto", "low", "high", "original"]).optional()
+        })
+      ]),
+      acknowledgedSafetyChecks: z14.array(safetyCheckSchema).optional()
+    })
+  )
+);
+var computerToolFactory = createProviderDefinedToolFactoryWithOutputSchema2({
+  id: "openai.computer",
+  inputSchema: computerInputSchema,
+  outputSchema: computerOutputSchema
+});
+var computer = (options = {}) => computerToolFactory(options);
+
+// src/tool/custom.ts
+import {
+  createProviderDefinedToolFactory,
+  lazySchema as lazySchema14,
+  zodSchema as zodSchema14
+} from "@ai-sdk/provider-utils";
+import { z as z15 } from "zod/v4";
+var customArgsSchema = lazySchema14(
+  () => zodSchema14(
+    z15.object({
+      description: z15.string().optional(),
+      format: z15.union([
+        z15.object({
+          type: z15.literal("grammar"),
+          syntax: z15.enum(["regex", "lark"]),
+          definition: z15.string()
+        }),
+        z15.object({
+          type: z15.literal("text")
         })
       ]).optional()
     })
   )
 );
-var customInputSchema = lazySchema13(() => zodSchema13(z14.string()));
+var customInputSchema = lazySchema14(() => zodSchema14(z15.string()));
 var customToolFactory = createProviderDefinedToolFactory({
   id: "openai.custom",
   inputSchema: customInputSchema
@@ -2559,45 +2656,45 @@ var customTool = (args) => customToolFactory(args);
 // src/tool/file-search.ts
 import {
   createProviderExecutedToolFactory as createProviderExecutedToolFactory2,
-  lazySchema as lazySchema14,
-  zodSchema as zodSchema14
+  lazySchema as lazySchema15,
+  zodSchema as zodSchema15
 } from "@ai-sdk/provider-utils";
-import { z as z15 } from "zod/v4";
-var comparisonFilterSchema = z15.object({
-  key: z15.string(),
-  type: z15.enum(["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin"]),
-  value: z15.union([z15.string(), z15.number(), z15.boolean(), z15.array(z15.string())])
+import { z as z16 } from "zod/v4";
+var comparisonFilterSchema = z16.object({
+  key: z16.string(),
+  type: z16.enum(["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin"]),
+  value: z16.union([z16.string(), z16.number(), z16.boolean(), z16.array(z16.string())])
 });
-var compoundFilterSchema = z15.object({
-  type: z15.enum(["and", "or"]),
-  filters: z15.array(
-    z15.union([comparisonFilterSchema, z15.lazy(() => compoundFilterSchema)])
+var compoundFilterSchema = z16.object({
+  type: z16.enum(["and", "or"]),
+  filters: z16.array(
+    z16.union([comparisonFilterSchema, z16.lazy(() => compoundFilterSchema)])
   )
 });
-var fileSearchArgsSchema = lazySchema14(
-  () => zodSchema14(
-    z15.object({
-      vectorStoreIds: z15.array(z15.string()),
-      maxNumResults: z15.number().optional(),
-      ranking: z15.object({
-        ranker: z15.string().optional(),
-        scoreThreshold: z15.number().optional()
+var fileSearchArgsSchema = lazySchema15(
+  () => zodSchema15(
+    z16.object({
+      vectorStoreIds: z16.array(z16.string()),
+      maxNumResults: z16.number().optional(),
+      ranking: z16.object({
+        ranker: z16.string().optional(),
+        scoreThreshold: z16.number().optional()
       }).optional(),
-      filters: z15.union([comparisonFilterSchema, compoundFilterSchema]).optional()
+      filters: z16.union([comparisonFilterSchema, compoundFilterSchema]).optional()
     })
   )
 );
-var fileSearchOutputSchema = lazySchema14(
-  () => zodSchema14(
-    z15.object({
-      queries: z15.array(z15.string()),
-      results: z15.array(
-        z15.object({
-          attributes: z15.record(z15.string(), z15.unknown()),
-          fileId: z15.string(),
-          filename: z15.string(),
-          score: z15.number(),
-          text: z15.string()
+var fileSearchOutputSchema = lazySchema15(
+  () => zodSchema15(
+    z16.object({
+      queries: z16.array(z16.string()),
+      results: z16.array(
+        z16.object({
+          attributes: z16.record(z16.string(), z16.unknown()),
+          fileId: z16.string(),
+          filename: z16.string(),
+          score: z16.number(),
+          text: z16.string()
         })
       ).nullable()
     })
@@ -2605,39 +2702,39 @@ var fileSearchOutputSchema = lazySchema14(
 );
 var fileSearch = createProviderExecutedToolFactory2({
   id: "openai.file_search",
-  inputSchema: z15.object({}),
+  inputSchema: z16.object({}),
   outputSchema: fileSearchOutputSchema
 });
 
 // src/tool/image-generation.ts
 import {
   createProviderExecutedToolFactory as createProviderExecutedToolFactory3,
-  lazySchema as lazySchema15,
-  zodSchema as zodSchema15
+  lazySchema as lazySchema16,
+  zodSchema as zodSchema16
 } from "@ai-sdk/provider-utils";
-import { z as z16 } from "zod/v4";
-var imageGenerationArgsSchema = lazySchema15(
-  () => zodSchema15(
-    z16.object({
-      background: z16.enum(["auto", "opaque", "transparent"]).optional(),
-      inputFidelity: z16.enum(["low", "high"]).optional(),
-      inputImageMask: z16.object({
-        fileId: z16.string().optional(),
-        imageUrl: z16.string().optional()
+import { z as z17 } from "zod/v4";
+var imageGenerationArgsSchema = lazySchema16(
+  () => zodSchema16(
+    z17.object({
+      background: z17.enum(["auto", "opaque", "transparent"]).optional(),
+      inputFidelity: z17.enum(["low", "high"]).optional(),
+      inputImageMask: z17.object({
+        fileId: z17.string().optional(),
+        imageUrl: z17.string().optional()
       }).optional(),
-      model: z16.string().optional(),
-      moderation: z16.enum(["auto"]).optional(),
-      outputCompression: z16.number().int().min(0).max(100).optional(),
-      outputFormat: z16.enum(["png", "jpeg", "webp"]).optional(),
-      partialImages: z16.number().int().min(0).max(3).optional(),
-      quality: z16.enum(["auto", "low", "medium", "high"]).optional(),
-      size: z16.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
+      model: z17.string().optional(),
+      moderation: z17.enum(["auto"]).optional(),
+      outputCompression: z17.number().int().min(0).max(100).optional(),
+      outputFormat: z17.enum(["png", "jpeg", "webp"]).optional(),
+      partialImages: z17.number().int().min(0).max(3).optional(),
+      quality: z17.enum(["auto", "low", "medium", "high"]).optional(),
+      size: z17.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
     }).strict()
   )
 );
-var imageGenerationInputSchema = lazySchema15(() => zodSchema15(z16.object({})));
-var imageGenerationOutputSchema = lazySchema15(
-  () => zodSchema15(z16.object({ result: z16.string() }))
+var imageGenerationInputSchema = lazySchema16(() => zodSchema16(z17.object({})));
+var imageGenerationOutputSchema = lazySchema16(
+  () => zodSchema16(z17.object({ result: z17.string() }))
 );
 var imageGenerationToolFactory = createProviderExecutedToolFactory3({
   id: "openai.image_generation",
@@ -2650,29 +2747,29 @@ var imageGeneration = (args = {}) => {
 
 // src/tool/local-shell.ts
 import {
-  createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema2,
-  lazySchema as lazySchema16,
-  zodSchema as zodSchema16
+  createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema3,
+  lazySchema as lazySchema17,
+  zodSchema as zodSchema17
 } from "@ai-sdk/provider-utils";
-import { z as z17 } from "zod/v4";
-var localShellInputSchema = lazySchema16(
-  () => zodSchema16(
-    z17.object({
-      action: z17.object({
-        type: z17.literal("exec"),
-        command: z17.array(z17.string()),
-        timeoutMs: z17.number().optional(),
-        user: z17.string().optional(),
-        workingDirectory: z17.string().optional(),
-        env: z17.record(z17.string(), z17.string()).optional()
+import { z as z18 } from "zod/v4";
+var localShellInputSchema = lazySchema17(
+  () => zodSchema17(
+    z18.object({
+      action: z18.object({
+        type: z18.literal("exec"),
+        command: z18.array(z18.string()),
+        timeoutMs: z18.number().optional(),
+        user: z18.string().optional(),
+        workingDirectory: z18.string().optional(),
+        env: z18.record(z18.string(), z18.string()).optional()
       })
     })
   )
 );
-var localShellOutputSchema = lazySchema16(
-  () => zodSchema16(z17.object({ output: z17.string() }))
+var localShellOutputSchema = lazySchema17(
+  () => zodSchema17(z18.object({ output: z18.string() }))
 );
-var localShell = createProviderDefinedToolFactoryWithOutputSchema2({
+var localShell = createProviderDefinedToolFactoryWithOutputSchema3({
   id: "openai.local_shell",
   inputSchema: localShellInputSchema,
   outputSchema: localShellOutputSchema
@@ -2680,92 +2777,92 @@ var localShell = createProviderDefinedToolFactoryWithOutputSchema2({
 
 // src/tool/shell.ts
 import {
-  createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema3,
-  lazySchema as lazySchema17,
-  zodSchema as zodSchema17
+  createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema4,
+  lazySchema as lazySchema18,
+  zodSchema as zodSchema18
 } from "@ai-sdk/provider-utils";
-import { z as z18 } from "zod/v4";
-var shellInputSchema = lazySchema17(
-  () => zodSchema17(
-    z18.object({
-      action: z18.object({
-        commands: z18.array(z18.string()),
-        timeoutMs: z18.number().optional(),
-        maxOutputLength: z18.number().optional()
+import { z as z19 } from "zod/v4";
+var shellInputSchema = lazySchema18(
+  () => zodSchema18(
+    z19.object({
+      action: z19.object({
+        commands: z19.array(z19.string()),
+        timeoutMs: z19.number().optional(),
+        maxOutputLength: z19.number().optional()
       })
     })
   )
 );
-var shellOutputSchema = lazySchema17(
-  () => zodSchema17(
-    z18.object({
-      output: z18.array(
-        z18.object({
-          stdout: z18.string(),
-          stderr: z18.string(),
-          outcome: z18.discriminatedUnion("type", [
-            z18.object({ type: z18.literal("timeout") }),
-            z18.object({ type: z18.literal("exit"), exitCode: z18.number() })
+var shellOutputSchema = lazySchema18(
+  () => zodSchema18(
+    z19.object({
+      output: z19.array(
+        z19.object({
+          stdout: z19.string(),
+          stderr: z19.string(),
+          outcome: z19.discriminatedUnion("type", [
+            z19.object({ type: z19.literal("timeout") }),
+            z19.object({ type: z19.literal("exit"), exitCode: z19.number() })
           ])
         })
       )
     })
   )
 );
-var shellSkillsSchema = z18.array(
-  z18.discriminatedUnion("type", [
-    z18.object({
-      type: z18.literal("skillReference"),
-      providerReference: z18.record(z18.string(), z18.string()),
-      version: z18.string().optional()
+var shellSkillsSchema = z19.array(
+  z19.discriminatedUnion("type", [
+    z19.object({
+      type: z19.literal("skillReference"),
+      providerReference: z19.record(z19.string(), z19.string()),
+      version: z19.string().optional()
     }),
-    z18.object({
-      type: z18.literal("inline"),
-      name: z18.string(),
-      description: z18.string(),
-      source: z18.object({
-        type: z18.literal("base64"),
-        mediaType: z18.literal("application/zip"),
-        data: z18.string()
+    z19.object({
+      type: z19.literal("inline"),
+      name: z19.string(),
+      description: z19.string(),
+      source: z19.object({
+        type: z19.literal("base64"),
+        mediaType: z19.literal("application/zip"),
+        data: z19.string()
       })
     })
   ])
 ).optional();
-var shellArgsSchema = lazySchema17(
-  () => zodSchema17(
-    z18.object({
-      environment: z18.union([
-        z18.object({
-          type: z18.literal("containerAuto"),
-          fileIds: z18.array(z18.string()).optional(),
-          memoryLimit: z18.enum(["1g", "4g", "16g", "64g"]).optional(),
-          networkPolicy: z18.discriminatedUnion("type", [
-            z18.object({ type: z18.literal("disabled") }),
-            z18.object({
-              type: z18.literal("allowlist"),
-              allowedDomains: z18.array(z18.string()),
-              domainSecrets: z18.array(
-                z18.object({
-                  domain: z18.string(),
-                  name: z18.string(),
-                  value: z18.string()
+var shellArgsSchema = lazySchema18(
+  () => zodSchema18(
+    z19.object({
+      environment: z19.union([
+        z19.object({
+          type: z19.literal("containerAuto"),
+          fileIds: z19.array(z19.string()).optional(),
+          memoryLimit: z19.enum(["1g", "4g", "16g", "64g"]).optional(),
+          networkPolicy: z19.discriminatedUnion("type", [
+            z19.object({ type: z19.literal("disabled") }),
+            z19.object({
+              type: z19.literal("allowlist"),
+              allowedDomains: z19.array(z19.string()),
+              domainSecrets: z19.array(
+                z19.object({
+                  domain: z19.string(),
+                  name: z19.string(),
+                  value: z19.string()
                 })
               ).optional()
             })
           ]).optional(),
           skills: shellSkillsSchema
         }),
-        z18.object({
-          type: z18.literal("containerReference"),
-          containerId: z18.string()
+        z19.object({
+          type: z19.literal("containerReference"),
+          containerId: z19.string()
         }),
-        z18.object({
-          type: z18.literal("local").optional(),
-          skills: z18.array(
-            z18.object({
-              name: z18.string(),
-              description: z18.string(),
-              path: z18.string()
+        z19.object({
+          type: z19.literal("local").optional(),
+          skills: z19.array(
+            z19.object({
+              name: z19.string(),
+              description: z19.string(),
+              path: z19.string()
             })
           ).optional()
         })
@@ -2773,7 +2870,7 @@ var shellArgsSchema = lazySchema17(
     })
   )
 );
-var shell = createProviderDefinedToolFactoryWithOutputSchema3({
+var shell = createProviderDefinedToolFactoryWithOutputSchema4({
   id: "openai.shell",
   inputSchema: shellInputSchema,
   outputSchema: shellOutputSchema
@@ -2781,36 +2878,36 @@ var shell = createProviderDefinedToolFactoryWithOutputSchema3({
 
 // src/tool/tool-search.ts
 import {
-  createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema4,
-  lazySchema as lazySchema18,
-  zodSchema as zodSchema18
+  createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema5,
+  lazySchema as lazySchema19,
+  zodSchema as zodSchema19
 } from "@ai-sdk/provider-utils";
-import { z as z19 } from "zod/v4";
-var toolSearchArgsSchema = lazySchema18(
-  () => zodSchema18(
-    z19.object({
-      execution: z19.enum(["server", "client"]).optional(),
-      description: z19.string().optional(),
-      parameters: z19.record(z19.string(), z19.unknown()).optional()
+import { z as z20 } from "zod/v4";
+var toolSearchArgsSchema = lazySchema19(
+  () => zodSchema19(
+    z20.object({
+      execution: z20.enum(["server", "client"]).optional(),
+      description: z20.string().optional(),
+      parameters: z20.record(z20.string(), z20.unknown()).optional()
     })
   )
 );
-var toolSearchInputSchema = lazySchema18(
-  () => zodSchema18(
-    z19.object({
-      arguments: z19.unknown().optional(),
-      call_id: z19.string().nullish()
+var toolSearchInputSchema = lazySchema19(
+  () => zodSchema19(
+    z20.object({
+      arguments: z20.unknown().optional(),
+      call_id: z20.string().nullish()
     })
   )
 );
-var toolSearchOutputSchema = lazySchema18(
-  () => zodSchema18(
-    z19.object({
-      tools: z19.array(z19.record(z19.string(), z19.unknown()))
+var toolSearchOutputSchema = lazySchema19(
+  () => zodSchema19(
+    z20.object({
+      tools: z20.array(z20.record(z20.string(), z20.unknown()))
     })
   )
 );
-var toolSearchToolFactory = createProviderDefinedToolFactoryWithOutputSchema4({
+var toolSearchToolFactory = createProviderDefinedToolFactoryWithOutputSchema5({
   id: "openai.tool_search",
   inputSchema: toolSearchInputSchema,
   outputSchema: toolSearchOutputSchema
@@ -2820,50 +2917,50 @@ var toolSearch = (args = {}) => toolSearchToolFactory(args);
 // src/tool/web-search.ts
 import {
   createProviderExecutedToolFactory as createProviderExecutedToolFactory4,
-  lazySchema as lazySchema19,
-  zodSchema as zodSchema19
+  lazySchema as lazySchema20,
+  zodSchema as zodSchema20
 } from "@ai-sdk/provider-utils";
-import { z as z20 } from "zod/v4";
-var webSearchArgsSchema = lazySchema19(
-  () => zodSchema19(
-    z20.object({
-      externalWebAccess: z20.boolean().optional(),
-      filters: z20.object({ allowedDomains: z20.array(z20.string()).optional() }).optional(),
-      searchContextSize: z20.enum(["low", "medium", "high"]).optional(),
-      userLocation: z20.object({
-        type: z20.literal("approximate"),
-        country: z20.string().optional(),
-        city: z20.string().optional(),
-        region: z20.string().optional(),
-        timezone: z20.string().optional()
+import { z as z21 } from "zod/v4";
+var webSearchArgsSchema = lazySchema20(
+  () => zodSchema20(
+    z21.object({
+      externalWebAccess: z21.boolean().optional(),
+      filters: z21.object({ allowedDomains: z21.array(z21.string()).optional() }).optional(),
+      searchContextSize: z21.enum(["low", "medium", "high"]).optional(),
+      userLocation: z21.object({
+        type: z21.literal("approximate"),
+        country: z21.string().optional(),
+        city: z21.string().optional(),
+        region: z21.string().optional(),
+        timezone: z21.string().optional()
       }).optional()
     })
   )
 );
-var webSearchInputSchema = lazySchema19(() => zodSchema19(z20.object({})));
-var webSearchOutputSchema = lazySchema19(
-  () => zodSchema19(
-    z20.object({
-      action: z20.discriminatedUnion("type", [
-        z20.object({
-          type: z20.literal("search"),
-          query: z20.string().optional(),
-          queries: z20.array(z20.string()).optional()
+var webSearchInputSchema = lazySchema20(() => zodSchema20(z21.object({})));
+var webSearchOutputSchema = lazySchema20(
+  () => zodSchema20(
+    z21.object({
+      action: z21.discriminatedUnion("type", [
+        z21.object({
+          type: z21.literal("search"),
+          query: z21.string().optional(),
+          queries: z21.array(z21.string()).optional()
         }),
-        z20.object({
-          type: z20.literal("openPage"),
-          url: z20.string().nullish()
+        z21.object({
+          type: z21.literal("openPage"),
+          url: z21.string().nullish()
         }),
-        z20.object({
-          type: z20.literal("findInPage"),
-          url: z20.string().nullish(),
-          pattern: z20.string().nullish()
+        z21.object({
+          type: z21.literal("findInPage"),
+          url: z21.string().nullish(),
+          pattern: z21.string().nullish()
         })
       ]).optional(),
-      sources: z20.array(
-        z20.discriminatedUnion("type", [
-          z20.object({ type: z20.literal("url"), url: z20.string() }),
-          z20.object({ type: z20.literal("api"), name: z20.string() })
+      sources: z21.array(
+        z21.discriminatedUnion("type", [
+          z21.object({ type: z21.literal("url"), url: z21.string() }),
+          z21.object({ type: z21.literal("api"), name: z21.string() })
         ])
       ).optional()
     })
@@ -2879,43 +2976,43 @@ var webSearch = (args = {}) => webSearchToolFactory(args);
 // src/tool/web-search-preview.ts
 import {
   createProviderExecutedToolFactory as createProviderExecutedToolFactory5,
-  lazySchema as lazySchema20,
-  zodSchema as zodSchema20
+  lazySchema as lazySchema21,
+  zodSchema as zodSchema21
 } from "@ai-sdk/provider-utils";
-import { z as z21 } from "zod/v4";
-var webSearchPreviewArgsSchema = lazySchema20(
-  () => zodSchema20(
-    z21.object({
-      searchContextSize: z21.enum(["low", "medium", "high"]).optional(),
-      userLocation: z21.object({
-        type: z21.literal("approximate"),
-        country: z21.string().optional(),
-        city: z21.string().optional(),
-        region: z21.string().optional(),
-        timezone: z21.string().optional()
+import { z as z22 } from "zod/v4";
+var webSearchPreviewArgsSchema = lazySchema21(
+  () => zodSchema21(
+    z22.object({
+      searchContextSize: z22.enum(["low", "medium", "high"]).optional(),
+      userLocation: z22.object({
+        type: z22.literal("approximate"),
+        country: z22.string().optional(),
+        city: z22.string().optional(),
+        region: z22.string().optional(),
+        timezone: z22.string().optional()
       }).optional()
     })
   )
 );
-var webSearchPreviewInputSchema = lazySchema20(
-  () => zodSchema20(z21.object({}))
+var webSearchPreviewInputSchema = lazySchema21(
+  () => zodSchema21(z22.object({}))
 );
-var webSearchPreviewOutputSchema = lazySchema20(
-  () => zodSchema20(
-    z21.object({
-      action: z21.discriminatedUnion("type", [
-        z21.object({
-          type: z21.literal("search"),
-          query: z21.string().optional()
+var webSearchPreviewOutputSchema = lazySchema21(
+  () => zodSchema21(
+    z22.object({
+      action: z22.discriminatedUnion("type", [
+        z22.object({
+          type: z22.literal("search"),
+          query: z22.string().optional()
         }),
-        z21.object({
-          type: z21.literal("openPage"),
-          url: z21.string().nullish()
+        z22.object({
+          type: z22.literal("openPage"),
+          url: z22.string().nullish()
         }),
-        z21.object({
-          type: z21.literal("findInPage"),
-          url: z21.string().nullish(),
-          pattern: z21.string().nullish()
+        z22.object({
+          type: z22.literal("findInPage"),
+          url: z22.string().nullish(),
+          pattern: z22.string().nullish()
         })
       ]).optional()
     })
@@ -2930,60 +3027,60 @@ var webSearchPreview = createProviderExecutedToolFactory5({
 // src/tool/mcp.ts
 import {
   createProviderExecutedToolFactory as createProviderExecutedToolFactory6,
-  lazySchema as lazySchema21,
-  zodSchema as zodSchema21
+  lazySchema as lazySchema22,
+  zodSchema as zodSchema22
 } from "@ai-sdk/provider-utils";
-import { z as z22 } from "zod/v4";
-var jsonValueSchema = z22.lazy(
-  () => z22.union([
-    z22.string(),
-    z22.number(),
-    z22.boolean(),
-    z22.null(),
-    z22.array(jsonValueSchema),
-    z22.record(z22.string(), jsonValueSchema)
+import { z as z23 } from "zod/v4";
+var jsonValueSchema = z23.lazy(
+  () => z23.union([
+    z23.string(),
+    z23.number(),
+    z23.boolean(),
+    z23.null(),
+    z23.array(jsonValueSchema),
+    z23.record(z23.string(), jsonValueSchema)
   ])
 );
-var mcpArgsSchema = lazySchema21(
-  () => zodSchema21(
-    z22.object({
-      serverLabel: z22.string(),
-      allowedTools: z22.union([
-        z22.array(z22.string()),
-        z22.object({
-          readOnly: z22.boolean().optional(),
-          toolNames: z22.array(z22.string()).optional()
+var mcpArgsSchema = lazySchema22(
+  () => zodSchema22(
+    z23.object({
+      serverLabel: z23.string(),
+      allowedTools: z23.union([
+        z23.array(z23.string()),
+        z23.object({
+          readOnly: z23.boolean().optional(),
+          toolNames: z23.array(z23.string()).optional()
         })
       ]).optional(),
-      authorization: z22.string().optional(),
-      connectorId: z22.string().optional(),
-      headers: z22.record(z22.string(), z22.string()).optional(),
-      requireApproval: z22.union([
-        z22.enum(["always", "never"]),
-        z22.object({
-          never: z22.object({
-            toolNames: z22.array(z22.string()).optional()
+      authorization: z23.string().optional(),
+      connectorId: z23.string().optional(),
+      headers: z23.record(z23.string(), z23.string()).optional(),
+      requireApproval: z23.union([
+        z23.enum(["always", "never"]),
+        z23.object({
+          never: z23.object({
+            toolNames: z23.array(z23.string()).optional()
           }).optional()
         })
       ]).optional(),
-      serverDescription: z22.string().optional(),
-      serverUrl: z22.string().optional()
+      serverDescription: z23.string().optional(),
+      serverUrl: z23.string().optional()
     }).refine(
       (v) => v.serverUrl != null || v.connectorId != null,
       "One of serverUrl or connectorId must be provided."
     )
   )
 );
-var mcpInputSchema = lazySchema21(() => zodSchema21(z22.object({})));
-var mcpOutputSchema = lazySchema21(
-  () => zodSchema21(
-    z22.object({
-      type: z22.literal("call"),
-      serverLabel: z22.string(),
-      name: z22.string(),
-      arguments: z22.string(),
-      output: z22.string().nullish(),
-      error: z22.union([z22.string(), jsonValueSchema]).optional()
+var mcpInputSchema = lazySchema22(() => zodSchema22(z23.object({})));
+var mcpOutputSchema = lazySchema22(
+  () => zodSchema22(
+    z23.object({
+      type: z23.literal("call"),
+      serverLabel: z23.string(),
+      name: z23.string(),
+      arguments: z23.string(),
+      output: z23.string().nullish(),
+      error: z23.union([z23.string(), jsonValueSchema]).optional()
     })
   )
 );
@@ -3021,6 +3118,15 @@ var openaiTools = {
    * @param container - The container to use for the code interpreter.
    */
   codeInterpreter,
+  /**
+   * The computer tool allows models to operate a browser or desktop through
+   * batched UI actions. Your application executes the actions and returns an
+   * updated screenshot.
+   *
+   * WARNING: Run computer use in an isolated environment, treat on-screen
+   * content as untrusted, and require confirmation for consequential actions.
+   */
+  computer,
   /**
    * File search is a tool available in the Responses API. It enables models to
    * retrieve information in a knowledge base of previously uploaded files through
@@ -3572,7 +3678,7 @@ import {
   resolveProviderReference as resolveProviderReference2,
   validateTypes
 } from "@ai-sdk/provider-utils";
-import { z as z23 } from "zod/v4";
+import { z as z24 } from "zod/v4";
 function serializeToolCallArguments2(input) {
   return JSON.stringify(input === void 0 ? {} : input);
 }
@@ -3597,9 +3703,10 @@ async function convertToOpenAIResponsesInput({
   hasLocalShellTool = false,
   hasShellTool = false,
   hasApplyPatchTool = false,
+  hasComputerTool = false,
   customProviderToolNames
 }) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
   let input = [];
   const warnings = [];
   const processedApprovalIds = /* @__PURE__ */ new Set();
@@ -3823,7 +3930,7 @@ async function convertToOpenAIResponsesInput({
               if (hasPreviousResponseId && store && id != null) {
                 break;
               }
-              const isProviderDefinedToolCall = hasLocalShellTool && resolvedToolName === "local_shell" || hasShellTool && resolvedToolName === "shell" || hasApplyPatchTool && resolvedToolName === "apply_patch" || ((_m = customProviderToolNames == null ? void 0 : customProviderToolNames.has(resolvedToolName)) != null ? _m : false);
+              const isProviderDefinedToolCall = hasLocalShellTool && resolvedToolName === "local_shell" || hasShellTool && resolvedToolName === "shell" || hasApplyPatchTool && resolvedToolName === "apply_patch" || hasComputerTool && resolvedToolName === "computer" || ((_m = customProviderToolNames == null ? void 0 : customProviderToolNames.has(resolvedToolName)) != null ? _m : false);
               if (store && id != null && isProviderDefinedToolCall) {
                 input.push({ type: "item_reference", id });
                 break;
@@ -3880,6 +3987,53 @@ async function convertToOpenAIResponsesInput({
                 });
                 break;
               }
+              if (hasComputerTool && resolvedToolName === "computer") {
+                const parsedInput = await validateTypes({
+                  value: part.input,
+                  schema: computerInputSchema
+                });
+                input.push({
+                  type: "computer_call",
+                  call_id: part.toolCallId,
+                  id,
+                  status: parsedInput.status,
+                  actions: parsedInput.actions.map((action) => {
+                    switch (action.type) {
+                      case "click":
+                      case "double_click":
+                      case "move":
+                        return {
+                          ...action,
+                          keys: action.keys
+                        };
+                      case "drag":
+                        return {
+                          ...action,
+                          keys: action.keys
+                        };
+                      case "scroll":
+                        return {
+                          type: "scroll",
+                          x: action.x,
+                          y: action.y,
+                          scroll_x: action.scrollX,
+                          scroll_y: action.scrollY,
+                          keys: action.keys
+                        };
+                      default:
+                        return action;
+                    }
+                  }),
+                  pending_safety_checks: parsedInput.pendingSafetyChecks.map(
+                    (safetyCheck) => ({
+                      id: safetyCheck.id,
+                      code: safetyCheck.code,
+                      message: safetyCheck.message
+                    })
+                  )
+                });
+                break;
+              }
               if (customProviderToolNames == null ? void 0 : customProviderToolNames.has(resolvedToolName)) {
                 input.push({
                   type: "custom_tool_call",
@@ -4150,6 +4304,28 @@ async function convertToOpenAIResponsesInput({
             });
             continue;
           }
+          if (hasComputerTool && resolvedToolName === "computer" && output.type === "json") {
+            const parsedOutput = await validateTypes({
+              value: output.value,
+              schema: computerOutputSchema
+            });
+            input.push({
+              type: "computer_call_output",
+              call_id: part.toolCallId,
+              output: {
+                type: "computer_screenshot",
+                image_url: parsedOutput.output.imageUrl,
+                file_id: parsedOutput.output.fileId,
+                detail: parsedOutput.output.detail
+              },
+              acknowledged_safety_checks: (_w = parsedOutput.acknowledgedSafetyChecks) == null ? void 0 : _w.map((safetyCheck) => ({
+                id: safetyCheck.id,
+                code: safetyCheck.code,
+                message: safetyCheck.message
+              }))
+            });
+            continue;
+          }
           if (customProviderToolNames == null ? void 0 : customProviderToolNames.has(resolvedToolName)) {
             let outputValue;
             switch (output.type) {
@@ -4158,7 +4334,7 @@ async function convertToOpenAIResponsesInput({
                 outputValue = output.value;
                 break;
               case "execution-denied":
-                outputValue = (_w = output.reason) != null ? _w : "Tool call execution denied.";
+                outputValue = (_x = output.reason) != null ? _x : "Tool call execution denied.";
                 break;
               case "json":
               case "error-json":
@@ -4257,7 +4433,7 @@ async function convertToOpenAIResponsesInput({
               contentValue = output.value;
               break;
             case "execution-denied":
-              contentValue = (_x = output.reason) != null ? _x : "Tool call execution denied.";
+              contentValue = (_y = output.reason) != null ? _y : "Tool call execution denied.";
               break;
             case "json":
             case "error-json":
@@ -4369,9 +4545,9 @@ async function convertToOpenAIResponsesInput({
   }
   return { input, warnings };
 }
-var openaiResponsesReasoningProviderOptionsSchema = z23.object({
-  itemId: z23.string().nullish(),
-  reasoningEncryptedContent: z23.string().nullish()
+var openaiResponsesReasoningProviderOptionsSchema = z24.object({
+  itemId: z24.string().nullish(),
+  reasoningEncryptedContent: z24.string().nullish()
 });
 
 // src/responses/map-openai-responses-finish-reason.ts
@@ -4394,589 +4570,643 @@ function mapOpenAIResponseFinishReason({
 
 // src/responses/openai-responses-api.ts
 import {
-  lazySchema as lazySchema22,
-  zodSchema as zodSchema22
+  lazySchema as lazySchema23,
+  zodSchema as zodSchema23
 } from "@ai-sdk/provider-utils";
-import { z as z24 } from "zod/v4";
-var jsonValueSchema2 = z24.lazy(
-  () => z24.union([
-    z24.string(),
-    z24.number(),
-    z24.boolean(),
-    z24.null(),
-    z24.array(jsonValueSchema2),
-    z24.record(z24.string(), jsonValueSchema2.optional())
+import { z as z25 } from "zod/v4";
+var jsonValueSchema2 = z25.lazy(
+  () => z25.union([
+    z25.string(),
+    z25.number(),
+    z25.boolean(),
+    z25.null(),
+    z25.array(jsonValueSchema2),
+    z25.record(z25.string(), jsonValueSchema2.optional())
   ])
 );
-var openaiResponsesNestedErrorChunkSchema = z24.object({
-  type: z24.literal("error"),
-  sequence_number: z24.number(),
-  error: z24.object({
-    type: z24.string(),
-    code: z24.string(),
-    message: z24.string(),
-    param: z24.string().nullish()
+var openaiResponsesComputerSafetyCheckSchema = z25.object({
+  id: z25.string(),
+  code: z25.string().nullish(),
+  message: z25.string().nullish()
+});
+var openaiResponsesComputerActionSchema = z25.discriminatedUnion("type", [
+  z25.object({
+    type: z25.literal("click"),
+    button: z25.enum(["left", "right", "wheel", "back", "forward"]),
+    x: z25.number(),
+    y: z25.number(),
+    keys: z25.array(z25.string()).nullish()
+  }),
+  z25.object({
+    type: z25.literal("double_click"),
+    x: z25.number(),
+    y: z25.number(),
+    keys: z25.array(z25.string()).nullish()
+  }),
+  z25.object({
+    type: z25.literal("drag"),
+    path: z25.array(z25.object({ x: z25.number(), y: z25.number() })),
+    keys: z25.array(z25.string()).nullish()
+  }),
+  z25.object({
+    type: z25.literal("keypress"),
+    keys: z25.array(z25.string())
+  }),
+  z25.object({
+    type: z25.literal("move"),
+    x: z25.number(),
+    y: z25.number(),
+    keys: z25.array(z25.string()).nullish()
+  }),
+  z25.object({
+    type: z25.literal("screenshot")
+  }),
+  z25.object({
+    type: z25.literal("scroll"),
+    x: z25.number(),
+    y: z25.number(),
+    scroll_x: z25.number(),
+    scroll_y: z25.number(),
+    keys: z25.array(z25.string()).nullish()
+  }),
+  z25.object({
+    type: z25.literal("type"),
+    text: z25.string()
+  }),
+  z25.object({
+    type: z25.literal("wait")
   })
+]);
+var openaiResponsesComputerCallSchema = z25.object({
+  type: z25.literal("computer_call"),
+  id: z25.string(),
+  call_id: z25.string().nullish(),
+  status: z25.enum(["in_progress", "completed", "incomplete"]),
+  action: openaiResponsesComputerActionSchema.nullish(),
+  actions: z25.array(openaiResponsesComputerActionSchema).nullish(),
+  pending_safety_checks: z25.array(openaiResponsesComputerSafetyCheckSchema).nullish()
 });
-var openaiResponsesErrorChunkSchema = z24.object({
-  type: z24.literal("error"),
-  sequence_number: z24.number(),
-  code: z24.string().nullish(),
-  message: z24.string(),
-  param: z24.string().nullish()
+var openaiResponsesNestedErrorChunkSchema = z25.object({
+  type: z25.literal("error"),
+  sequence_number: z25.number(),
+  error: z25.object({
+    type: z25.string(),
+    code: z25.string(),
+    message: z25.string(),
+    param: z25.string().nullish()
+  })
 });
-var openaiResponsesChunkSchema = lazySchema22(
-  () => zodSchema22(
-    z24.union([
-      z24.object({
-        type: z24.literal("response.output_text.delta"),
-        item_id: z24.string(),
-        delta: z24.string(),
-        logprobs: z24.array(
-          z24.object({
-            token: z24.string(),
-            logprob: z24.number(),
-            top_logprobs: z24.array(
-              z24.object({
-                token: z24.string(),
-                logprob: z24.number()
+var openaiResponsesErrorChunkSchema = z25.object({
+  type: z25.literal("error"),
+  sequence_number: z25.number(),
+  code: z25.string().nullish(),
+  message: z25.string(),
+  param: z25.string().nullish()
+});
+var openaiResponsesChunkSchema = lazySchema23(
+  () => zodSchema23(
+    z25.union([
+      z25.object({
+        type: z25.literal("response.output_text.delta"),
+        item_id: z25.string(),
+        delta: z25.string(),
+        logprobs: z25.array(
+          z25.object({
+            token: z25.string(),
+            logprob: z25.number(),
+            top_logprobs: z25.array(
+              z25.object({
+                token: z25.string(),
+                logprob: z25.number()
               })
             )
           })
         ).nullish()
       }),
-      z24.object({
-        type: z24.enum(["response.completed", "response.incomplete"]),
-        response: z24.object({
-          incomplete_details: z24.object({ reason: z24.string() }).nullish(),
-          usage: z24.object({
-            input_tokens: z24.number(),
-            input_tokens_details: z24.object({
-              cached_tokens: z24.number().nullish(),
-              cache_write_tokens: z24.number().nullish(),
-              orchestration_input_tokens: z24.number().nullish(),
-              orchestration_input_cached_tokens: z24.number().nullish()
+      z25.object({
+        type: z25.enum(["response.completed", "response.incomplete"]),
+        response: z25.object({
+          incomplete_details: z25.object({ reason: z25.string() }).nullish(),
+          usage: z25.object({
+            input_tokens: z25.number(),
+            input_tokens_details: z25.object({
+              cached_tokens: z25.number().nullish(),
+              cache_write_tokens: z25.number().nullish(),
+              orchestration_input_tokens: z25.number().nullish(),
+              orchestration_input_cached_tokens: z25.number().nullish()
             }).nullish(),
-            output_tokens: z24.number(),
-            output_tokens_details: z24.object({
-              reasoning_tokens: z24.number().nullish(),
-              orchestration_output_tokens: z24.number().nullish()
+            output_tokens: z25.number(),
+            output_tokens_details: z25.object({
+              reasoning_tokens: z25.number().nullish(),
+              orchestration_output_tokens: z25.number().nullish()
             }).nullish()
           }),
-          reasoning: z24.object({
-            context: z24.string().nullish()
+          reasoning: z25.object({
+            context: z25.string().nullish()
           }).nullish(),
-          service_tier: z24.string().nullish()
+          service_tier: z25.string().nullish()
         })
       }),
-      z24.object({
-        type: z24.literal("response.failed"),
-        sequence_number: z24.number(),
-        response: z24.object({
-          error: z24.object({
-            code: z24.string().nullish(),
-            message: z24.string()
+      z25.object({
+        type: z25.literal("response.failed"),
+        sequence_number: z25.number(),
+        response: z25.object({
+          error: z25.object({
+            code: z25.string().nullish(),
+            message: z25.string()
           }).nullish(),
-          incomplete_details: z24.object({ reason: z24.string() }).nullish(),
-          usage: z24.object({
-            input_tokens: z24.number(),
-            input_tokens_details: z24.object({
-              cached_tokens: z24.number().nullish(),
-              cache_write_tokens: z24.number().nullish(),
-              orchestration_input_tokens: z24.number().nullish(),
-              orchestration_input_cached_tokens: z24.number().nullish()
+          incomplete_details: z25.object({ reason: z25.string() }).nullish(),
+          usage: z25.object({
+            input_tokens: z25.number(),
+            input_tokens_details: z25.object({
+              cached_tokens: z25.number().nullish(),
+              cache_write_tokens: z25.number().nullish(),
+              orchestration_input_tokens: z25.number().nullish(),
+              orchestration_input_cached_tokens: z25.number().nullish()
             }).nullish(),
-            output_tokens: z24.number(),
-            output_tokens_details: z24.object({
-              reasoning_tokens: z24.number().nullish(),
-              orchestration_output_tokens: z24.number().nullish()
+            output_tokens: z25.number(),
+            output_tokens_details: z25.object({
+              reasoning_tokens: z25.number().nullish(),
+              orchestration_output_tokens: z25.number().nullish()
             }).nullish()
           }).nullish(),
-          reasoning: z24.object({
-            context: z24.string().nullish()
+          reasoning: z25.object({
+            context: z25.string().nullish()
           }).nullish(),
-          service_tier: z24.string().nullish()
+          service_tier: z25.string().nullish()
         })
       }),
-      z24.object({
-        type: z24.literal("response.created"),
-        response: z24.object({
-          id: z24.string(),
-          created_at: z24.number(),
-          model: z24.string(),
-          service_tier: z24.string().nullish()
+      z25.object({
+        type: z25.literal("response.created"),
+        response: z25.object({
+          id: z25.string(),
+          created_at: z25.number(),
+          model: z25.string(),
+          service_tier: z25.string().nullish()
         })
       }),
-      z24.object({
-        type: z24.literal("response.output_item.added"),
-        output_index: z24.number(),
-        item: z24.discriminatedUnion("type", [
-          z24.object({
-            type: z24.literal("message"),
-            id: z24.string(),
-            phase: z24.enum(["commentary", "final_answer"]).nullish()
-          }),
-          z24.object({
-            type: z24.literal("reasoning"),
-            id: z24.string(),
-            encrypted_content: z24.string().nullish()
+      z25.object({
+        type: z25.literal("response.output_item.added"),
+        output_index: z25.number(),
+        item: z25.discriminatedUnion("type", [
+          z25.object({
+            type: z25.literal("message"),
+            id: z25.string(),
+            phase: z25.enum(["commentary", "final_answer"]).nullish()
           }),
-          z24.object({
-            type: z24.literal("function_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            name: z24.string(),
-            arguments: z24.string(),
-            namespace: z24.string().nullish()
+          z25.object({
+            type: z25.literal("reasoning"),
+            id: z25.string(),
+            encrypted_content: z25.string().nullish()
           }),
-          z24.object({
-            type: z24.literal("web_search_call"),
-            id: z24.string(),
-            status: z24.string()
+          z25.object({
+            type: z25.literal("function_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            name: z25.string(),
+            arguments: z25.string(),
+            namespace: z25.string().nullish()
           }),
-          z24.object({
-            type: z24.literal("computer_call"),
-            id: z24.string(),
-            status: z24.string()
+          z25.object({
+            type: z25.literal("web_search_call"),
+            id: z25.string(),
+            status: z25.string()
           }),
-          z24.object({
-            type: z24.literal("file_search_call"),
-            id: z24.string()
+          openaiResponsesComputerCallSchema,
+          z25.object({
+            type: z25.literal("file_search_call"),
+            id: z25.string()
           }),
-          z24.object({
-            type: z24.literal("image_generation_call"),
-            id: z24.string()
+          z25.object({
+            type: z25.literal("image_generation_call"),
+            id: z25.string()
           }),
-          z24.object({
-            type: z24.literal("code_interpreter_call"),
-            id: z24.string(),
-            container_id: z24.string(),
-            code: z24.string().nullable(),
-            outputs: z24.array(
-              z24.discriminatedUnion("type", [
-                z24.object({ type: z24.literal("logs"), logs: z24.string() }),
-                z24.object({ type: z24.literal("image"), url: z24.string() })
+          z25.object({
+            type: z25.literal("code_interpreter_call"),
+            id: z25.string(),
+            container_id: z25.string(),
+            code: z25.string().nullable(),
+            outputs: z25.array(
+              z25.discriminatedUnion("type", [
+                z25.object({ type: z25.literal("logs"), logs: z25.string() }),
+                z25.object({ type: z25.literal("image"), url: z25.string() })
               ])
             ).nullable(),
-            status: z24.string()
+            status: z25.string()
           }),
-          z24.object({
-            type: z24.literal("mcp_call"),
-            id: z24.string(),
-            status: z24.string(),
-            approval_request_id: z24.string().nullish()
+          z25.object({
+            type: z25.literal("mcp_call"),
+            id: z25.string(),
+            status: z25.string(),
+            approval_request_id: z25.string().nullish()
           }),
-          z24.object({
-            type: z24.literal("mcp_list_tools"),
-            id: z24.string()
+          z25.object({
+            type: z25.literal("mcp_list_tools"),
+            id: z25.string()
           }),
-          z24.object({
-            type: z24.literal("mcp_approval_request"),
-            id: z24.string()
+          z25.object({
+            type: z25.literal("mcp_approval_request"),
+            id: z25.string()
           }),
-          z24.object({
-            type: z24.literal("apply_patch_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            status: z24.enum(["in_progress", "completed"]),
-            operation: z24.discriminatedUnion("type", [
-              z24.object({
-                type: z24.literal("create_file"),
-                path: z24.string(),
-                diff: z24.string()
+          z25.object({
+            type: z25.literal("apply_patch_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            status: z25.enum(["in_progress", "completed"]),
+            operation: z25.discriminatedUnion("type", [
+              z25.object({
+                type: z25.literal("create_file"),
+                path: z25.string(),
+                diff: z25.string()
               }),
-              z24.object({
-                type: z24.literal("delete_file"),
-                path: z24.string()
+              z25.object({
+                type: z25.literal("delete_file"),
+                path: z25.string()
               }),
-              z24.object({
-                type: z24.literal("update_file"),
-                path: z24.string(),
-                diff: z24.string()
+              z25.object({
+                type: z25.literal("update_file"),
+                path: z25.string(),
+                diff: z25.string()
               })
             ])
           }),
-          z24.object({
-            type: z24.literal("custom_tool_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            name: z24.string(),
-            input: z24.string()
+          z25.object({
+            type: z25.literal("custom_tool_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            name: z25.string(),
+            input: z25.string()
           }),
-          z24.object({
-            type: z24.literal("shell_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            action: z24.object({
-              commands: z24.array(z24.string())
+          z25.object({
+            type: z25.literal("shell_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            action: z25.object({
+              commands: z25.array(z25.string())
             })
           }),
-          z24.object({
-            type: z24.literal("compaction"),
-            id: z24.string(),
-            encrypted_content: z24.string().nullish()
+          z25.object({
+            type: z25.literal("compaction"),
+            id: z25.string(),
+            encrypted_content: z25.string().nullish()
           }),
-          z24.object({
-            type: z24.literal("shell_call_output"),
-            id: z24.string(),
-            call_id: z24.string(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            output: z24.array(
-              z24.object({
-                stdout: z24.string(),
-                stderr: z24.string(),
-                outcome: z24.discriminatedUnion("type", [
-                  z24.object({ type: z24.literal("timeout") }),
-                  z24.object({
-                    type: z24.literal("exit"),
-                    exit_code: z24.number()
+          z25.object({
+            type: z25.literal("shell_call_output"),
+            id: z25.string(),
+            call_id: z25.string(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            output: z25.array(
+              z25.object({
+                stdout: z25.string(),
+                stderr: z25.string(),
+                outcome: z25.discriminatedUnion("type", [
+                  z25.object({ type: z25.literal("timeout") }),
+                  z25.object({
+                    type: z25.literal("exit"),
+                    exit_code: z25.number()
                   })
                 ])
               })
             )
           }),
-          z24.object({
-            type: z24.literal("tool_search_call"),
-            id: z24.string(),
-            execution: z24.enum(["server", "client"]),
-            call_id: z24.string().nullable(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            arguments: z24.unknown()
+          z25.object({
+            type: z25.literal("tool_search_call"),
+            id: z25.string(),
+            execution: z25.enum(["server", "client"]),
+            call_id: z25.string().nullable(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            arguments: z25.unknown()
           }),
-          z24.object({
-            type: z24.literal("tool_search_output"),
-            id: z24.string(),
-            execution: z24.enum(["server", "client"]),
-            call_id: z24.string().nullable(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            tools: z24.array(z24.record(z24.string(), jsonValueSchema2.optional()))
+          z25.object({
+            type: z25.literal("tool_search_output"),
+            id: z25.string(),
+            execution: z25.enum(["server", "client"]),
+            call_id: z25.string().nullable(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            tools: z25.array(z25.record(z25.string(), jsonValueSchema2.optional()))
           })
         ])
       }),
-      z24.object({
-        type: z24.literal("response.output_item.done"),
-        output_index: z24.number(),
-        item: z24.discriminatedUnion("type", [
-          z24.object({
-            type: z24.literal("message"),
-            id: z24.string(),
-            phase: z24.enum(["commentary", "final_answer"]).nullish()
+      z25.object({
+        type: z25.literal("response.output_item.done"),
+        output_index: z25.number(),
+        item: z25.discriminatedUnion("type", [
+          z25.object({
+            type: z25.literal("message"),
+            id: z25.string(),
+            phase: z25.enum(["commentary", "final_answer"]).nullish()
           }),
-          z24.object({
-            type: z24.literal("reasoning"),
-            id: z24.string(),
-            encrypted_content: z24.string().nullish()
+          z25.object({
+            type: z25.literal("reasoning"),
+            id: z25.string(),
+            encrypted_content: z25.string().nullish()
           }),
-          z24.object({
-            type: z24.literal("function_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            name: z24.string(),
-            arguments: z24.string(),
-            status: z24.literal("completed"),
-            namespace: z24.string().nullish()
+          z25.object({
+            type: z25.literal("function_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            name: z25.string(),
+            arguments: z25.string(),
+            status: z25.literal("completed"),
+            namespace: z25.string().nullish()
           }),
-          z24.object({
-            type: z24.literal("custom_tool_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            name: z24.string(),
-            input: z24.string(),
-            status: z24.literal("completed")
+          z25.object({
+            type: z25.literal("custom_tool_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            name: z25.string(),
+            input: z25.string(),
+            status: z25.literal("completed")
           }),
-          z24.object({
-            type: z24.literal("code_interpreter_call"),
-            id: z24.string(),
-            code: z24.string().nullable(),
-            container_id: z24.string(),
-            outputs: z24.array(
-              z24.discriminatedUnion("type", [
-                z24.object({ type: z24.literal("logs"), logs: z24.string() }),
-                z24.object({ type: z24.literal("image"), url: z24.string() })
+          z25.object({
+            type: z25.literal("code_interpreter_call"),
+            id: z25.string(),
+            code: z25.string().nullable(),
+            container_id: z25.string(),
+            outputs: z25.array(
+              z25.discriminatedUnion("type", [
+                z25.object({ type: z25.literal("logs"), logs: z25.string() }),
+                z25.object({ type: z25.literal("image"), url: z25.string() })
               ])
             ).nullable()
           }),
-          z24.object({
-            type: z24.literal("image_generation_call"),
-            id: z24.string(),
-            result: z24.string()
+          z25.object({
+            type: z25.literal("image_generation_call"),
+            id: z25.string(),
+            result: z25.string()
           }),
-          z24.object({
-            type: z24.literal("web_search_call"),
-            id: z24.string(),
-            status: z24.string(),
-            action: z24.discriminatedUnion("type", [
-              z24.object({
-                type: z24.literal("search"),
-                query: z24.string().nullish(),
-                queries: z24.array(z24.string()).nullish(),
-                sources: z24.array(
-                  z24.discriminatedUnion("type", [
-                    z24.object({ type: z24.literal("url"), url: z24.string() }),
-                    z24.object({ type: z24.literal("api"), name: z24.string() })
+          z25.object({
+            type: z25.literal("web_search_call"),
+            id: z25.string(),
+            status: z25.string(),
+            action: z25.discriminatedUnion("type", [
+              z25.object({
+                type: z25.literal("search"),
+                query: z25.string().nullish(),
+                queries: z25.array(z25.string()).nullish(),
+                sources: z25.array(
+                  z25.discriminatedUnion("type", [
+                    z25.object({ type: z25.literal("url"), url: z25.string() }),
+                    z25.object({ type: z25.literal("api"), name: z25.string() })
                   ])
                 ).nullish()
               }),
-              z24.object({
-                type: z24.literal("open_page"),
-                url: z24.string().nullish()
+              z25.object({
+                type: z25.literal("open_page"),
+                url: z25.string().nullish()
               }),
-              z24.object({
-                type: z24.literal("find_in_page"),
-                url: z24.string().nullish(),
-                pattern: z24.string().nullish()
+              z25.object({
+                type: z25.literal("find_in_page"),
+                url: z25.string().nullish(),
+                pattern: z25.string().nullish()
               })
             ]).nullish()
           }),
-          z24.object({
-            type: z24.literal("file_search_call"),
-            id: z24.string(),
-            queries: z24.array(z24.string()),
-            results: z24.array(
-              z24.object({
-                attributes: z24.record(
-                  z24.string(),
-                  z24.union([z24.string(), z24.number(), z24.boolean()])
+          z25.object({
+            type: z25.literal("file_search_call"),
+            id: z25.string(),
+            queries: z25.array(z25.string()),
+            results: z25.array(
+              z25.object({
+                attributes: z25.record(
+                  z25.string(),
+                  z25.union([z25.string(), z25.number(), z25.boolean()])
                 ),
-                file_id: z24.string(),
-                filename: z24.string(),
-                score: z24.number(),
-                text: z24.string()
+                file_id: z25.string(),
+                filename: z25.string(),
+                score: z25.number(),
+                text: z25.string()
               })
             ).nullish()
           }),
-          z24.object({
-            type: z24.literal("local_shell_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            action: z24.object({
-              type: z24.literal("exec"),
-              command: z24.array(z24.string()),
-              timeout_ms: z24.number().optional(),
-              user: z24.string().optional(),
-              working_directory: z24.string().optional(),
-              env: z24.record(z24.string(), z24.string()).optional()
+          z25.object({
+            type: z25.literal("local_shell_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            action: z25.object({
+              type: z25.literal("exec"),
+              command: z25.array(z25.string()),
+              timeout_ms: z25.number().optional(),
+              user: z25.string().optional(),
+              working_directory: z25.string().optional(),
+              env: z25.record(z25.string(), z25.string()).optional()
             })
           }),
-          z24.object({
-            type: z24.literal("computer_call"),
-            id: z24.string(),
-            status: z24.literal("completed")
-          }),
-          z24.object({
-            type: z24.literal("mcp_call"),
-            id: z24.string(),
-            status: z24.string(),
-            arguments: z24.string(),
-            name: z24.string(),
-            server_label: z24.string(),
-            output: z24.string().nullish(),
-            error: z24.union([
-              z24.string(),
-              z24.object({
-                type: z24.string().optional(),
-                code: z24.union([z24.number(), z24.string()]).optional(),
-                message: z24.string().optional()
+          openaiResponsesComputerCallSchema,
+          z25.object({
+            type: z25.literal("mcp_call"),
+            id: z25.string(),
+            status: z25.string(),
+            arguments: z25.string(),
+            name: z25.string(),
+            server_label: z25.string(),
+            output: z25.string().nullish(),
+            error: z25.union([
+              z25.string(),
+              z25.object({
+                type: z25.string().optional(),
+                code: z25.union([z25.number(), z25.string()]).optional(),
+                message: z25.string().optional()
               }).loose()
             ]).nullish(),
-            approval_request_id: z24.string().nullish()
+            approval_request_id: z25.string().nullish()
           }),
-          z24.object({
-            type: z24.literal("mcp_list_tools"),
-            id: z24.string(),
-            server_label: z24.string(),
-            tools: z24.array(
-              z24.object({
-                name: z24.string(),
-                description: z24.string().optional(),
-                input_schema: z24.any(),
-                annotations: z24.record(z24.string(), z24.unknown()).optional()
+          z25.object({
+            type: z25.literal("mcp_list_tools"),
+            id: z25.string(),
+            server_label: z25.string(),
+            tools: z25.array(
+              z25.object({
+                name: z25.string(),
+                description: z25.string().optional(),
+                input_schema: z25.any(),
+                annotations: z25.record(z25.string(), z25.unknown()).optional()
               })
             ),
-            error: z24.union([
-              z24.string(),
-              z24.object({
-                type: z24.string().optional(),
-                code: z24.union([z24.number(), z24.string()]).optional(),
-                message: z24.string().optional()
+            error: z25.union([
+              z25.string(),
+              z25.object({
+                type: z25.string().optional(),
+                code: z25.union([z25.number(), z25.string()]).optional(),
+                message: z25.string().optional()
               }).loose()
             ]).optional()
           }),
-          z24.object({
-            type: z24.literal("mcp_approval_request"),
-            id: z24.string(),
-            server_label: z24.string(),
-            name: z24.string(),
-            arguments: z24.string(),
-            approval_request_id: z24.string().optional()
+          z25.object({
+            type: z25.literal("mcp_approval_request"),
+            id: z25.string(),
+            server_label: z25.string(),
+            name: z25.string(),
+            arguments: z25.string(),
+            approval_request_id: z25.string().optional()
           }),
-          z24.object({
-            type: z24.literal("apply_patch_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            status: z24.enum(["in_progress", "completed"]),
-            operation: z24.discriminatedUnion("type", [
-              z24.object({
-                type: z24.literal("create_file"),
-                path: z24.string(),
-                diff: z24.string()
+          z25.object({
+            type: z25.literal("apply_patch_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            status: z25.enum(["in_progress", "completed"]),
+            operation: z25.discriminatedUnion("type", [
+              z25.object({
+                type: z25.literal("create_file"),
+                path: z25.string(),
+                diff: z25.string()
               }),
-              z24.object({
-                type: z24.literal("delete_file"),
-                path: z24.string()
+              z25.object({
+                type: z25.literal("delete_file"),
+                path: z25.string()
               }),
-              z24.object({
-                type: z24.literal("update_file"),
-                path: z24.string(),
-                diff: z24.string()
+              z25.object({
+                type: z25.literal("update_file"),
+                path: z25.string(),
+                diff: z25.string()
               })
             ])
           }),
-          z24.object({
-            type: z24.literal("shell_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            action: z24.object({
-              commands: z24.array(z24.string())
+          z25.object({
+            type: z25.literal("shell_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            action: z25.object({
+              commands: z25.array(z25.string())
             })
           }),
-          z24.object({
-            type: z24.literal("compaction"),
-            id: z24.string(),
-            encrypted_content: z24.string()
+          z25.object({
+            type: z25.literal("compaction"),
+            id: z25.string(),
+            encrypted_content: z25.string()
           }),
-          z24.object({
-            type: z24.literal("shell_call_output"),
-            id: z24.string(),
-            call_id: z24.string(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            output: z24.array(
-              z24.object({
-                stdout: z24.string(),
-                stderr: z24.string(),
-                outcome: z24.discriminatedUnion("type", [
-                  z24.object({ type: z24.literal("timeout") }),
-                  z24.object({
-                    type: z24.literal("exit"),
-                    exit_code: z24.number()
+          z25.object({
+            type: z25.literal("shell_call_output"),
+            id: z25.string(),
+            call_id: z25.string(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            output: z25.array(
+              z25.object({
+                stdout: z25.string(),
+                stderr: z25.string(),
+                outcome: z25.discriminatedUnion("type", [
+                  z25.object({ type: z25.literal("timeout") }),
+                  z25.object({
+                    type: z25.literal("exit"),
+                    exit_code: z25.number()
                   })
                 ])
               })
             )
           }),
-          z24.object({
-            type: z24.literal("tool_search_call"),
-            id: z24.string(),
-            execution: z24.enum(["server", "client"]),
-            call_id: z24.string().nullable(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            arguments: z24.unknown()
+          z25.object({
+            type: z25.literal("tool_search_call"),
+            id: z25.string(),
+            execution: z25.enum(["server", "client"]),
+            call_id: z25.string().nullable(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            arguments: z25.unknown()
           }),
-          z24.object({
-            type: z24.literal("tool_search_output"),
-            id: z24.string(),
-            execution: z24.enum(["server", "client"]),
-            call_id: z24.string().nullable(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            tools: z24.array(z24.record(z24.string(), jsonValueSchema2.optional()))
+          z25.object({
+            type: z25.literal("tool_search_output"),
+            id: z25.string(),
+            execution: z25.enum(["server", "client"]),
+            call_id: z25.string().nullable(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            tools: z25.array(z25.record(z25.string(), jsonValueSchema2.optional()))
           })
         ])
       }),
-      z24.object({
-        type: z24.literal("response.function_call_arguments.delta"),
-        item_id: z24.string(),
-        output_index: z24.number(),
-        delta: z24.string()
+      z25.object({
+        type: z25.literal("response.function_call_arguments.delta"),
+        item_id: z25.string(),
+        output_index: z25.number(),
+        delta: z25.string()
       }),
-      z24.object({
-        type: z24.literal("response.custom_tool_call_input.delta"),
-        item_id: z24.string(),
-        output_index: z24.number(),
-        delta: z24.string()
+      z25.object({
+        type: z25.literal("response.custom_tool_call_input.delta"),
+        item_id: z25.string(),
+        output_index: z25.number(),
+        delta: z25.string()
       }),
-      z24.object({
-        type: z24.literal("response.image_generation_call.partial_image"),
-        item_id: z24.string(),
-        output_index: z24.number(),
-        partial_image_b64: z24.string()
+      z25.object({
+        type: z25.literal("response.image_generation_call.partial_image"),
+        item_id: z25.string(),
+        output_index: z25.number(),
+        partial_image_b64: z25.string()
       }),
-      z24.object({
-        type: z24.literal("response.code_interpreter_call_code.delta"),
-        item_id: z24.string(),
-        output_index: z24.number(),
-        delta: z24.string()
+      z25.object({
+        type: z25.literal("response.code_interpreter_call_code.delta"),
+        item_id: z25.string(),
+        output_index: z25.number(),
+        delta: z25.string()
       }),
-      z24.object({
-        type: z24.literal("response.code_interpreter_call_code.done"),
-        item_id: z24.string(),
-        output_index: z24.number(),
-        code: z24.string()
+      z25.object({
+        type: z25.literal("response.code_interpreter_call_code.done"),
+        item_id: z25.string(),
+        output_index: z25.number(),
+        code: z25.string()
       }),
-      z24.object({
-        type: z24.literal("response.output_text.annotation.added"),
-        annotation: z24.discriminatedUnion("type", [
-          z24.object({
-            type: z24.literal("url_citation"),
-            start_index: z24.number(),
-            end_index: z24.number(),
-            url: z24.string(),
-            title: z24.string()
+      z25.object({
+        type: z25.literal("response.output_text.annotation.added"),
+        annotation: z25.discriminatedUnion("type", [
+          z25.object({
+            type: z25.literal("url_citation"),
+            start_index: z25.number(),
+            end_index: z25.number(),
+            url: z25.string(),
+            title: z25.string()
           }),
-          z24.object({
-            type: z24.literal("file_citation"),
-            file_id: z24.string(),
-            filename: z24.string(),
-            index: z24.number()
+          z25.object({
+            type: z25.literal("file_citation"),
+            file_id: z25.string(),
+            filename: z25.string(),
+            index: z25.number()
           }),
-          z24.object({
-            type: z24.literal("container_file_citation"),
-            container_id: z24.string(),
-            file_id: z24.string(),
-            filename: z24.string(),
-            start_index: z24.number(),
-            end_index: z24.number()
+          z25.object({
+            type: z25.literal("container_file_citation"),
+            container_id: z25.string(),
+            file_id: z25.string(),
+            filename: z25.string(),
+            start_index: z25.number(),
+            end_index: z25.number()
           }),
-          z24.object({
-            type: z24.literal("file_path"),
-            file_id: z24.string(),
-            index: z24.number()
+          z25.object({
+            type: z25.literal("file_path"),
+            file_id: z25.string(),
+            index: z25.number()
           })
         ])
       }),
-      z24.object({
-        type: z24.literal("response.reasoning_summary_part.added"),
-        item_id: z24.string(),
-        summary_index: z24.number()
+      z25.object({
+        type: z25.literal("response.reasoning_summary_part.added"),
+        item_id: z25.string(),
+        summary_index: z25.number()
       }),
-      z24.object({
-        type: z24.literal("response.reasoning_summary_text.delta"),
-        item_id: z24.string(),
-        summary_index: z24.number(),
-        delta: z24.string()
+      z25.object({
+        type: z25.literal("response.reasoning_summary_text.delta"),
+        item_id: z25.string(),
+        summary_index: z25.number(),
+        delta: z25.string()
       }),
-      z24.object({
-        type: z24.literal("response.reasoning_summary_part.done"),
-        item_id: z24.string(),
-        summary_index: z24.number()
+      z25.object({
+        type: z25.literal("response.reasoning_summary_part.done"),
+        item_id: z25.string(),
+        summary_index: z25.number()
       }),
-      z24.object({
-        type: z24.literal("response.apply_patch_call_operation_diff.delta"),
-        item_id: z24.string(),
-        output_index: z24.number(),
-        delta: z24.string(),
-        obfuscation: z24.string().nullish()
+      z25.object({
+        type: z25.literal("response.apply_patch_call_operation_diff.delta"),
+        item_id: z25.string(),
+        output_index: z25.number(),
+        delta: z25.string(),
+        obfuscation: z25.string().nullish()
       }),
-      z24.object({
-        type: z24.literal("response.apply_patch_call_operation_diff.done"),
-        item_id: z24.string(),
-        output_index: z24.number(),
-        diff: z24.string()
+      z25.object({
+        type: z25.literal("response.apply_patch_call_operation_diff.done"),
+        item_id: z25.string(),
+        output_index: z25.number(),
+        diff: z25.string()
       }),
       openaiResponsesNestedErrorChunkSchema,
       openaiResponsesErrorChunkSchema,
-      z24.object({ type: z24.string() }).loose().transform((value) => ({
+      z25.object({ type: z25.string() }).loose().transform((value) => ({
         type: "unknown_chunk",
         message: value.type
       }))
@@ -4984,319 +5214,315 @@ var openaiResponsesChunkSchema = lazySchema22(
     ])
   )
 );
-var openaiResponsesResponseSchema = lazySchema22(
-  () => zodSchema22(
-    z24.object({
-      id: z24.string().optional(),
-      created_at: z24.number().optional(),
-      error: z24.object({
-        message: z24.string(),
-        type: z24.string(),
-        param: z24.string().nullish(),
-        code: z24.string()
+var openaiResponsesResponseSchema = lazySchema23(
+  () => zodSchema23(
+    z25.object({
+      id: z25.string().optional(),
+      created_at: z25.number().optional(),
+      error: z25.object({
+        message: z25.string(),
+        type: z25.string(),
+        param: z25.string().nullish(),
+        code: z25.string()
       }).nullish(),
-      model: z24.string().optional(),
-      output: z24.array(
-        z24.discriminatedUnion("type", [
-          z24.object({
-            type: z24.literal("message"),
-            role: z24.literal("assistant"),
-            id: z24.string(),
-            phase: z24.enum(["commentary", "final_answer"]).nullish(),
-            content: z24.array(
-              z24.object({
-                type: z24.literal("output_text"),
-                text: z24.string(),
-                logprobs: z24.array(
-                  z24.object({
-                    token: z24.string(),
-                    logprob: z24.number(),
-                    top_logprobs: z24.array(
-                      z24.object({
-                        token: z24.string(),
-                        logprob: z24.number()
+      model: z25.string().optional(),
+      output: z25.array(
+        z25.discriminatedUnion("type", [
+          z25.object({
+            type: z25.literal("message"),
+            role: z25.literal("assistant"),
+            id: z25.string(),
+            phase: z25.enum(["commentary", "final_answer"]).nullish(),
+            content: z25.array(
+              z25.object({
+                type: z25.literal("output_text"),
+                text: z25.string(),
+                logprobs: z25.array(
+                  z25.object({
+                    token: z25.string(),
+                    logprob: z25.number(),
+                    top_logprobs: z25.array(
+                      z25.object({
+                        token: z25.string(),
+                        logprob: z25.number()
                       })
                     )
                   })
                 ).nullish(),
-                annotations: z24.array(
-                  z24.discriminatedUnion("type", [
-                    z24.object({
-                      type: z24.literal("url_citation"),
-                      start_index: z24.number(),
-                      end_index: z24.number(),
-                      url: z24.string(),
-                      title: z24.string()
+                annotations: z25.array(
+                  z25.discriminatedUnion("type", [
+                    z25.object({
+                      type: z25.literal("url_citation"),
+                      start_index: z25.number(),
+                      end_index: z25.number(),
+                      url: z25.string(),
+                      title: z25.string()
                     }),
-                    z24.object({
-                      type: z24.literal("file_citation"),
-                      file_id: z24.string(),
-                      filename: z24.string(),
-                      index: z24.number()
+                    z25.object({
+                      type: z25.literal("file_citation"),
+                      file_id: z25.string(),
+                      filename: z25.string(),
+                      index: z25.number()
                     }),
-                    z24.object({
-                      type: z24.literal("container_file_citation"),
-                      container_id: z24.string(),
-                      file_id: z24.string(),
-                      filename: z24.string(),
-                      start_index: z24.number(),
-                      end_index: z24.number()
+                    z25.object({
+                      type: z25.literal("container_file_citation"),
+                      container_id: z25.string(),
+                      file_id: z25.string(),
+                      filename: z25.string(),
+                      start_index: z25.number(),
+                      end_index: z25.number()
                     }),
-                    z24.object({
-                      type: z24.literal("file_path"),
-                      file_id: z24.string(),
-                      index: z24.number()
+                    z25.object({
+                      type: z25.literal("file_path"),
+                      file_id: z25.string(),
+                      index: z25.number()
                     })
                   ])
                 )
               })
             )
           }),
-          z24.object({
-            type: z24.literal("web_search_call"),
-            id: z24.string(),
-            status: z24.string(),
-            action: z24.discriminatedUnion("type", [
-              z24.object({
-                type: z24.literal("search"),
-                query: z24.string().nullish(),
-                queries: z24.array(z24.string()).nullish(),
-                sources: z24.array(
-                  z24.discriminatedUnion("type", [
-                    z24.object({ type: z24.literal("url"), url: z24.string() }),
-                    z24.object({
-                      type: z24.literal("api"),
-                      name: z24.string()
+          z25.object({
+            type: z25.literal("web_search_call"),
+            id: z25.string(),
+            status: z25.string(),
+            action: z25.discriminatedUnion("type", [
+              z25.object({
+                type: z25.literal("search"),
+                query: z25.string().nullish(),
+                queries: z25.array(z25.string()).nullish(),
+                sources: z25.array(
+                  z25.discriminatedUnion("type", [
+                    z25.object({ type: z25.literal("url"), url: z25.string() }),
+                    z25.object({
+                      type: z25.literal("api"),
+                      name: z25.string()
                     })
                   ])
                 ).nullish()
               }),
-              z24.object({
-                type: z24.literal("open_page"),
-                url: z24.string().nullish()
+              z25.object({
+                type: z25.literal("open_page"),
+                url: z25.string().nullish()
               }),
-              z24.object({
-                type: z24.literal("find_in_page"),
-                url: z24.string().nullish(),
-                pattern: z24.string().nullish()
+              z25.object({
+                type: z25.literal("find_in_page"),
+                url: z25.string().nullish(),
+                pattern: z25.string().nullish()
               })
             ]).nullish()
           }),
-          z24.object({
-            type: z24.literal("file_search_call"),
-            id: z24.string(),
-            queries: z24.array(z24.string()),
-            results: z24.array(
-              z24.object({
-                attributes: z24.record(
-                  z24.string(),
-                  z24.union([z24.string(), z24.number(), z24.boolean()])
+          z25.object({
+            type: z25.literal("file_search_call"),
+            id: z25.string(),
+            queries: z25.array(z25.string()),
+            results: z25.array(
+              z25.object({
+                attributes: z25.record(
+                  z25.string(),
+                  z25.union([z25.string(), z25.number(), z25.boolean()])
                 ),
-                file_id: z24.string(),
-                filename: z24.string(),
-                score: z24.number(),
-                text: z24.string()
+                file_id: z25.string(),
+                filename: z25.string(),
+                score: z25.number(),
+                text: z25.string()
               })
             ).nullish()
           }),
-          z24.object({
-            type: z24.literal("code_interpreter_call"),
-            id: z24.string(),
-            code: z24.string().nullable(),
-            container_id: z24.string(),
-            outputs: z24.array(
-              z24.discriminatedUnion("type", [
-                z24.object({ type: z24.literal("logs"), logs: z24.string() }),
-                z24.object({ type: z24.literal("image"), url: z24.string() })
+          z25.object({
+            type: z25.literal("code_interpreter_call"),
+            id: z25.string(),
+            code: z25.string().nullable(),
+            container_id: z25.string(),
+            outputs: z25.array(
+              z25.discriminatedUnion("type", [
+                z25.object({ type: z25.literal("logs"), logs: z25.string() }),
+                z25.object({ type: z25.literal("image"), url: z25.string() })
               ])
             ).nullable()
           }),
-          z24.object({
-            type: z24.literal("image_generation_call"),
-            id: z24.string(),
-            result: z24.string()
+          z25.object({
+            type: z25.literal("image_generation_call"),
+            id: z25.string(),
+            result: z25.string()
           }),
-          z24.object({
-            type: z24.literal("local_shell_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            action: z24.object({
-              type: z24.literal("exec"),
-              command: z24.array(z24.string()),
-              timeout_ms: z24.number().optional(),
-              user: z24.string().optional(),
-              working_directory: z24.string().optional(),
-              env: z24.record(z24.string(), z24.string()).optional()
+          z25.object({
+            type: z25.literal("local_shell_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            action: z25.object({
+              type: z25.literal("exec"),
+              command: z25.array(z25.string()),
+              timeout_ms: z25.number().optional(),
+              user: z25.string().optional(),
+              working_directory: z25.string().optional(),
+              env: z25.record(z25.string(), z25.string()).optional()
             })
           }),
-          z24.object({
-            type: z24.literal("function_call"),
-            call_id: z24.string(),
-            name: z24.string(),
-            arguments: z24.string(),
-            id: z24.string(),
-            namespace: z24.string().nullish()
+          z25.object({
+            type: z25.literal("function_call"),
+            call_id: z25.string(),
+            name: z25.string(),
+            arguments: z25.string(),
+            id: z25.string(),
+            namespace: z25.string().nullish()
           }),
-          z24.object({
-            type: z24.literal("custom_tool_call"),
-            call_id: z24.string(),
-            name: z24.string(),
-            input: z24.string(),
-            id: z24.string()
+          z25.object({
+            type: z25.literal("custom_tool_call"),
+            call_id: z25.string(),
+            name: z25.string(),
+            input: z25.string(),
+            id: z25.string()
           }),
-          z24.object({
-            type: z24.literal("computer_call"),
-            id: z24.string(),
-            status: z24.string().optional()
-          }),
-          z24.object({
-            type: z24.literal("reasoning"),
-            id: z24.string(),
-            encrypted_content: z24.string().nullish(),
-            summary: z24.array(
-              z24.object({
-                type: z24.literal("summary_text"),
-                text: z24.string()
+          openaiResponsesComputerCallSchema,
+          z25.object({
+            type: z25.literal("reasoning"),
+            id: z25.string(),
+            encrypted_content: z25.string().nullish(),
+            summary: z25.array(
+              z25.object({
+                type: z25.literal("summary_text"),
+                text: z25.string()
               })
             )
           }),
-          z24.object({
-            type: z24.literal("mcp_call"),
-            id: z24.string(),
-            status: z24.string(),
-            arguments: z24.string(),
-            name: z24.string(),
-            server_label: z24.string(),
-            output: z24.string().nullish(),
-            error: z24.union([
-              z24.string(),
-              z24.object({
-                type: z24.string().optional(),
-                code: z24.union([z24.number(), z24.string()]).optional(),
-                message: z24.string().optional()
+          z25.object({
+            type: z25.literal("mcp_call"),
+            id: z25.string(),
+            status: z25.string(),
+            arguments: z25.string(),
+            name: z25.string(),
+            server_label: z25.string(),
+            output: z25.string().nullish(),
+            error: z25.union([
+              z25.string(),
+              z25.object({
+                type: z25.string().optional(),
+                code: z25.union([z25.number(), z25.string()]).optional(),
+                message: z25.string().optional()
               }).loose()
             ]).nullish(),
-            approval_request_id: z24.string().nullish()
+            approval_request_id: z25.string().nullish()
           }),
-          z24.object({
-            type: z24.literal("mcp_list_tools"),
-            id: z24.string(),
-            server_label: z24.string(),
-            tools: z24.array(
-              z24.object({
-                name: z24.string(),
-                description: z24.string().optional(),
-                input_schema: z24.any(),
-                annotations: z24.record(z24.string(), z24.unknown()).optional()
+          z25.object({
+            type: z25.literal("mcp_list_tools"),
+            id: z25.string(),
+            server_label: z25.string(),
+            tools: z25.array(
+              z25.object({
+                name: z25.string(),
+                description: z25.string().optional(),
+                input_schema: z25.any(),
+                annotations: z25.record(z25.string(), z25.unknown()).optional()
               })
             ),
-            error: z24.union([
-              z24.string(),
-              z24.object({
-                type: z24.string().optional(),
-                code: z24.union([z24.number(), z24.string()]).optional(),
-                message: z24.string().optional()
+            error: z25.union([
+              z25.string(),
+              z25.object({
+                type: z25.string().optional(),
+                code: z25.union([z25.number(), z25.string()]).optional(),
+                message: z25.string().optional()
               }).loose()
             ]).optional()
           }),
-          z24.object({
-            type: z24.literal("mcp_approval_request"),
-            id: z24.string(),
-            server_label: z24.string(),
-            name: z24.string(),
-            arguments: z24.string(),
-            approval_request_id: z24.string().optional()
+          z25.object({
+            type: z25.literal("mcp_approval_request"),
+            id: z25.string(),
+            server_label: z25.string(),
+            name: z25.string(),
+            arguments: z25.string(),
+            approval_request_id: z25.string().optional()
           }),
-          z24.object({
-            type: z24.literal("apply_patch_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            status: z24.enum(["in_progress", "completed"]),
-            operation: z24.discriminatedUnion("type", [
-              z24.object({
-                type: z24.literal("create_file"),
-                path: z24.string(),
-                diff: z24.string()
+          z25.object({
+            type: z25.literal("apply_patch_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            status: z25.enum(["in_progress", "completed"]),
+            operation: z25.discriminatedUnion("type", [
+              z25.object({
+                type: z25.literal("create_file"),
+                path: z25.string(),
+                diff: z25.string()
               }),
-              z24.object({
-                type: z24.literal("delete_file"),
-                path: z24.string()
+              z25.object({
+                type: z25.literal("delete_file"),
+                path: z25.string()
               }),
-              z24.object({
-                type: z24.literal("update_file"),
-                path: z24.string(),
-                diff: z24.string()
+              z25.object({
+                type: z25.literal("update_file"),
+                path: z25.string(),
+                diff: z25.string()
               })
             ])
           }),
-          z24.object({
-            type: z24.literal("shell_call"),
-            id: z24.string(),
-            call_id: z24.string(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            action: z24.object({
-              commands: z24.array(z24.string())
+          z25.object({
+            type: z25.literal("shell_call"),
+            id: z25.string(),
+            call_id: z25.string(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            action: z25.object({
+              commands: z25.array(z25.string())
             })
           }),
-          z24.object({
-            type: z24.literal("compaction"),
-            id: z24.string(),
-            encrypted_content: z24.string()
+          z25.object({
+            type: z25.literal("compaction"),
+            id: z25.string(),
+            encrypted_content: z25.string()
           }),
-          z24.object({
-            type: z24.literal("shell_call_output"),
-            id: z24.string(),
-            call_id: z24.string(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            output: z24.array(
-              z24.object({
-                stdout: z24.string(),
-                stderr: z24.string(),
-                outcome: z24.discriminatedUnion("type", [
-                  z24.object({ type: z24.literal("timeout") }),
-                  z24.object({
-                    type: z24.literal("exit"),
-                    exit_code: z24.number()
+          z25.object({
+            type: z25.literal("shell_call_output"),
+            id: z25.string(),
+            call_id: z25.string(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            output: z25.array(
+              z25.object({
+                stdout: z25.string(),
+                stderr: z25.string(),
+                outcome: z25.discriminatedUnion("type", [
+                  z25.object({ type: z25.literal("timeout") }),
+                  z25.object({
+                    type: z25.literal("exit"),
+                    exit_code: z25.number()
                   })
                 ])
               })
             )
           }),
-          z24.object({
-            type: z24.literal("tool_search_call"),
-            id: z24.string(),
-            execution: z24.enum(["server", "client"]),
-            call_id: z24.string().nullable(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            arguments: z24.unknown()
+          z25.object({
+            type: z25.literal("tool_search_call"),
+            id: z25.string(),
+            execution: z25.enum(["server", "client"]),
+            call_id: z25.string().nullable(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            arguments: z25.unknown()
           }),
-          z24.object({
-            type: z24.literal("tool_search_output"),
-            id: z24.string(),
-            execution: z24.enum(["server", "client"]),
-            call_id: z24.string().nullable(),
-            status: z24.enum(["in_progress", "completed", "incomplete"]),
-            tools: z24.array(z24.record(z24.string(), jsonValueSchema2.optional()))
+          z25.object({
+            type: z25.literal("tool_search_output"),
+            id: z25.string(),
+            execution: z25.enum(["server", "client"]),
+            call_id: z25.string().nullable(),
+            status: z25.enum(["in_progress", "completed", "incomplete"]),
+            tools: z25.array(z25.record(z25.string(), jsonValueSchema2.optional()))
           })
         ])
       ).optional(),
-      service_tier: z24.string().nullish(),
-      reasoning: z24.object({
-        context: z24.string().nullish()
+      service_tier: z25.string().nullish(),
+      reasoning: z25.object({
+        context: z25.string().nullish()
       }).nullish(),
-      incomplete_details: z24.object({ reason: z24.string() }).nullish(),
-      usage: z24.object({
-        input_tokens: z24.number(),
-        input_tokens_details: z24.object({
-          cached_tokens: z24.number().nullish(),
-          cache_write_tokens: z24.number().nullish(),
-          orchestration_input_tokens: z24.number().nullish(),
-          orchestration_input_cached_tokens: z24.number().nullish()
+      incomplete_details: z25.object({ reason: z25.string() }).nullish(),
+      usage: z25.object({
+        input_tokens: z25.number(),
+        input_tokens_details: z25.object({
+          cached_tokens: z25.number().nullish(),
+          cache_write_tokens: z25.number().nullish(),
+          orchestration_input_tokens: z25.number().nullish(),
+          orchestration_input_cached_tokens: z25.number().nullish()
         }).nullish(),
-        output_tokens: z24.number(),
-        output_tokens_details: z24.object({
-          reasoning_tokens: z24.number().nullish(),
-          orchestration_output_tokens: z24.number().nullish()
+        output_tokens: z25.number(),
+        output_tokens_details: z25.object({
+          reasoning_tokens: z25.number().nullish(),
+          orchestration_output_tokens: z25.number().nullish()
         }).nullish()
       }).optional()
     })
@@ -5305,10 +5531,10 @@ var openaiResponsesResponseSchema = lazySchema22(
 
 // src/responses/openai-responses-language-model-options.ts
 import {
-  lazySchema as lazySchema23,
-  zodSchema as zodSchema23
+  lazySchema as lazySchema24,
+  zodSchema as zodSchema24
 } from "@ai-sdk/provider-utils";
-import { z as z25 } from "zod/v4";
+import { z as z26 } from "zod/v4";
 var TOP_LOGPROBS_MAX = 20;
 var openaiResponsesReasoningModelIds = [
   "o1",
@@ -5379,9 +5605,9 @@ var openaiResponsesModelIds = [
   "gpt-5-chat-latest",
   ...openaiResponsesReasoningModelIds
 ];
-var openaiLanguageModelResponsesOptionsSchema = lazySchema23(
-  () => zodSchema23(
-    z25.object({
+var openaiLanguageModelResponsesOptionsSchema = lazySchema24(
+  () => zodSchema24(
+    z26.object({
       /**
        * The ID of the OpenAI Conversation to continue.
        * You must create a conversation first via the OpenAI API.
@@ -5389,13 +5615,13 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema23(
        * Defaults to `undefined`.
        * @see https://platform.openai.com/docs/api-reference/conversations/create
        */
-      conversation: z25.string().nullish(),
+      conversation: z26.string().nullish(),
       /**
        * The set of extra fields to include in the response (advanced, usually not needed).
        * Example values: 'reasoning.encrypted_content', 'file_search_call.results', 'web_search_call.results', 'message.output_text.logprobs'.
        */
-      include: z25.array(
-        z25.enum([
+      include: z26.array(
+        z26.enum([
           "reasoning.encrypted_content",
           // handled internally by default, only needed for unknown reasoning models
           "file_search_call.results",
@@ -5408,7 +5634,7 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema23(
        * They can be used to change the system or developer message when continuing a conversation using the `previousResponseId` option.
        * Defaults to `undefined`.
        */
-      instructions: z25.string().nullish(),
+      instructions: z26.string().nullish(),
       /**
        * Return the log probabilities of the tokens. Including logprobs will increase
        * the response size and can slow down response times. However, it can
@@ -5423,38 +5649,38 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema23(
        * @see https://platform.openai.com/docs/api-reference/responses/create
        * @see https://cookbook.openai.com/examples/using_logprobs
        */
-      logprobs: z25.union([z25.boolean(), z25.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
+      logprobs: z26.union([z26.boolean(), z26.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
       /**
        * The maximum number of total calls to built-in tools that can be processed in a response.
        * This maximum number applies across all built-in tool calls, not per individual tool.
        * Any further attempts to call a tool by the model will be ignored.
        */
-      maxToolCalls: z25.number().nullish(),
+      maxToolCalls: z26.number().nullish(),
       /**
        * Additional metadata to store with the generation.
        */
-      metadata: z25.any().nullish(),
+      metadata: z26.any().nullish(),
       /**
        * Whether to use parallel tool calls. Defaults to `true`.
        */
-      parallelToolCalls: z25.boolean().nullish(),
+      parallelToolCalls: z26.boolean().nullish(),
       /**
        * The ID of the previous response. You can use it to continue a conversation.
        * Defaults to `undefined`.
        */
-      previousResponseId: z25.string().nullish(),
+      previousResponseId: z26.string().nullish(),
       /**
        * Sets a cache key to tie this prompt to cached prefixes for better caching performance.
        */
-      promptCacheKey: z25.string().nullish(),
+      promptCacheKey: z26.string().nullish(),
       /**
        * 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.
        */
-      promptCacheOptions: z25.object({
-        mode: z25.enum(["implicit", "explicit"]).optional(),
-        ttl: z25.literal("30m").optional()
+      promptCacheOptions: z26.object({
+        mode: z26.enum(["implicit", "explicit"]).optional(),
+        ttl: z26.literal("30m").optional()
       }).optional(),
       /**
        * The retention policy for the prompt cache.
@@ -5466,35 +5692,35 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema23(
        *
        * @default 'in_memory'
        */
-      promptCacheRetention: z25.enum(["in_memory", "24h"]).nullish(),
+      promptCacheRetention: z26.enum(["in_memory", "24h"]).nullish(),
       /**
        * Reasoning effort for reasoning models. Defaults to `medium`. If you use
        * `providerOptions` to set the `reasoningEffort` option, this model setting will be ignored.
        * GPT-5.6 supports 'none' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'.
        * Supported values vary by model.
        */
-      reasoningEffort: z25.string().nullish(),
+      reasoningEffort: z26.string().nullish(),
       /**
        * Controls how much model work GPT-5.6 performs before returning a final answer.
        * `standard` is the default. `pro` increases quality, latency, and token usage.
        */
-      reasoningMode: z25.enum(["standard", "pro"]).optional(),
+      reasoningMode: z26.enum(["standard", "pro"]).optional(),
       /**
        * Controls which available reasoning items GPT-5.6 can use.
        * `auto` uses the model default, `current_turn` excludes reasoning from earlier
        * turns, and `all_turns` makes compatible earlier reasoning available.
        */
-      reasoningContext: z25.enum(["auto", "current_turn", "all_turns"]).optional(),
+      reasoningContext: z26.enum(["auto", "current_turn", "all_turns"]).optional(),
       /**
        * Controls reasoning summary output from the model.
        * Set to "auto" to automatically receive the richest level available,
        * or "detailed" for comprehensive summaries.
        */
-      reasoningSummary: z25.string().nullish(),
+      reasoningSummary: z26.string().nullish(),
       /**
        * The identifier for safety monitoring and tracking.
        */
-      safetyIdentifier: z25.string().nullish(),
+      safetyIdentifier: z26.string().nullish(),
       /**
        * Service tier for the request.
        * Set to 'flex' for 50% cheaper processing at the cost of increased latency (available for o3, o4-mini, and gpt-5 models).
@@ -5502,11 +5728,11 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema23(
        *
        * Defaults to 'auto'.
        */
-      serviceTier: z25.enum(["auto", "flex", "priority", "default"]).nullish(),
+      serviceTier: z26.enum(["auto", "flex", "priority", "default"]).nullish(),
       /**
        * Whether to store the generation. Defaults to `true`.
        */
-      store: z25.boolean().nullish(),
+      store: z26.boolean().nullish(),
       /**
        * Whether to pass through non-image file types as generic input files.
        *
@@ -5514,30 +5740,30 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema23(
        * Enable this when the target OpenAI Responses model supports additional
        * file media types, such as text/csv.
        */
-      passThroughUnsupportedFiles: z25.boolean().optional(),
+      passThroughUnsupportedFiles: z26.boolean().optional(),
       /**
        * Whether to use strict JSON schema validation.
        * Defaults to `true`.
        */
-      strictJsonSchema: z25.boolean().nullish(),
+      strictJsonSchema: z26.boolean().nullish(),
       /**
        * Controls the verbosity of the model's responses. Lower values ('low') will result
        * in more concise responses, while higher values ('high') will result in more verbose responses.
        * Valid values: 'low', 'medium', 'high'.
        */
-      textVerbosity: z25.enum(["low", "medium", "high"]).nullish(),
+      textVerbosity: z26.enum(["low", "medium", "high"]).nullish(),
       /**
        * Controls output truncation. 'auto' (default) performs truncation automatically;
        * 'disabled' turns truncation off.
        */
-      truncation: z25.enum(["auto", "disabled"]).nullish(),
+      truncation: z26.enum(["auto", "disabled"]).nullish(),
       /**
        * A unique identifier representing your end-user, which can help OpenAI to
        * monitor and detect abuse.
        * Defaults to `undefined`.
        * @see https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids
        */
-      user: z25.string().nullish(),
+      user: z26.string().nullish(),
       /**
        * Override the system message mode for this model.
        * - 'system': Use the 'system' role for system messages (default for most models)
@@ -5546,7 +5772,7 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema23(
        *
        * If not specified, the mode is automatically determined based on the model.
        */
-      systemMessageMode: z25.enum(["system", "developer", "remove"]).optional(),
+      systemMessageMode: z26.enum(["system", "developer", "remove"]).optional(),
       /**
        * Force treating this model as a reasoning model.
        *
@@ -5556,14 +5782,14 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema23(
        * When enabled, the SDK applies reasoning-model parameter compatibility rules
        * and defaults `systemMessageMode` to `developer` unless overridden.
        */
-      forceReasoning: z25.boolean().optional(),
+      forceReasoning: z26.boolean().optional(),
       /**
        * Enable server-side context management (compaction).
        */
-      contextManagement: z25.array(
-        z25.object({
-          type: z25.literal("compaction"),
-          compactThreshold: z25.number()
+      contextManagement: z26.array(
+        z26.object({
+          type: z26.literal("compaction"),
+          compactThreshold: z26.number()
         })
       ).nullish(),
       /**
@@ -5576,9 +5802,9 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema23(
        *
        * @see https://developers.openai.com/api/reference/resources/responses/methods/create#(resource)%20responses%20%3E%20(model)%20tool_choice_allowed%20%3E%20(schema)
        */
-      allowedTools: z25.object({
-        toolNames: z25.array(z25.string()).min(1),
-        mode: z25.enum(["auto", "required"]).optional()
+      allowedTools: z26.object({
+        toolNames: z26.array(z26.string()).min(1),
+        mode: z26.enum(["auto", "required"]).optional()
       }).optional()
     })
   )
@@ -5683,6 +5909,12 @@ async function prepareResponsesTools({
             });
             break;
           }
+          case "openai.computer": {
+            openaiTools2.push({
+              type: "computer"
+            });
+            break;
+          }
           case "openai.web_search_preview": {
             const args = await validateTypes2({
               value: tool.args,
@@ -5837,7 +6069,7 @@ async function prepareResponsesTools({
       const resolvedToolName = (_c = toolNameMapping == null ? void 0 : toolNameMapping.toProviderToolName(toolChoice.toolName)) != null ? _c : toolChoice.toolName;
       return {
         tools: openaiTools2,
-        toolChoice: resolvedToolName === "code_interpreter" || resolvedToolName === "file_search" || resolvedToolName === "image_generation" || resolvedToolName === "web_search_preview" || resolvedToolName === "web_search" || resolvedToolName === "mcp" || resolvedToolName === "apply_patch" ? { type: resolvedToolName } : resolvedCustomProviderToolNames.has(resolvedToolName) ? { type: "custom", name: resolvedToolName } : { type: "function", name: resolvedToolName },
+        toolChoice: resolvedToolName === "code_interpreter" || resolvedToolName === "file_search" || resolvedToolName === "image_generation" || resolvedToolName === "web_search_preview" || resolvedToolName === "web_search" || resolvedToolName === "mcp" || resolvedToolName === "apply_patch" || resolvedToolName === "computer" ? { type: resolvedToolName } : resolvedCustomProviderToolNames.has(resolvedToolName) ? { type: "custom", name: resolvedToolName } : { type: "function", name: resolvedToolName },
         toolWarnings
       };
     }
@@ -5932,6 +6164,74 @@ function extractApprovalRequestIdToToolCallIdMapping(prompt) {
   }
   return mapping;
 }
+function mapComputerAction(action) {
+  switch (action.type) {
+    case "click":
+      return {
+        type: "click",
+        button: action.button,
+        x: action.x,
+        y: action.y,
+        ...action.keys != null && { keys: action.keys }
+      };
+    case "double_click":
+      return {
+        type: "double_click",
+        x: action.x,
+        y: action.y,
+        ...action.keys != null && { keys: action.keys }
+      };
+    case "drag":
+      return {
+        type: "drag",
+        path: action.path,
+        ...action.keys != null && { keys: action.keys }
+      };
+    case "keypress":
+      return action;
+    case "move":
+      return {
+        type: "move",
+        x: action.x,
+        y: action.y,
+        ...action.keys != null && { keys: action.keys }
+      };
+    case "screenshot":
+      return action;
+    case "scroll":
+      return {
+        type: "scroll",
+        x: action.x,
+        y: action.y,
+        scrollX: action.scroll_x,
+        scrollY: action.scroll_y,
+        ...action.keys != null && { keys: action.keys }
+      };
+    case "type":
+      return action;
+    case "wait":
+      return action;
+  }
+}
+function mapComputerCallInput({
+  action,
+  actions,
+  pending_safety_checks,
+  status
+}) {
+  var _a;
+  return {
+    actions: (actions != null ? actions : action != null ? [action] : []).map(
+      mapComputerAction
+    ),
+    pendingSafetyChecks: (_a = pending_safety_checks == null ? void 0 : pending_safety_checks.map((safetyCheck) => ({
+      id: safetyCheck.id,
+      ...safetyCheck.code != null && { code: safetyCheck.code },
+      ...safetyCheck.message != null && { message: safetyCheck.message }
+    }))) != null ? _a : [],
+    status
+  };
+}
 var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
@@ -6015,6 +6315,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
       tools,
       providerToolNames: {
         "openai.code_interpreter": "code_interpreter",
+        "openai.computer": "computer",
         "openai.file_search": "file_search",
         "openai.image_generation": "image_generation",
         "openai.local_shell": "local_shell",
@@ -6051,6 +6352,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
       hasLocalShellTool: hasOpenAITool("openai.local_shell"),
       hasShellTool: hasOpenAITool("openai.shell"),
       hasApplyPatchTool: hasOpenAITool("openai.apply_patch"),
+      hasComputerTool: hasOpenAITool("openai.computer"),
       customProviderToolNames: customProviderToolNames.size > 0 ? customProviderToolNames : void 0
     });
     warnings.push(...inputWarnings);
@@ -6593,20 +6895,36 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
           break;
         }
         case "computer_call": {
+          if (part.call_id == null) {
+            content.push({
+              type: "tool-call",
+              toolCallId: part.id,
+              toolName: toolNameMapping.toCustomToolName("computer_use"),
+              input: "",
+              providerExecuted: true
+            });
+            content.push({
+              type: "tool-result",
+              toolCallId: part.id,
+              toolName: toolNameMapping.toCustomToolName("computer_use"),
+              result: {
+                type: "computer_use_tool_result",
+                status: part.status
+              }
+            });
+            break;
+          }
+          hasFunctionCall = true;
+          const toolName = toolNameMapping.toCustomToolName("computer");
           content.push({
             type: "tool-call",
-            toolCallId: part.id,
-            toolName: toolNameMapping.toCustomToolName("computer_use"),
-            input: "",
-            providerExecuted: true
-          });
-          content.push({
-            type: "tool-result",
-            toolCallId: part.id,
-            toolName: toolNameMapping.toCustomToolName("computer_use"),
-            result: {
-              type: "computer_use_tool_result",
-              status: part.status || "completed"
+            toolCallId: part.call_id,
+            toolName,
+            input: JSON.stringify(mapComputerCallInput(part)),
+            providerMetadata: {
+              [providerOptionsName]: {
+                itemId: part.id
+              }
             }
           });
           break;
@@ -6784,7 +7102,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N;
+            var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
@@ -6854,15 +7172,15 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                   providerExecuted: true
                 });
               } else if (value.item.type === "computer_call") {
+                const toolCallId = (_a2 = value.item.call_id) != null ? _a2 : value.item.id;
                 ongoingToolCalls[value.output_index] = {
-                  toolName: toolNameMapping.toCustomToolName("computer_use"),
-                  toolCallId: value.item.id
+                  toolName: toolNameMapping.toCustomToolName("computer"),
+                  toolCallId
                 };
                 controller.enqueue({
                   type: "tool-input-start",
-                  id: value.item.id,
-                  toolName: toolNameMapping.toCustomToolName("computer_use"),
-                  providerExecuted: true
+                  id: toolCallId,
+                  toolName: toolNameMapping.toCustomToolName("computer")
                 });
               } else if (value.item.type === "code_interpreter_call") {
                 ongoingToolCalls[value.output_index] = {
@@ -6906,7 +7224,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 ongoingToolCalls[value.output_index] = {
                   toolName,
                   toolCallId,
-                  toolSearchExecution: (_a2 = value.item.execution) != null ? _a2 : "server"
+                  toolSearchExecution: (_b2 = value.item.execution) != null ? _b2 : "server"
                 };
                 if (isHosted) {
                   controller.enqueue({
@@ -6963,7 +7281,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
               } else if (value.item.type === "shell_call_output") {
               } else if (value.item.type === "message") {
                 ongoingAnnotations.splice(0, ongoingAnnotations.length);
-                activeMessagePhase = (_b2 = value.item.phase) != null ? _b2 : void 0;
+                activeMessagePhase = (_c = value.item.phase) != null ? _c : void 0;
                 controller.enqueue({
                   type: "text-start",
                   id: value.item.id,
@@ -6987,14 +7305,14 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                   providerMetadata: {
                     [providerOptionsName]: {
                       itemId: value.item.id,
-                      reasoningEncryptedContent: (_c = value.item.encrypted_content) != null ? _c : null
+                      reasoningEncryptedContent: (_d = value.item.encrypted_content) != null ? _d : null
                     }
                   }
                 });
               }
             } else if (isResponseOutputItemDoneChunk(value)) {
               if (value.item.type === "message") {
-                const phase = (_d = value.item.phase) != null ? _d : activeMessagePhase;
+                const phase = (_e = value.item.phase) != null ? _e : activeMessagePhase;
                 activeMessagePhase = void 0;
                 controller.enqueue({
                   type: "text-end",
@@ -7070,24 +7388,50 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 });
               } else if (value.item.type === "computer_call") {
                 ongoingToolCalls[value.output_index] = void 0;
+                if (value.item.call_id == null) {
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: value.item.id
+                  });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: value.item.id,
+                    toolName: toolNameMapping.toCustomToolName("computer_use"),
+                    input: "",
+                    providerExecuted: true
+                  });
+                  controller.enqueue({
+                    type: "tool-result",
+                    toolCallId: value.item.id,
+                    toolName: toolNameMapping.toCustomToolName("computer_use"),
+                    result: {
+                      type: "computer_use_tool_result",
+                      status: value.item.status
+                    }
+                  });
+                  return;
+                }
+                hasFunctionCall = true;
+                const toolName = toolNameMapping.toCustomToolName("computer");
+                const input = JSON.stringify(mapComputerCallInput(value.item));
                 controller.enqueue({
-                  type: "tool-input-end",
-                  id: value.item.id
+                  type: "tool-input-delta",
+                  id: value.item.call_id,
+                  delta: input
                 });
                 controller.enqueue({
-                  type: "tool-call",
-                  toolCallId: value.item.id,
-                  toolName: toolNameMapping.toCustomToolName("computer_use"),
-                  input: "",
-                  providerExecuted: true
+                  type: "tool-input-end",
+                  id: value.item.call_id
                 });
                 controller.enqueue({
-                  type: "tool-result",
-                  toolCallId: value.item.id,
-                  toolName: toolNameMapping.toCustomToolName("computer_use"),
-                  result: {
-                    type: "computer_use_tool_result",
-                    status: value.item.status || "completed"
+                  type: "tool-call",
+                  toolCallId: value.item.call_id,
+                  toolName,
+                  input,
+                  providerMetadata: {
+                    [providerOptionsName]: {
+                      itemId: value.item.id
+                    }
                   }
                 });
               } else if (value.item.type === "file_search_call") {
@@ -7098,13 +7442,13 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                   toolName: toolNameMapping.toCustomToolName("file_search"),
                   result: {
                     queries: value.item.queries,
-                    results: (_f = (_e = value.item.results) == null ? void 0 : _e.map((result2) => ({
+                    results: (_g = (_f = value.item.results) == null ? void 0 : _f.map((result2) => ({
                       attributes: result2.attributes,
                       fileId: result2.file_id,
                       filename: result2.filename,
                       score: result2.score,
                       text: result2.text
-                    }))) != null ? _f : null
+                    }))) != null ? _g : null
                   }
                 });
               } else if (value.item.type === "code_interpreter_call") {
@@ -7130,7 +7474,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 const toolCall = ongoingToolCalls[value.output_index];
                 const isHosted = value.item.execution === "server";
                 if (toolCall != null) {
-                  const toolCallId = isHosted ? toolCall.toolCallId : (_g = value.item.call_id) != null ? _g : value.item.id;
+                  const toolCallId = isHosted ? toolCall.toolCallId : (_h = value.item.call_id) != null ? _h : value.item.id;
                   if (isHosted) {
                     hostedToolSearchCallIds.push(toolCallId);
                   } else {
@@ -7162,7 +7506,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 }
                 ongoingToolCalls[value.output_index] = void 0;
               } else if (value.item.type === "tool_search_output") {
-                const toolCallId = (_i = (_h = value.item.call_id) != null ? _h : hostedToolSearchCallIds.shift()) != null ? _i : value.item.id;
+                const toolCallId = (_j = (_i = value.item.call_id) != null ? _i : hostedToolSearchCallIds.shift()) != null ? _j : value.item.id;
                 controller.enqueue({
                   type: "tool-result",
                   toolCallId,
@@ -7178,10 +7522,10 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 });
               } else if (value.item.type === "mcp_call") {
                 ongoingToolCalls[value.output_index] = void 0;
-                const approvalRequestId = (_j = value.item.approval_request_id) != null ? _j : void 0;
-                const aliasedToolCallId = approvalRequestId != null ? (_l = (_k = approvalRequestIdToDummyToolCallIdFromStream.get(
+                const approvalRequestId = (_k = value.item.approval_request_id) != null ? _k : void 0;
+                const aliasedToolCallId = approvalRequestId != null ? (_m = (_l = approvalRequestIdToDummyToolCallIdFromStream.get(
                   approvalRequestId
-                )) != null ? _k : approvalRequestIdToDummyToolCallIdFromPrompt[approvalRequestId]) != null ? _l : value.item.id : value.item.id;
+                )) != null ? _l : approvalRequestIdToDummyToolCallIdFromPrompt[approvalRequestId]) != null ? _m : value.item.id : value.item.id;
                 const toolName = `mcp.${value.item.name}`;
                 controller.enqueue({
                   type: "tool-call",
@@ -7251,8 +7595,8 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 ongoingToolCalls[value.output_index] = void 0;
               } else if (value.item.type === "mcp_approval_request") {
                 ongoingToolCalls[value.output_index] = void 0;
-                const dummyToolCallId = (_o = (_n = (_m = self.config).generateId) == null ? void 0 : _n.call(_m)) != null ? _o : generateId2();
-                const approvalRequestId = (_p = value.item.approval_request_id) != null ? _p : value.item.id;
+                const dummyToolCallId = (_p = (_o = (_n = self.config).generateId) == null ? void 0 : _o.call(_n)) != null ? _p : generateId2();
+                const approvalRequestId = (_q = value.item.approval_request_id) != null ? _q : value.item.id;
                 approvalRequestIdToDummyToolCallIdFromStream.set(
                   approvalRequestId,
                   dummyToolCallId
@@ -7341,7 +7685,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                     providerMetadata: {
                       [providerOptionsName]: {
                         itemId: value.item.id,
-                        reasoningEncryptedContent: (_q = value.item.encrypted_content) != null ? _q : null
+                        reasoningEncryptedContent: (_r = value.item.encrypted_content) != null ? _r : null
                       }
                     }
                   });
@@ -7466,7 +7810,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 id: value.item_id,
                 delta: value.delta
               });
-              if (((_s = (_r = options.providerOptions) == null ? void 0 : _r[providerOptionsName]) == null ? void 0 : _s.logprobs) && value.logprobs) {
+              if (((_t = (_s = options.providerOptions) == null ? void 0 : _s[providerOptionsName]) == null ? void 0 : _t.logprobs) && value.logprobs) {
                 logprobs.push(value.logprobs);
               }
             } else if (value.type === "response.reasoning_summary_part.added") {
@@ -7495,7 +7839,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                   providerMetadata: {
                     [providerOptionsName]: {
                       itemId: value.item_id,
-                      reasoningEncryptedContent: (_u = (_t = activeReasoning[value.item_id]) == null ? void 0 : _t.encryptedContent) != null ? _u : null
+                      reasoningEncryptedContent: (_v = (_u = activeReasoning[value.item_id]) == null ? void 0 : _u.encryptedContent) != null ? _v : null
                     }
                   }
                 });
@@ -7529,20 +7873,20 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
             } else if (isResponseFinishedChunk(value)) {
               finishReason = {
                 unified: mapOpenAIResponseFinishReason({
-                  finishReason: (_v = value.response.incomplete_details) == null ? void 0 : _v.reason,
+                  finishReason: (_w = value.response.incomplete_details) == null ? void 0 : _w.reason,
                   hasFunctionCall
                 }),
-                raw: (_x = (_w = value.response.incomplete_details) == null ? void 0 : _w.reason) != null ? _x : void 0
+                raw: (_y = (_x = value.response.incomplete_details) == null ? void 0 : _x.reason) != null ? _y : void 0
               };
               usage = value.response.usage;
               if (typeof value.response.service_tier === "string") {
                 serviceTier = value.response.service_tier;
               }
-              if (((_y = value.response.reasoning) == null ? void 0 : _y.context) != null) {
+              if (((_z = value.response.reasoning) == null ? void 0 : _z.context) != null) {
                 reasoningContext = value.response.reasoning.context;
               }
             } else if (isResponseFailedChunk(value)) {
-              const incompleteReason = (_z = value.response.incomplete_details) == null ? void 0 : _z.reason;
+              const incompleteReason = (_A = value.response.incomplete_details) == null ? void 0 : _A.reason;
               finishReason = {
                 unified: incompleteReason ? mapOpenAIResponseFinishReason({
                   finishReason: incompleteReason,
@@ -7550,8 +7894,8 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 }) : "error",
                 raw: incompleteReason != null ? incompleteReason : "error"
               };
-              usage = (_A = value.response.usage) != null ? _A : void 0;
-              if (((_B = value.response.reasoning) == null ? void 0 : _B.context) != null) {
+              usage = (_B = value.response.usage) != null ? _B : void 0;
+              if (((_C = value.response.reasoning) == null ? void 0 : _C.context) != null) {
                 reasoningContext = value.response.reasoning.context;
               }
               if (!encounteredStreamError && value.response.error != null) {
@@ -7575,7 +7919,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 controller.enqueue({
                   type: "source",
                   sourceType: "url",
-                  id: (_E = (_D = (_C = self.config).generateId) == null ? void 0 : _D.call(_C)) != null ? _E : generateId2(),
+                  id: (_F = (_E = (_D = self.config).generateId) == null ? void 0 : _E.call(_D)) != null ? _F : generateId2(),
                   url: value.annotation.url,
                   title: value.annotation.title
                 });
@@ -7583,7 +7927,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 controller.enqueue({
                   type: "source",
                   sourceType: "document",
-                  id: (_H = (_G = (_F = self.config).generateId) == null ? void 0 : _G.call(_F)) != null ? _H : generateId2(),
+                  id: (_I = (_H = (_G = self.config).generateId) == null ? void 0 : _H.call(_G)) != null ? _I : generateId2(),
                   mediaType: "text/plain",
                   title: value.annotation.filename,
                   filename: value.annotation.filename,
@@ -7599,7 +7943,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 controller.enqueue({
                   type: "source",
                   sourceType: "document",
-                  id: (_K = (_J = (_I = self.config).generateId) == null ? void 0 : _J.call(_I)) != null ? _K : generateId2(),
+                  id: (_L = (_K = (_J = self.config).generateId) == null ? void 0 : _K.call(_J)) != null ? _L : generateId2(),
                   mediaType: "text/plain",
                   title: value.annotation.filename,
                   filename: value.annotation.filename,
@@ -7615,7 +7959,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 controller.enqueue({
                   type: "source",
                   sourceType: "document",
-                  id: (_N = (_M = (_L = self.config).generateId) == null ? void 0 : _M.call(_L)) != null ? _N : generateId2(),
+                  id: (_O = (_N = (_M = self.config).generateId) == null ? void 0 : _N.call(_M)) != null ? _O : generateId2(),
                   mediaType: "application/octet-stream",
                   title: value.annotation.file_id,
                   filename: value.annotation.file_id,
@@ -7776,15 +8120,15 @@ import {
 
 // src/speech/openai-speech-model-options.ts
 import {
-  lazySchema as lazySchema24,
-  zodSchema as zodSchema24
+  lazySchema as lazySchema25,
+  zodSchema as zodSchema25
 } from "@ai-sdk/provider-utils";
-import { z as z26 } from "zod/v4";
-var openaiSpeechModelOptionsSchema = lazySchema24(
-  () => zodSchema24(
-    z26.object({
-      instructions: z26.string().nullish(),
-      speed: z26.number().min(0.25).max(4).default(1).nullish()
+import { z as z27 } from "zod/v4";
+var openaiSpeechModelOptionsSchema = lazySchema25(
+  () => zodSchema25(
+    z27.object({
+      instructions: z27.string().nullish(),
+      speed: z27.number().min(0.25).max(4).default(1).nullish()
     })
   )
 );
@@ -7921,33 +8265,33 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/transcription/openai-transcription-api.ts
-import { lazySchema as lazySchema25, zodSchema as zodSchema25 } from "@ai-sdk/provider-utils";
-import { z as z27 } from "zod/v4";
-var openaiTranscriptionResponseSchema = lazySchema25(
-  () => zodSchema25(
-    z27.object({
-      text: z27.string(),
-      language: z27.string().nullish(),
-      duration: z27.number().nullish(),
-      words: z27.array(
-        z27.object({
-          word: z27.string(),
-          start: z27.number(),
-          end: z27.number()
+import { lazySchema as lazySchema26, zodSchema as zodSchema26 } from "@ai-sdk/provider-utils";
+import { z as z28 } from "zod/v4";
+var openaiTranscriptionResponseSchema = lazySchema26(
+  () => zodSchema26(
+    z28.object({
+      text: z28.string(),
+      language: z28.string().nullish(),
+      duration: z28.number().nullish(),
+      words: z28.array(
+        z28.object({
+          word: z28.string(),
+          start: z28.number(),
+          end: z28.number()
         })
       ).nullish(),
-      segments: z27.array(
-        z27.object({
-          id: z27.number(),
-          seek: z27.number(),
-          start: z27.number(),
-          end: z27.number(),
-          text: z27.string(),
-          tokens: z27.array(z27.number()),
-          temperature: z27.number(),
-          avg_logprob: z27.number(),
-          compression_ratio: z27.number(),
-          no_speech_prob: z27.number()
+      segments: z28.array(
+        z28.object({
+          id: z28.number(),
+          seek: z28.number(),
+          start: z28.number(),
+          end: z28.number(),
+          text: z28.string(),
+          tokens: z28.array(z28.number()),
+          temperature: z28.number(),
+          avg_logprob: z28.number(),
+          compression_ratio: z28.number(),
+          no_speech_prob: z28.number()
         })
       ).nullish()
     })
@@ -7956,47 +8300,47 @@ var openaiTranscriptionResponseSchema = lazySchema25(
 
 // src/transcription/openai-transcription-model-options.ts
 import {
-  lazySchema as lazySchema26,
-  zodSchema as zodSchema26
+  lazySchema as lazySchema27,
+  zodSchema as zodSchema27
 } from "@ai-sdk/provider-utils";
-import { z as z28 } from "zod/v4";
-var openAITranscriptionModelOptions = lazySchema26(
-  () => zodSchema26(
-    z28.object({
+import { z as z29 } from "zod/v4";
+var openAITranscriptionModelOptions = lazySchema27(
+  () => zodSchema27(
+    z29.object({
       /**
        * Additional information to include in the transcription response.
        */
-      include: z28.array(z28.string()).optional(),
+      include: z29.array(z29.string()).optional(),
       /**
        * The language of the input audio in ISO-639-1 format.
        */
-      language: z28.string().optional(),
+      language: z29.string().optional(),
       /**
        * An optional text to guide the model's style or continue a previous audio segment.
        */
-      prompt: z28.string().optional(),
+      prompt: z29.string().optional(),
       /**
        * The sampling temperature, between 0 and 1.
        * @default 0
        */
-      temperature: z28.number().min(0).max(1).default(0).optional(),
+      temperature: z29.number().min(0).max(1).default(0).optional(),
       /**
        * The timestamp granularities to populate for this transcription.
        * @default ['segment']
        */
-      timestampGranularities: z28.array(z28.enum(["word", "segment"])).default(["segment"]).optional(),
+      timestampGranularities: z29.array(z29.enum(["word", "segment"])).default(["segment"]).optional(),
       /**
        * Options for streaming transcription models such as `gpt-realtime-whisper`.
        */
-      streaming: z28.object({
+      streaming: z29.object({
         /**
          * Latency/accuracy tradeoff for realtime transcription.
          */
-        delay: z28.enum(["minimal", "low", "medium", "high", "xhigh"]).optional(),
+        delay: z29.enum(["minimal", "low", "medium", "high", "xhigh"]).optional(),
         /**
          * Additional fields to include in realtime transcription events.
          */
-        include: z28.array(z28.string()).optional()
+        include: z29.array(z29.string()).optional()
       }).optional()
     })
   )
@@ -8441,28 +8785,28 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/skills/openai-skills-api.ts
-import { lazySchema as lazySchema27, zodSchema as zodSchema27 } from "@ai-sdk/provider-utils";
-import { z as z29 } from "zod/v4";
-var openaiSkillResponseSchema = lazySchema27(
-  () => zodSchema27(
-    z29.object({
-      id: z29.string(),
-      name: z29.string().nullish(),
-      description: z29.string().nullish(),
-      default_version: z29.string().nullish(),
-      latest_version: z29.string().nullish(),
-      created_at: z29.number(),
-      updated_at: z29.number().nullish()
+import { lazySchema as lazySchema28, zodSchema as zodSchema28 } from "@ai-sdk/provider-utils";
+import { z as z30 } from "zod/v4";
+var openaiSkillResponseSchema = lazySchema28(
+  () => zodSchema28(
+    z30.object({
+      id: z30.string(),
+      name: z30.string().nullish(),
+      description: z30.string().nullish(),
+      default_version: z30.string().nullish(),
+      latest_version: z30.string().nullish(),
+      created_at: z30.number(),
+      updated_at: z30.number().nullish()
     })
   )
 );
-var openaiSkillVersionResponseSchema = lazySchema27(
-  () => zodSchema27(
-    z29.object({
-      id: z29.string(),
-      version: z29.string().nullish(),
-      name: z29.string().nullish(),
-      description: z29.string().nullish()
+var openaiSkillVersionResponseSchema = lazySchema28(
+  () => zodSchema28(
+    z30.object({
+      id: z30.string(),
+      version: z30.string().nullish(),
+      name: z30.string().nullish(),
+      description: z30.string().nullish()
     })
   )
 );
@@ -8517,7 +8861,7 @@ var OpenAISkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.13" : "0.0.0-test";
+var VERSION = true ? "4.0.15" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {