@ai-sdk/openai 3.0.0-beta.80 → 3.0.0-beta.82

package/dist/index.mjs

@@ -1973,74 +1973,58 @@ var localShell = createProviderToolFactoryWithOutputSchema5({
   outputSchema: localShellOutputSchema
 });
 
-// src/tool/web-search.ts
+// src/tool/shell.ts
 import {
   createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema6,
   lazySchema as lazySchema13,
   zodSchema as zodSchema13
 } from "@ai-sdk/provider-utils";
 import { z as z14 } from "zod/v4";
-var webSearchArgsSchema = lazySchema13(
+var shellInputSchema = lazySchema13(
   () => zodSchema13(
     z14.object({
-      externalWebAccess: z14.boolean().optional(),
-      filters: z14.object({ allowedDomains: z14.array(z14.string()).optional() }).optional(),
-      searchContextSize: z14.enum(["low", "medium", "high"]).optional(),
-      userLocation: z14.object({
-        type: z14.literal("approximate"),
-        country: z14.string().optional(),
-        city: z14.string().optional(),
-        region: z14.string().optional(),
-        timezone: z14.string().optional()
-      }).optional()
+      action: z14.object({
+        commands: z14.array(z14.string()),
+        timeoutMs: z14.number().optional(),
+        maxOutputLength: z14.number().optional()
+      })
     })
   )
 );
-var webSearchInputSchema = lazySchema13(() => zodSchema13(z14.object({})));
-var webSearchOutputSchema = lazySchema13(
+var shellOutputSchema = lazySchema13(
   () => zodSchema13(
     z14.object({
-      action: z14.discriminatedUnion("type", [
+      output: z14.array(
         z14.object({
-          type: z14.literal("search"),
-          query: z14.string().optional()
-        }),
-        z14.object({
-          type: z14.literal("openPage"),
-          url: z14.string().nullish()
-        }),
-        z14.object({
-          type: z14.literal("find"),
-          url: z14.string().nullish(),
-          pattern: z14.string().nullish()
+          stdout: z14.string(),
+          stderr: z14.string(),
+          outcome: z14.discriminatedUnion("type", [
+            z14.object({ type: z14.literal("timeout") }),
+            z14.object({ type: z14.literal("exit"), exitCode: z14.number() })
+          ])
         })
-      ]),
-      sources: z14.array(
-        z14.discriminatedUnion("type", [
-          z14.object({ type: z14.literal("url"), url: z14.string() }),
-          z14.object({ type: z14.literal("api"), name: z14.string() })
-        ])
-      ).optional()
+      )
     })
   )
 );
-var webSearchToolFactory = createProviderToolFactoryWithOutputSchema6({
-  id: "openai.web_search",
-  inputSchema: webSearchInputSchema,
-  outputSchema: webSearchOutputSchema
+var shell = createProviderToolFactoryWithOutputSchema6({
+  id: "openai.shell",
+  inputSchema: shellInputSchema,
+  outputSchema: shellOutputSchema
 });
-var webSearch = (args = {}) => webSearchToolFactory(args);
 
-// src/tool/web-search-preview.ts
+// src/tool/web-search.ts
 import {
   createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema7,
   lazySchema as lazySchema14,
   zodSchema as zodSchema14
 } from "@ai-sdk/provider-utils";
 import { z as z15 } from "zod/v4";
-var webSearchPreviewArgsSchema = lazySchema14(
+var webSearchArgsSchema = lazySchema14(
   () => zodSchema14(
     z15.object({
+      externalWebAccess: z15.boolean().optional(),
+      filters: z15.object({ allowedDomains: z15.array(z15.string()).optional() }).optional(),
       searchContextSize: z15.enum(["low", "medium", "high"]).optional(),
       userLocation: z15.object({
         type: z15.literal("approximate"),
@@ -2052,10 +2036,8 @@ var webSearchPreviewArgsSchema = lazySchema14(
     })
   )
 );
-var webSearchPreviewInputSchema = lazySchema14(
-  () => zodSchema14(z15.object({}))
-);
-var webSearchPreviewOutputSchema = lazySchema14(
+var webSearchInputSchema = lazySchema14(() => zodSchema14(z15.object({})));
+var webSearchOutputSchema = lazySchema14(
   () => zodSchema14(
     z15.object({
       action: z15.discriminatedUnion("type", [
@@ -2072,47 +2054,105 @@ var webSearchPreviewOutputSchema = lazySchema14(
           url: z15.string().nullish(),
           pattern: z15.string().nullish()
         })
-      ])
+      ]),
+      sources: z15.array(
+        z15.discriminatedUnion("type", [
+          z15.object({ type: z15.literal("url"), url: z15.string() }),
+          z15.object({ type: z15.literal("api"), name: z15.string() })
+        ])
+      ).optional()
     })
   )
 );
-var webSearchPreview = createProviderToolFactoryWithOutputSchema7({
-  id: "openai.web_search_preview",
-  inputSchema: webSearchPreviewInputSchema,
-  outputSchema: webSearchPreviewOutputSchema
+var webSearchToolFactory = createProviderToolFactoryWithOutputSchema7({
+  id: "openai.web_search",
+  inputSchema: webSearchInputSchema,
+  outputSchema: webSearchOutputSchema
 });
+var webSearch = (args = {}) => webSearchToolFactory(args);
 
-// src/tool/mcp.ts
+// src/tool/web-search-preview.ts
 import {
   createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema8,
   lazySchema as lazySchema15,
   zodSchema as zodSchema15
 } from "@ai-sdk/provider-utils";
 import { z as z16 } from "zod/v4";
-var jsonValueSchema = z16.lazy(
-  () => z16.union([
-    z16.string(),
-    z16.number(),
-    z16.boolean(),
-    z16.null(),
-    z16.array(jsonValueSchema),
-    z16.record(z16.string(), jsonValueSchema)
-  ])
+var webSearchPreviewArgsSchema = lazySchema15(
+  () => zodSchema15(
+    z16.object({
+      searchContextSize: z16.enum(["low", "medium", "high"]).optional(),
+      userLocation: z16.object({
+        type: z16.literal("approximate"),
+        country: z16.string().optional(),
+        city: z16.string().optional(),
+        region: z16.string().optional(),
+        timezone: z16.string().optional()
+      }).optional()
+    })
+  )
 );
-var mcpArgsSchema = lazySchema15(
+var webSearchPreviewInputSchema = lazySchema15(
+  () => zodSchema15(z16.object({}))
+);
+var webSearchPreviewOutputSchema = lazySchema15(
   () => zodSchema15(
     z16.object({
-      serverLabel: z16.string(),
-      allowedTools: z16.union([
-        z16.array(z16.string()),
+      action: z16.discriminatedUnion("type", [
+        z16.object({
+          type: z16.literal("search"),
+          query: z16.string().optional()
+        }),
+        z16.object({
+          type: z16.literal("openPage"),
+          url: z16.string().nullish()
+        }),
         z16.object({
-          readOnly: z16.boolean().optional(),
-          toolNames: z16.array(z16.string()).optional()
+          type: z16.literal("find"),
+          url: z16.string().nullish(),
+          pattern: z16.string().nullish()
+        })
+      ])
+    })
+  )
+);
+var webSearchPreview = createProviderToolFactoryWithOutputSchema8({
+  id: "openai.web_search_preview",
+  inputSchema: webSearchPreviewInputSchema,
+  outputSchema: webSearchPreviewOutputSchema
+});
+
+// src/tool/mcp.ts
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema9,
+  lazySchema as lazySchema16,
+  zodSchema as zodSchema16
+} from "@ai-sdk/provider-utils";
+import { z as z17 } from "zod/v4";
+var jsonValueSchema = z17.lazy(
+  () => z17.union([
+    z17.string(),
+    z17.number(),
+    z17.boolean(),
+    z17.null(),
+    z17.array(jsonValueSchema),
+    z17.record(z17.string(), jsonValueSchema)
+  ])
+);
+var mcpArgsSchema = lazySchema16(
+  () => zodSchema16(
+    z17.object({
+      serverLabel: z17.string(),
+      allowedTools: z17.union([
+        z17.array(z17.string()),
+        z17.object({
+          readOnly: z17.boolean().optional(),
+          toolNames: z17.array(z17.string()).optional()
         })
       ]).optional(),
-      authorization: z16.string().optional(),
-      connectorId: z16.string().optional(),
-      headers: z16.record(z16.string(), z16.string()).optional(),
+      authorization: z17.string().optional(),
+      connectorId: z17.string().optional(),
+      headers: z17.record(z17.string(), z17.string()).optional(),
       // TODO: Integrate this MCP tool approval with our SDK's existing tool approval architecture
       // requireApproval: z
       //   .union([
@@ -2123,50 +2163,50 @@ var mcpArgsSchema = lazySchema15(
       //     }),
       //   ])
       //   .optional(),
-      serverDescription: z16.string().optional(),
-      serverUrl: z16.string().optional()
+      serverDescription: z17.string().optional(),
+      serverUrl: z17.string().optional()
     }).refine(
       (v) => v.serverUrl != null || v.connectorId != null,
       "One of serverUrl or connectorId must be provided."
     )
   )
 );
-var mcpInputSchema = lazySchema15(() => zodSchema15(z16.object({})));
-var mcpOutputSchema = lazySchema15(
-  () => zodSchema15(
-    z16.discriminatedUnion("type", [
-      z16.object({
-        type: z16.literal("call"),
-        serverLabel: z16.string(),
-        name: z16.string(),
-        arguments: z16.string(),
-        output: z16.string().nullable().optional(),
-        error: z16.union([z16.string(), jsonValueSchema]).optional()
+var mcpInputSchema = lazySchema16(() => zodSchema16(z17.object({})));
+var mcpOutputSchema = lazySchema16(
+  () => zodSchema16(
+    z17.discriminatedUnion("type", [
+      z17.object({
+        type: z17.literal("call"),
+        serverLabel: z17.string(),
+        name: z17.string(),
+        arguments: z17.string(),
+        output: z17.string().nullable().optional(),
+        error: z17.union([z17.string(), jsonValueSchema]).optional()
       }),
-      z16.object({
-        type: z16.literal("listTools"),
-        serverLabel: z16.string(),
-        tools: z16.array(
-          z16.object({
-            name: z16.string(),
-            description: z16.string().optional(),
+      z17.object({
+        type: z17.literal("listTools"),
+        serverLabel: z17.string(),
+        tools: z17.array(
+          z17.object({
+            name: z17.string(),
+            description: z17.string().optional(),
             inputSchema: jsonValueSchema,
-            annotations: z16.record(z16.string(), jsonValueSchema).optional()
+            annotations: z17.record(z17.string(), jsonValueSchema).optional()
           })
         ),
-        error: z16.union([z16.string(), jsonValueSchema]).optional()
+        error: z17.union([z17.string(), jsonValueSchema]).optional()
       }),
-      z16.object({
-        type: z16.literal("approvalRequest"),
-        serverLabel: z16.string(),
-        name: z16.string(),
-        arguments: z16.string(),
-        approvalRequestId: z16.string()
+      z17.object({
+        type: z17.literal("approvalRequest"),
+        serverLabel: z17.string(),
+        name: z17.string(),
+        arguments: z17.string(),
+        approvalRequestId: z17.string()
       })
     ])
   )
 );
-var mcpToolFactory = createProviderToolFactoryWithOutputSchema8({
+var mcpToolFactory = createProviderToolFactoryWithOutputSchema9({
   id: "openai.mcp",
   inputSchema: mcpInputSchema,
   outputSchema: mcpOutputSchema
@@ -2226,6 +2266,18 @@ var openaiTools = {
    * Supported models: `gpt-5-codex` and `codex-mini-latest`
    */
   localShell,
+  /**
+   * The shell tool allows the model to interact with your local computer through
+   * a controlled command-line interface. The model proposes shell commands; your
+   * integration executes them and returns the outputs.
+   *
+   * Available through the Responses API for use with GPT-5.1.
+   *
+   * WARNING: Running arbitrary shell commands can be dangerous. Always sandbox
+   * execution or add strict allow-/deny-lists before forwarding a command to
+   * the system shell.
+   */
+  shell,
   /**
    * Web search allows models to access up-to-date information from the internet
    * and provide answers with sourced citations.
@@ -2283,7 +2335,7 @@ import {
   parseProviderOptions as parseProviderOptions4,
   validateTypes
 } from "@ai-sdk/provider-utils";
-import { z as z17 } from "zod/v4";
+import { z as z18 } from "zod/v4";
 function isFileId(data, prefixes) {
   if (!prefixes) return false;
   return prefixes.some((prefix) => data.startsWith(prefix));
@@ -2295,6 +2347,7 @@ async function convertToOpenAIResponsesInput({
   fileIdPrefixes,
   store,
   hasLocalShellTool = false,
+  hasShellTool = false,
   hasApplyPatchTool = false
 }) {
   var _a, _b, _c, _d, _e;
@@ -2421,6 +2474,24 @@ async function convertToOpenAIResponsesInput({
                 });
                 break;
               }
+              if (hasShellTool && resolvedToolName === "shell") {
+                const parsedInput = await validateTypes({
+                  value: part.input,
+                  schema: shellInputSchema
+                });
+                input.push({
+                  type: "shell_call",
+                  call_id: part.toolCallId,
+                  id,
+                  status: "completed",
+                  action: {
+                    commands: parsedInput.action.commands,
+                    timeout_ms: parsedInput.action.timeoutMs,
+                    max_output_length: parsedInput.action.maxOutputLength
+                  }
+                });
+                break;
+              }
               input.push({
                 type: "function_call",
                 call_id: part.toolCallId,
@@ -2518,6 +2589,25 @@ async function convertToOpenAIResponsesInput({
             });
             break;
           }
+          if (hasShellTool && resolvedToolName === "shell" && output.type === "json") {
+            const parsedOutput = await validateTypes({
+              value: output.value,
+              schema: shellOutputSchema
+            });
+            input.push({
+              type: "shell_call_output",
+              call_id: part.toolCallId,
+              output: parsedOutput.output.map((item) => ({
+                stdout: item.stdout,
+                stderr: item.stderr,
+                outcome: item.outcome.type === "timeout" ? { type: "timeout" } : {
+                  type: "exit",
+                  exit_code: item.outcome.exitCode
+                }
+              }))
+            });
+            break;
+          }
           if (hasApplyPatchTool && part.toolName === "apply_patch" && output.type === "json") {
             const parsedOutput = await validateTypes({
               value: output.value,
@@ -2591,9 +2681,9 @@ async function convertToOpenAIResponsesInput({
   }
   return { input, warnings };
 }
-var openaiResponsesReasoningProviderOptionsSchema = z17.object({
-  itemId: z17.string().nullish(),
-  reasoningEncryptedContent: z17.string().nullish()
+var openaiResponsesReasoningProviderOptionsSchema = z18.object({
+  itemId: z18.string().nullish(),
+  reasoningEncryptedContent: z18.string().nullish()
 });
 
 // src/responses/map-openai-responses-finish-reason.ts
@@ -2615,393 +2705,411 @@ function mapOpenAIResponseFinishReason({
 }
 
 // src/responses/openai-responses-api.ts
-import { lazySchema as lazySchema16, zodSchema as zodSchema16 } from "@ai-sdk/provider-utils";
-import { z as z18 } from "zod/v4";
-var openaiResponsesChunkSchema = lazySchema16(
-  () => zodSchema16(
-    z18.union([
-      z18.object({
-        type: z18.literal("response.output_text.delta"),
-        item_id: z18.string(),
-        delta: z18.string(),
-        logprobs: z18.array(
-          z18.object({
-            token: z18.string(),
-            logprob: z18.number(),
-            top_logprobs: z18.array(
-              z18.object({
-                token: z18.string(),
-                logprob: z18.number()
+import { lazySchema as lazySchema17, zodSchema as zodSchema17 } from "@ai-sdk/provider-utils";
+import { z as z19 } from "zod/v4";
+var openaiResponsesChunkSchema = lazySchema17(
+  () => zodSchema17(
+    z19.union([
+      z19.object({
+        type: z19.literal("response.output_text.delta"),
+        item_id: z19.string(),
+        delta: z19.string(),
+        logprobs: z19.array(
+          z19.object({
+            token: z19.string(),
+            logprob: z19.number(),
+            top_logprobs: z19.array(
+              z19.object({
+                token: z19.string(),
+                logprob: z19.number()
               })
             )
           })
         ).nullish()
       }),
-      z18.object({
-        type: z18.enum(["response.completed", "response.incomplete"]),
-        response: z18.object({
-          incomplete_details: z18.object({ reason: z18.string() }).nullish(),
-          usage: z18.object({
-            input_tokens: z18.number(),
-            input_tokens_details: z18.object({ cached_tokens: z18.number().nullish() }).nullish(),
-            output_tokens: z18.number(),
-            output_tokens_details: z18.object({ reasoning_tokens: z18.number().nullish() }).nullish()
+      z19.object({
+        type: z19.enum(["response.completed", "response.incomplete"]),
+        response: z19.object({
+          incomplete_details: z19.object({ reason: z19.string() }).nullish(),
+          usage: z19.object({
+            input_tokens: z19.number(),
+            input_tokens_details: z19.object({ cached_tokens: z19.number().nullish() }).nullish(),
+            output_tokens: z19.number(),
+            output_tokens_details: z19.object({ reasoning_tokens: z19.number().nullish() }).nullish()
           }),
-          service_tier: z18.string().nullish()
+          service_tier: z19.string().nullish()
         })
       }),
-      z18.object({
-        type: z18.literal("response.created"),
-        response: z18.object({
-          id: z18.string(),
-          created_at: z18.number(),
-          model: z18.string(),
-          service_tier: z18.string().nullish()
+      z19.object({
+        type: z19.literal("response.created"),
+        response: z19.object({
+          id: z19.string(),
+          created_at: z19.number(),
+          model: z19.string(),
+          service_tier: z19.string().nullish()
         })
       }),
-      z18.object({
-        type: z18.literal("response.output_item.added"),
-        output_index: z18.number(),
-        item: z18.discriminatedUnion("type", [
-          z18.object({
-            type: z18.literal("message"),
-            id: z18.string()
+      z19.object({
+        type: z19.literal("response.output_item.added"),
+        output_index: z19.number(),
+        item: z19.discriminatedUnion("type", [
+          z19.object({
+            type: z19.literal("message"),
+            id: z19.string()
           }),
-          z18.object({
-            type: z18.literal("reasoning"),
-            id: z18.string(),
-            encrypted_content: z18.string().nullish()
+          z19.object({
+            type: z19.literal("reasoning"),
+            id: z19.string(),
+            encrypted_content: z19.string().nullish()
           }),
-          z18.object({
-            type: z18.literal("function_call"),
-            id: z18.string(),
-            call_id: z18.string(),
-            name: z18.string(),
-            arguments: z18.string()
+          z19.object({
+            type: z19.literal("function_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            name: z19.string(),
+            arguments: z19.string()
           }),
-          z18.object({
-            type: z18.literal("web_search_call"),
-            id: z18.string(),
-            status: z18.string()
+          z19.object({
+            type: z19.literal("web_search_call"),
+            id: z19.string(),
+            status: z19.string()
           }),
-          z18.object({
-            type: z18.literal("computer_call"),
-            id: z18.string(),
-            status: z18.string()
+          z19.object({
+            type: z19.literal("computer_call"),
+            id: z19.string(),
+            status: z19.string()
           }),
-          z18.object({
-            type: z18.literal("file_search_call"),
-            id: z18.string()
+          z19.object({
+            type: z19.literal("file_search_call"),
+            id: z19.string()
           }),
-          z18.object({
-            type: z18.literal("image_generation_call"),
-            id: z18.string()
+          z19.object({
+            type: z19.literal("image_generation_call"),
+            id: z19.string()
           }),
-          z18.object({
-            type: z18.literal("code_interpreter_call"),
-            id: z18.string(),
-            container_id: z18.string(),
-            code: z18.string().nullable(),
-            outputs: z18.array(
-              z18.discriminatedUnion("type", [
-                z18.object({ type: z18.literal("logs"), logs: z18.string() }),
-                z18.object({ type: z18.literal("image"), url: z18.string() })
+          z19.object({
+            type: z19.literal("code_interpreter_call"),
+            id: z19.string(),
+            container_id: z19.string(),
+            code: z19.string().nullable(),
+            outputs: z19.array(
+              z19.discriminatedUnion("type", [
+                z19.object({ type: z19.literal("logs"), logs: z19.string() }),
+                z19.object({ type: z19.literal("image"), url: z19.string() })
               ])
             ).nullable(),
-            status: z18.string()
+            status: z19.string()
           }),
-          z18.object({
-            type: z18.literal("mcp_call"),
-            id: z18.string(),
-            status: z18.string()
+          z19.object({
+            type: z19.literal("mcp_call"),
+            id: z19.string(),
+            status: z19.string()
           }),
-          z18.object({
-            type: z18.literal("mcp_list_tools"),
-            id: z18.string()
+          z19.object({
+            type: z19.literal("mcp_list_tools"),
+            id: z19.string()
           }),
-          z18.object({
-            type: z18.literal("mcp_approval_request"),
-            id: z18.string()
+          z19.object({
+            type: z19.literal("mcp_approval_request"),
+            id: z19.string()
           }),
-          z18.object({
-            type: z18.literal("apply_patch_call"),
-            id: z18.string(),
-            call_id: z18.string(),
-            status: z18.enum(["in_progress", "completed"]),
-            operation: z18.discriminatedUnion("type", [
-              z18.object({
-                type: z18.literal("create_file"),
-                path: z18.string(),
-                diff: z18.string()
+          z19.object({
+            type: z19.literal("apply_patch_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            status: z19.enum(["in_progress", "completed"]),
+            operation: z19.discriminatedUnion("type", [
+              z19.object({
+                type: z19.literal("create_file"),
+                path: z19.string(),
+                diff: z19.string()
               }),
-              z18.object({
-                type: z18.literal("delete_file"),
-                path: z18.string()
+              z19.object({
+                type: z19.literal("delete_file"),
+                path: z19.string()
               }),
-              z18.object({
-                type: z18.literal("update_file"),
-                path: z18.string(),
-                diff: z18.string()
+              z19.object({
+                type: z19.literal("update_file"),
+                path: z19.string(),
+                diff: z19.string()
               })
             ])
+          }),
+          z19.object({
+            type: z19.literal("shell_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            status: z19.enum(["in_progress", "completed", "incomplete"]),
+            action: z19.object({
+              commands: z19.array(z19.string())
+            })
           })
         ])
       }),
-      z18.object({
-        type: z18.literal("response.output_item.done"),
-        output_index: z18.number(),
-        item: z18.discriminatedUnion("type", [
-          z18.object({
-            type: z18.literal("message"),
-            id: z18.string()
+      z19.object({
+        type: z19.literal("response.output_item.done"),
+        output_index: z19.number(),
+        item: z19.discriminatedUnion("type", [
+          z19.object({
+            type: z19.literal("message"),
+            id: z19.string()
           }),
-          z18.object({
-            type: z18.literal("reasoning"),
-            id: z18.string(),
-            encrypted_content: z18.string().nullish()
+          z19.object({
+            type: z19.literal("reasoning"),
+            id: z19.string(),
+            encrypted_content: z19.string().nullish()
           }),
-          z18.object({
-            type: z18.literal("function_call"),
-            id: z18.string(),
-            call_id: z18.string(),
-            name: z18.string(),
-            arguments: z18.string(),
-            status: z18.literal("completed")
+          z19.object({
+            type: z19.literal("function_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            name: z19.string(),
+            arguments: z19.string(),
+            status: z19.literal("completed")
           }),
-          z18.object({
-            type: z18.literal("code_interpreter_call"),
-            id: z18.string(),
-            code: z18.string().nullable(),
-            container_id: z18.string(),
-            outputs: z18.array(
-              z18.discriminatedUnion("type", [
-                z18.object({ type: z18.literal("logs"), logs: z18.string() }),
-                z18.object({ type: z18.literal("image"), url: z18.string() })
+          z19.object({
+            type: z19.literal("code_interpreter_call"),
+            id: z19.string(),
+            code: z19.string().nullable(),
+            container_id: z19.string(),
+            outputs: z19.array(
+              z19.discriminatedUnion("type", [
+                z19.object({ type: z19.literal("logs"), logs: z19.string() }),
+                z19.object({ type: z19.literal("image"), url: z19.string() })
               ])
             ).nullable()
           }),
-          z18.object({
-            type: z18.literal("image_generation_call"),
-            id: z18.string(),
-            result: z18.string()
+          z19.object({
+            type: z19.literal("image_generation_call"),
+            id: z19.string(),
+            result: z19.string()
           }),
-          z18.object({
-            type: z18.literal("web_search_call"),
-            id: z18.string(),
-            status: z18.string(),
-            action: z18.discriminatedUnion("type", [
-              z18.object({
-                type: z18.literal("search"),
-                query: z18.string().nullish(),
-                sources: z18.array(
-                  z18.discriminatedUnion("type", [
-                    z18.object({ type: z18.literal("url"), url: z18.string() }),
-                    z18.object({ type: z18.literal("api"), name: z18.string() })
+          z19.object({
+            type: z19.literal("web_search_call"),
+            id: z19.string(),
+            status: z19.string(),
+            action: z19.discriminatedUnion("type", [
+              z19.object({
+                type: z19.literal("search"),
+                query: z19.string().nullish(),
+                sources: z19.array(
+                  z19.discriminatedUnion("type", [
+                    z19.object({ type: z19.literal("url"), url: z19.string() }),
+                    z19.object({ type: z19.literal("api"), name: z19.string() })
                   ])
                 ).nullish()
               }),
-              z18.object({
-                type: z18.literal("open_page"),
-                url: z18.string().nullish()
+              z19.object({
+                type: z19.literal("open_page"),
+                url: z19.string().nullish()
               }),
-              z18.object({
-                type: z18.literal("find"),
-                url: z18.string().nullish(),
-                pattern: z18.string().nullish()
+              z19.object({
+                type: z19.literal("find"),
+                url: z19.string().nullish(),
+                pattern: z19.string().nullish()
               })
             ])
           }),
-          z18.object({
-            type: z18.literal("file_search_call"),
-            id: z18.string(),
-            queries: z18.array(z18.string()),
-            results: z18.array(
-              z18.object({
-                attributes: z18.record(
-                  z18.string(),
-                  z18.union([z18.string(), z18.number(), z18.boolean()])
+          z19.object({
+            type: z19.literal("file_search_call"),
+            id: z19.string(),
+            queries: z19.array(z19.string()),
+            results: z19.array(
+              z19.object({
+                attributes: z19.record(
+                  z19.string(),
+                  z19.union([z19.string(), z19.number(), z19.boolean()])
                 ),
-                file_id: z18.string(),
-                filename: z18.string(),
-                score: z18.number(),
-                text: z18.string()
+                file_id: z19.string(),
+                filename: z19.string(),
+                score: z19.number(),
+                text: z19.string()
               })
             ).nullish()
           }),
-          z18.object({
-            type: z18.literal("local_shell_call"),
-            id: z18.string(),
-            call_id: z18.string(),
-            action: z18.object({
-              type: z18.literal("exec"),
-              command: z18.array(z18.string()),
-              timeout_ms: z18.number().optional(),
-              user: z18.string().optional(),
-              working_directory: z18.string().optional(),
-              env: z18.record(z18.string(), z18.string()).optional()
+          z19.object({
+            type: z19.literal("local_shell_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            action: z19.object({
+              type: z19.literal("exec"),
+              command: z19.array(z19.string()),
+              timeout_ms: z19.number().optional(),
+              user: z19.string().optional(),
+              working_directory: z19.string().optional(),
+              env: z19.record(z19.string(), z19.string()).optional()
             })
           }),
-          z18.object({
-            type: z18.literal("computer_call"),
-            id: z18.string(),
-            status: z18.literal("completed")
+          z19.object({
+            type: z19.literal("computer_call"),
+            id: z19.string(),
+            status: z19.literal("completed")
           }),
-          z18.object({
-            type: z18.literal("mcp_call"),
-            id: z18.string(),
-            status: z18.string(),
-            arguments: z18.string(),
-            name: z18.string(),
-            server_label: z18.string(),
-            output: z18.string().nullish(),
-            error: z18.union([
-              z18.string(),
-              z18.object({
-                type: z18.string().optional(),
-                code: z18.union([z18.number(), z18.string()]).optional(),
-                message: z18.string().optional()
+          z19.object({
+            type: z19.literal("mcp_call"),
+            id: z19.string(),
+            status: z19.string(),
+            arguments: z19.string(),
+            name: z19.string(),
+            server_label: z19.string(),
+            output: z19.string().nullish(),
+            error: z19.union([
+              z19.string(),
+              z19.object({
+                type: z19.string().optional(),
+                code: z19.union([z19.number(), z19.string()]).optional(),
+                message: z19.string().optional()
               }).loose()
             ]).nullish()
           }),
-          z18.object({
-            type: z18.literal("mcp_list_tools"),
-            id: z18.string(),
-            server_label: z18.string(),
-            tools: z18.array(
-              z18.object({
-                name: z18.string(),
-                description: z18.string().optional(),
-                input_schema: z18.any(),
-                annotations: z18.record(z18.string(), z18.unknown()).optional()
+          z19.object({
+            type: z19.literal("mcp_list_tools"),
+            id: z19.string(),
+            server_label: z19.string(),
+            tools: z19.array(
+              z19.object({
+                name: z19.string(),
+                description: z19.string().optional(),
+                input_schema: z19.any(),
+                annotations: z19.record(z19.string(), z19.unknown()).optional()
               })
             ),
-            error: z18.union([
-              z18.string(),
-              z18.object({
-                type: z18.string().optional(),
-                code: z18.union([z18.number(), z18.string()]).optional(),
-                message: z18.string().optional()
+            error: z19.union([
+              z19.string(),
+              z19.object({
+                type: z19.string().optional(),
+                code: z19.union([z19.number(), z19.string()]).optional(),
+                message: z19.string().optional()
               }).loose()
             ]).optional()
           }),
-          z18.object({
-            type: z18.literal("mcp_approval_request"),
-            id: z18.string(),
-            server_label: z18.string(),
-            name: z18.string(),
-            arguments: z18.string(),
-            approval_request_id: z18.string()
+          z19.object({
+            type: z19.literal("mcp_approval_request"),
+            id: z19.string(),
+            server_label: z19.string(),
+            name: z19.string(),
+            arguments: z19.string(),
+            approval_request_id: z19.string()
           }),
-          z18.object({
-            type: z18.literal("apply_patch_call"),
-            id: z18.string(),
-            call_id: z18.string(),
-            status: z18.enum(["in_progress", "completed"]),
-            operation: z18.discriminatedUnion("type", [
-              z18.object({
-                type: z18.literal("create_file"),
-                path: z18.string(),
-                diff: z18.string()
+          z19.object({
+            type: z19.literal("apply_patch_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            status: z19.enum(["in_progress", "completed"]),
+            operation: z19.discriminatedUnion("type", [
+              z19.object({
+                type: z19.literal("create_file"),
+                path: z19.string(),
+                diff: z19.string()
               }),
-              z18.object({
-                type: z18.literal("delete_file"),
-                path: z18.string()
+              z19.object({
+                type: z19.literal("delete_file"),
+                path: z19.string()
               }),
-              z18.object({
-                type: z18.literal("update_file"),
-                path: z18.string(),
-                diff: z18.string()
+              z19.object({
+                type: z19.literal("update_file"),
+                path: z19.string(),
+                diff: z19.string()
               })
             ])
+          }),
+          z19.object({
+            type: z19.literal("shell_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            status: z19.enum(["in_progress", "completed", "incomplete"]),
+            action: z19.object({
+              commands: z19.array(z19.string())
+            })
           })
         ])
       }),
-      z18.object({
-        type: z18.literal("response.function_call_arguments.delta"),
-        item_id: z18.string(),
-        output_index: z18.number(),
-        delta: z18.string()
+      z19.object({
+        type: z19.literal("response.function_call_arguments.delta"),
+        item_id: z19.string(),
+        output_index: z19.number(),
+        delta: z19.string()
       }),
-      z18.object({
-        type: z18.literal("response.image_generation_call.partial_image"),
-        item_id: z18.string(),
-        output_index: z18.number(),
-        partial_image_b64: z18.string()
+      z19.object({
+        type: z19.literal("response.image_generation_call.partial_image"),
+        item_id: z19.string(),
+        output_index: z19.number(),
+        partial_image_b64: z19.string()
       }),
-      z18.object({
-        type: z18.literal("response.code_interpreter_call_code.delta"),
-        item_id: z18.string(),
-        output_index: z18.number(),
-        delta: z18.string()
+      z19.object({
+        type: z19.literal("response.code_interpreter_call_code.delta"),
+        item_id: z19.string(),
+        output_index: z19.number(),
+        delta: z19.string()
       }),
-      z18.object({
-        type: z18.literal("response.code_interpreter_call_code.done"),
-        item_id: z18.string(),
-        output_index: z18.number(),
-        code: z18.string()
+      z19.object({
+        type: z19.literal("response.code_interpreter_call_code.done"),
+        item_id: z19.string(),
+        output_index: z19.number(),
+        code: z19.string()
       }),
-      z18.object({
-        type: z18.literal("response.output_text.annotation.added"),
-        annotation: z18.discriminatedUnion("type", [
-          z18.object({
-            type: z18.literal("url_citation"),
-            start_index: z18.number(),
-            end_index: z18.number(),
-            url: z18.string(),
-            title: z18.string()
+      z19.object({
+        type: z19.literal("response.output_text.annotation.added"),
+        annotation: z19.discriminatedUnion("type", [
+          z19.object({
+            type: z19.literal("url_citation"),
+            start_index: z19.number(),
+            end_index: z19.number(),
+            url: z19.string(),
+            title: z19.string()
           }),
-          z18.object({
-            type: z18.literal("file_citation"),
-            file_id: z18.string(),
-            filename: z18.string().nullish(),
-            index: z18.number().nullish(),
-            start_index: z18.number().nullish(),
-            end_index: z18.number().nullish(),
-            quote: z18.string().nullish()
+          z19.object({
+            type: z19.literal("file_citation"),
+            file_id: z19.string(),
+            filename: z19.string().nullish(),
+            index: z19.number().nullish(),
+            start_index: z19.number().nullish(),
+            end_index: z19.number().nullish(),
+            quote: z19.string().nullish()
           }),
-          z18.object({
-            type: z18.literal("container_file_citation"),
-            container_id: z18.string(),
-            file_id: z18.string(),
-            filename: z18.string().nullish(),
-            start_index: z18.number().nullish(),
-            end_index: z18.number().nullish(),
-            index: z18.number().nullish()
+          z19.object({
+            type: z19.literal("container_file_citation"),
+            container_id: z19.string(),
+            file_id: z19.string(),
+            filename: z19.string().nullish(),
+            start_index: z19.number().nullish(),
+            end_index: z19.number().nullish(),
+            index: z19.number().nullish()
           }),
-          z18.object({
-            type: z18.literal("file_path"),
-            file_id: z18.string(),
-            index: z18.number().nullish()
+          z19.object({
+            type: z19.literal("file_path"),
+            file_id: z19.string(),
+            index: z19.number().nullish()
           })
         ])
       }),
-      z18.object({
-        type: z18.literal("response.reasoning_summary_part.added"),
-        item_id: z18.string(),
-        summary_index: z18.number()
+      z19.object({
+        type: z19.literal("response.reasoning_summary_part.added"),
+        item_id: z19.string(),
+        summary_index: z19.number()
       }),
-      z18.object({
-        type: z18.literal("response.reasoning_summary_text.delta"),
-        item_id: z18.string(),
-        summary_index: z18.number(),
-        delta: z18.string()
+      z19.object({
+        type: z19.literal("response.reasoning_summary_text.delta"),
+        item_id: z19.string(),
+        summary_index: z19.number(),
+        delta: z19.string()
       }),
-      z18.object({
-        type: z18.literal("response.reasoning_summary_part.done"),
-        item_id: z18.string(),
-        summary_index: z18.number()
+      z19.object({
+        type: z19.literal("response.reasoning_summary_part.done"),
+        item_id: z19.string(),
+        summary_index: z19.number()
       }),
-      z18.object({
-        type: z18.literal("error"),
-        sequence_number: z18.number(),
-        error: z18.object({
-          type: z18.string(),
-          code: z18.string(),
-          message: z18.string(),
-          param: z18.string().nullish()
+      z19.object({
+        type: z19.literal("error"),
+        sequence_number: z19.number(),
+        error: z19.object({
+          type: z19.string(),
+          code: z19.string(),
+          message: z19.string(),
+          param: z19.string().nullish()
         })
       }),
-      z18.object({ type: z18.string() }).loose().transform((value) => ({
+      z19.object({ type: z19.string() }).loose().transform((value) => ({
         type: "unknown_chunk",
         message: value.type
       }))
@@ -3009,258 +3117,267 @@ var openaiResponsesChunkSchema = lazySchema16(
     ])
   )
 );
-var openaiResponsesResponseSchema = lazySchema16(
-  () => zodSchema16(
-    z18.object({
-      id: z18.string().optional(),
-      created_at: z18.number().optional(),
-      error: z18.object({
-        message: z18.string(),
-        type: z18.string(),
-        param: z18.string().nullish(),
-        code: z18.string()
+var openaiResponsesResponseSchema = lazySchema17(
+  () => zodSchema17(
+    z19.object({
+      id: z19.string().optional(),
+      created_at: z19.number().optional(),
+      error: z19.object({
+        message: z19.string(),
+        type: z19.string(),
+        param: z19.string().nullish(),
+        code: z19.string()
       }).nullish(),
-      model: z18.string().optional(),
-      output: z18.array(
-        z18.discriminatedUnion("type", [
-          z18.object({
-            type: z18.literal("message"),
-            role: z18.literal("assistant"),
-            id: z18.string(),
-            content: z18.array(
-              z18.object({
-                type: z18.literal("output_text"),
-                text: z18.string(),
-                logprobs: z18.array(
-                  z18.object({
-                    token: z18.string(),
-                    logprob: z18.number(),
-                    top_logprobs: z18.array(
-                      z18.object({
-                        token: z18.string(),
-                        logprob: z18.number()
+      model: z19.string().optional(),
+      output: z19.array(
+        z19.discriminatedUnion("type", [
+          z19.object({
+            type: z19.literal("message"),
+            role: z19.literal("assistant"),
+            id: z19.string(),
+            content: z19.array(
+              z19.object({
+                type: z19.literal("output_text"),
+                text: z19.string(),
+                logprobs: z19.array(
+                  z19.object({
+                    token: z19.string(),
+                    logprob: z19.number(),
+                    top_logprobs: z19.array(
+                      z19.object({
+                        token: z19.string(),
+                        logprob: z19.number()
                       })
                     )
                   })
                 ).nullish(),
-                annotations: z18.array(
-                  z18.discriminatedUnion("type", [
-                    z18.object({
-                      type: z18.literal("url_citation"),
-                      start_index: z18.number(),
-                      end_index: z18.number(),
-                      url: z18.string(),
-                      title: z18.string()
+                annotations: z19.array(
+                  z19.discriminatedUnion("type", [
+                    z19.object({
+                      type: z19.literal("url_citation"),
+                      start_index: z19.number(),
+                      end_index: z19.number(),
+                      url: z19.string(),
+                      title: z19.string()
                     }),
-                    z18.object({
-                      type: z18.literal("file_citation"),
-                      file_id: z18.string(),
-                      filename: z18.string().nullish(),
-                      index: z18.number().nullish(),
-                      start_index: z18.number().nullish(),
-                      end_index: z18.number().nullish(),
-                      quote: z18.string().nullish()
+                    z19.object({
+                      type: z19.literal("file_citation"),
+                      file_id: z19.string(),
+                      filename: z19.string().nullish(),
+                      index: z19.number().nullish(),
+                      start_index: z19.number().nullish(),
+                      end_index: z19.number().nullish(),
+                      quote: z19.string().nullish()
                     }),
-                    z18.object({
-                      type: z18.literal("container_file_citation"),
-                      container_id: z18.string(),
-                      file_id: z18.string(),
-                      filename: z18.string().nullish(),
-                      start_index: z18.number().nullish(),
-                      end_index: z18.number().nullish(),
-                      index: z18.number().nullish()
+                    z19.object({
+                      type: z19.literal("container_file_citation"),
+                      container_id: z19.string(),
+                      file_id: z19.string(),
+                      filename: z19.string().nullish(),
+                      start_index: z19.number().nullish(),
+                      end_index: z19.number().nullish(),
+                      index: z19.number().nullish()
                     }),
-                    z18.object({
-                      type: z18.literal("file_path"),
-                      file_id: z18.string(),
-                      index: z18.number().nullish()
+                    z19.object({
+                      type: z19.literal("file_path"),
+                      file_id: z19.string(),
+                      index: z19.number().nullish()
                     })
                   ])
                 )
               })
             )
           }),
-          z18.object({
-            type: z18.literal("web_search_call"),
-            id: z18.string(),
-            status: z18.string(),
-            action: z18.discriminatedUnion("type", [
-              z18.object({
-                type: z18.literal("search"),
-                query: z18.string().nullish(),
-                sources: z18.array(
-                  z18.discriminatedUnion("type", [
-                    z18.object({ type: z18.literal("url"), url: z18.string() }),
-                    z18.object({ type: z18.literal("api"), name: z18.string() })
+          z19.object({
+            type: z19.literal("web_search_call"),
+            id: z19.string(),
+            status: z19.string(),
+            action: z19.discriminatedUnion("type", [
+              z19.object({
+                type: z19.literal("search"),
+                query: z19.string().nullish(),
+                sources: z19.array(
+                  z19.discriminatedUnion("type", [
+                    z19.object({ type: z19.literal("url"), url: z19.string() }),
+                    z19.object({ type: z19.literal("api"), name: z19.string() })
                   ])
                 ).nullish()
               }),
-              z18.object({
-                type: z18.literal("open_page"),
-                url: z18.string().nullish()
+              z19.object({
+                type: z19.literal("open_page"),
+                url: z19.string().nullish()
               }),
-              z18.object({
-                type: z18.literal("find"),
-                url: z18.string().nullish(),
-                pattern: z18.string().nullish()
+              z19.object({
+                type: z19.literal("find"),
+                url: z19.string().nullish(),
+                pattern: z19.string().nullish()
               })
             ])
           }),
-          z18.object({
-            type: z18.literal("file_search_call"),
-            id: z18.string(),
-            queries: z18.array(z18.string()),
-            results: z18.array(
-              z18.object({
-                attributes: z18.record(
-                  z18.string(),
-                  z18.union([z18.string(), z18.number(), z18.boolean()])
+          z19.object({
+            type: z19.literal("file_search_call"),
+            id: z19.string(),
+            queries: z19.array(z19.string()),
+            results: z19.array(
+              z19.object({
+                attributes: z19.record(
+                  z19.string(),
+                  z19.union([z19.string(), z19.number(), z19.boolean()])
                 ),
-                file_id: z18.string(),
-                filename: z18.string(),
-                score: z18.number(),
-                text: z18.string()
+                file_id: z19.string(),
+                filename: z19.string(),
+                score: z19.number(),
+                text: z19.string()
               })
             ).nullish()
           }),
-          z18.object({
-            type: z18.literal("code_interpreter_call"),
-            id: z18.string(),
-            code: z18.string().nullable(),
-            container_id: z18.string(),
-            outputs: z18.array(
-              z18.discriminatedUnion("type", [
-                z18.object({ type: z18.literal("logs"), logs: z18.string() }),
-                z18.object({ type: z18.literal("image"), url: z18.string() })
+          z19.object({
+            type: z19.literal("code_interpreter_call"),
+            id: z19.string(),
+            code: z19.string().nullable(),
+            container_id: z19.string(),
+            outputs: z19.array(
+              z19.discriminatedUnion("type", [
+                z19.object({ type: z19.literal("logs"), logs: z19.string() }),
+                z19.object({ type: z19.literal("image"), url: z19.string() })
               ])
             ).nullable()
           }),
-          z18.object({
-            type: z18.literal("image_generation_call"),
-            id: z18.string(),
-            result: z18.string()
+          z19.object({
+            type: z19.literal("image_generation_call"),
+            id: z19.string(),
+            result: z19.string()
           }),
-          z18.object({
-            type: z18.literal("local_shell_call"),
-            id: z18.string(),
-            call_id: z18.string(),
-            action: z18.object({
-              type: z18.literal("exec"),
-              command: z18.array(z18.string()),
-              timeout_ms: z18.number().optional(),
-              user: z18.string().optional(),
-              working_directory: z18.string().optional(),
-              env: z18.record(z18.string(), z18.string()).optional()
+          z19.object({
+            type: z19.literal("local_shell_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            action: z19.object({
+              type: z19.literal("exec"),
+              command: z19.array(z19.string()),
+              timeout_ms: z19.number().optional(),
+              user: z19.string().optional(),
+              working_directory: z19.string().optional(),
+              env: z19.record(z19.string(), z19.string()).optional()
             })
           }),
-          z18.object({
-            type: z18.literal("function_call"),
-            call_id: z18.string(),
-            name: z18.string(),
-            arguments: z18.string(),
-            id: z18.string()
+          z19.object({
+            type: z19.literal("function_call"),
+            call_id: z19.string(),
+            name: z19.string(),
+            arguments: z19.string(),
+            id: z19.string()
           }),
-          z18.object({
-            type: z18.literal("computer_call"),
-            id: z18.string(),
-            status: z18.string().optional()
+          z19.object({
+            type: z19.literal("computer_call"),
+            id: z19.string(),
+            status: z19.string().optional()
           }),
-          z18.object({
-            type: z18.literal("reasoning"),
-            id: z18.string(),
-            encrypted_content: z18.string().nullish(),
-            summary: z18.array(
-              z18.object({
-                type: z18.literal("summary_text"),
-                text: z18.string()
+          z19.object({
+            type: z19.literal("reasoning"),
+            id: z19.string(),
+            encrypted_content: z19.string().nullish(),
+            summary: z19.array(
+              z19.object({
+                type: z19.literal("summary_text"),
+                text: z19.string()
               })
             )
           }),
-          z18.object({
-            type: z18.literal("mcp_call"),
-            id: z18.string(),
-            status: z18.string(),
-            arguments: z18.string(),
-            name: z18.string(),
-            server_label: z18.string(),
-            output: z18.string().nullish(),
-            error: z18.union([
-              z18.string(),
-              z18.object({
-                type: z18.string().optional(),
-                code: z18.union([z18.number(), z18.string()]).optional(),
-                message: z18.string().optional()
+          z19.object({
+            type: z19.literal("mcp_call"),
+            id: z19.string(),
+            status: z19.string(),
+            arguments: z19.string(),
+            name: z19.string(),
+            server_label: z19.string(),
+            output: z19.string().nullish(),
+            error: z19.union([
+              z19.string(),
+              z19.object({
+                type: z19.string().optional(),
+                code: z19.union([z19.number(), z19.string()]).optional(),
+                message: z19.string().optional()
               }).loose()
             ]).nullish()
           }),
-          z18.object({
-            type: z18.literal("mcp_list_tools"),
-            id: z18.string(),
-            server_label: z18.string(),
-            tools: z18.array(
-              z18.object({
-                name: z18.string(),
-                description: z18.string().optional(),
-                input_schema: z18.any(),
-                annotations: z18.record(z18.string(), z18.unknown()).optional()
+          z19.object({
+            type: z19.literal("mcp_list_tools"),
+            id: z19.string(),
+            server_label: z19.string(),
+            tools: z19.array(
+              z19.object({
+                name: z19.string(),
+                description: z19.string().optional(),
+                input_schema: z19.any(),
+                annotations: z19.record(z19.string(), z19.unknown()).optional()
               })
             ),
-            error: z18.union([
-              z18.string(),
-              z18.object({
-                type: z18.string().optional(),
-                code: z18.union([z18.number(), z18.string()]).optional(),
-                message: z18.string().optional()
+            error: z19.union([
+              z19.string(),
+              z19.object({
+                type: z19.string().optional(),
+                code: z19.union([z19.number(), z19.string()]).optional(),
+                message: z19.string().optional()
               }).loose()
             ]).optional()
           }),
-          z18.object({
-            type: z18.literal("mcp_approval_request"),
-            id: z18.string(),
-            server_label: z18.string(),
-            name: z18.string(),
-            arguments: z18.string(),
-            approval_request_id: z18.string()
+          z19.object({
+            type: z19.literal("mcp_approval_request"),
+            id: z19.string(),
+            server_label: z19.string(),
+            name: z19.string(),
+            arguments: z19.string(),
+            approval_request_id: z19.string()
           }),
-          z18.object({
-            type: z18.literal("apply_patch_call"),
-            id: z18.string(),
-            call_id: z18.string(),
-            status: z18.enum(["in_progress", "completed"]),
-            operation: z18.discriminatedUnion("type", [
-              z18.object({
-                type: z18.literal("create_file"),
-                path: z18.string(),
-                diff: z18.string()
+          z19.object({
+            type: z19.literal("apply_patch_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            status: z19.enum(["in_progress", "completed"]),
+            operation: z19.discriminatedUnion("type", [
+              z19.object({
+                type: z19.literal("create_file"),
+                path: z19.string(),
+                diff: z19.string()
               }),
-              z18.object({
-                type: z18.literal("delete_file"),
-                path: z18.string()
+              z19.object({
+                type: z19.literal("delete_file"),
+                path: z19.string()
               }),
-              z18.object({
-                type: z18.literal("update_file"),
-                path: z18.string(),
-                diff: z18.string()
+              z19.object({
+                type: z19.literal("update_file"),
+                path: z19.string(),
+                diff: z19.string()
               })
             ])
+          }),
+          z19.object({
+            type: z19.literal("shell_call"),
+            id: z19.string(),
+            call_id: z19.string(),
+            status: z19.enum(["in_progress", "completed", "incomplete"]),
+            action: z19.object({
+              commands: z19.array(z19.string())
+            })
           })
         ])
       ).optional(),
-      service_tier: z18.string().nullish(),
-      incomplete_details: z18.object({ reason: z18.string() }).nullish(),
-      usage: z18.object({
-        input_tokens: z18.number(),
-        input_tokens_details: z18.object({ cached_tokens: z18.number().nullish() }).nullish(),
-        output_tokens: z18.number(),
-        output_tokens_details: z18.object({ reasoning_tokens: z18.number().nullish() }).nullish()
+      service_tier: z19.string().nullish(),
+      incomplete_details: z19.object({ reason: z19.string() }).nullish(),
+      usage: z19.object({
+        input_tokens: z19.number(),
+        input_tokens_details: z19.object({ cached_tokens: z19.number().nullish() }).nullish(),
+        output_tokens: z19.number(),
+        output_tokens_details: z19.object({ reasoning_tokens: z19.number().nullish() }).nullish()
       }).optional()
     })
   )
 );
 
 // src/responses/openai-responses-options.ts
-import { lazySchema as lazySchema17, zodSchema as zodSchema17 } from "@ai-sdk/provider-utils";
-import { z as z19 } from "zod/v4";
+import { lazySchema as lazySchema18, zodSchema as zodSchema18 } from "@ai-sdk/provider-utils";
+import { z as z20 } from "zod/v4";
 var TOP_LOGPROBS_MAX = 20;
 var openaiResponsesReasoningModelIds = [
   "o1",
@@ -3327,9 +3444,9 @@ var openaiResponsesModelIds = [
   "gpt-5-chat-latest",
   ...openaiResponsesReasoningModelIds
 ];
-var openaiResponsesProviderOptionsSchema = lazySchema17(
-  () => zodSchema17(
-    z19.object({
+var openaiResponsesProviderOptionsSchema = lazySchema18(
+  () => zodSchema18(
+    z20.object({
       /**
        * The ID of the OpenAI Conversation to continue.
        * You must create a conversation first via the OpenAI API.
@@ -3337,13 +3454,13 @@ var openaiResponsesProviderOptionsSchema = lazySchema17(
        * Defaults to `undefined`.
        * @see https://platform.openai.com/docs/api-reference/conversations/create
        */
-      conversation: z19.string().nullish(),
+      conversation: z20.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', 'message.output_text.logprobs'.
        */
-      include: z19.array(
-        z19.enum([
+      include: z20.array(
+        z20.enum([
           "reasoning.encrypted_content",
           // handled internally by default, only needed for unknown reasoning models
           "file_search_call.results",
@@ -3355,7 +3472,7 @@ var openaiResponsesProviderOptionsSchema = lazySchema17(
        * They can be used to change the system or developer message when continuing a conversation using the `previousResponseId` option.
        * Defaults to `undefined`.
        */
-      instructions: z19.string().nullish(),
+      instructions: z20.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
@@ -3370,30 +3487,30 @@ var openaiResponsesProviderOptionsSchema = lazySchema17(
        * @see https://platform.openai.com/docs/api-reference/responses/create
        * @see https://cookbook.openai.com/examples/using_logprobs
        */
-      logprobs: z19.union([z19.boolean(), z19.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
+      logprobs: z20.union([z20.boolean(), z20.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: z19.number().nullish(),
+      maxToolCalls: z20.number().nullish(),
       /**
        * Additional metadata to store with the generation.
        */
-      metadata: z19.any().nullish(),
+      metadata: z20.any().nullish(),
       /**
        * Whether to use parallel tool calls. Defaults to `true`.
        */
-      parallelToolCalls: z19.boolean().nullish(),
+      parallelToolCalls: z20.boolean().nullish(),
       /**
        * The ID of the previous response. You can use it to continue a conversation.
        * Defaults to `undefined`.
        */
-      previousResponseId: z19.string().nullish(),
+      previousResponseId: z20.string().nullish(),
       /**
        * Sets a cache key to tie this prompt to cached prefixes for better caching performance.
        */
-      promptCacheKey: z19.string().nullish(),
+      promptCacheKey: z20.string().nullish(),
       /**
        * The retention policy for the prompt cache.
        * - 'in_memory': Default. Standard prompt caching behavior.
@@ -3402,7 +3519,7 @@ var openaiResponsesProviderOptionsSchema = lazySchema17(
        *
        * @default 'in_memory'
        */
-      promptCacheRetention: z19.enum(["in_memory", "24h"]).nullish(),
+      promptCacheRetention: z20.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.
@@ -3412,17 +3529,17 @@ var openaiResponsesProviderOptionsSchema = lazySchema17(
        * models. Setting `reasoningEffort` to 'none' with other models will result in
        * an error.
        */
-      reasoningEffort: z19.string().nullish(),
+      reasoningEffort: z20.string().nullish(),
       /**
        * Controls reasoning summary output from the model.
        * Set to "auto" to automatically receive the richest level available,
        * or "detailed" for comprehensive summaries.
        */
-      reasoningSummary: z19.string().nullish(),
+      reasoningSummary: z20.string().nullish(),
       /**
        * The identifier for safety monitoring and tracking.
        */
-      safetyIdentifier: z19.string().nullish(),
+      safetyIdentifier: z20.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).
@@ -3430,34 +3547,34 @@ var openaiResponsesProviderOptionsSchema = lazySchema17(
        *
        * Defaults to 'auto'.
        */
-      serviceTier: z19.enum(["auto", "flex", "priority", "default"]).nullish(),
+      serviceTier: z20.enum(["auto", "flex", "priority", "default"]).nullish(),
       /**
        * Whether to store the generation. Defaults to `true`.
        */
-      store: z19.boolean().nullish(),
+      store: z20.boolean().nullish(),
       /**
        * Whether to use strict JSON schema validation.
        * Defaults to `true`.
        */
-      strictJsonSchema: z19.boolean().nullish(),
+      strictJsonSchema: z20.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: z19.enum(["low", "medium", "high"]).nullish(),
+      textVerbosity: z20.enum(["low", "medium", "high"]).nullish(),
       /**
        * Controls output truncation. 'auto' (default) performs truncation automatically;
        * 'disabled' turns truncation off.
        */
-      truncation: z19.enum(["auto", "disabled"]).nullish(),
+      truncation: z20.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: z19.string().nullish()
+      user: z20.string().nullish()
     })
   )
 );
@@ -3513,6 +3630,12 @@ async function prepareResponsesTools({
             });
             break;
           }
+          case "openai.shell": {
+            openaiTools2.push({
+              type: "shell"
+            });
+            break;
+          }
           case "openai.apply_patch": {
             openaiTools2.push({
               type: "apply_patch"
@@ -3701,6 +3824,7 @@ var OpenAIResponsesLanguageModel = class {
         "openai.file_search": "file_search",
         "openai.image_generation": "image_generation",
         "openai.local_shell": "local_shell",
+        "openai.shell": "shell",
         "openai.web_search": "web_search",
         "openai.web_search_preview": "web_search_preview",
         "openai.mcp": "mcp",
@@ -3714,6 +3838,7 @@ var OpenAIResponsesLanguageModel = class {
       fileIdPrefixes: this.config.fileIdPrefixes,
       store: (_a = openaiOptions == null ? void 0 : openaiOptions.store) != null ? _a : true,
       hasLocalShellTool: hasOpenAITool("openai.local_shell"),
+      hasShellTool: hasOpenAITool("openai.shell"),
       hasApplyPatchTool: hasOpenAITool("openai.apply_patch")
     });
     warnings.push(...inputWarnings);
@@ -3961,6 +4086,24 @@ var OpenAIResponsesLanguageModel = class {
           });
           break;
         }
+        case "shell_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.call_id,
+            toolName: toolNameMapping.toCustomToolName("shell"),
+            input: JSON.stringify({
+              action: {
+                commands: part.action.commands
+              }
+            }),
+            providerMetadata: {
+              [providerKey]: {
+                itemId: part.id
+              }
+            }
+          });
+          break;
+        }
         case "message": {
           for (const contentPart of part.content) {
             if (((_c = (_b = options.providerOptions) == null ? void 0 : _b.openai) == null ? void 0 : _c.logprobs) && contentPart.logprobs) {
@@ -4439,6 +4582,11 @@ var OpenAIResponsesLanguageModel = class {
                     }
                   });
                 }
+              } else if (value.item.type === "shell_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: toolNameMapping.toCustomToolName("shell"),
+                  toolCallId: value.item.call_id
+                };
               } else if (value.item.type === "message") {
                 ongoingAnnotations.splice(0, ongoingAnnotations.length);
                 controller.enqueue({
@@ -4654,6 +4802,21 @@ var OpenAIResponsesLanguageModel = class {
                     [providerKey]: { itemId: value.item.id }
                   }
                 });
+              } else if (value.item.type === "shell_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.call_id,
+                  toolName: toolNameMapping.toCustomToolName("shell"),
+                  input: JSON.stringify({
+                    action: {
+                      commands: value.item.action.commands
+                    }
+                  }),
+                  providerMetadata: {
+                    [providerKey]: { itemId: value.item.id }
+                  }
+                });
               } else if (value.item.type === "reasoning") {
                 const activeReasoningPart = activeReasoning[value.item.id];
                 const summaryPartIndices = Object.entries(
@@ -4971,13 +5134,13 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/speech/openai-speech-options.ts
-import { lazySchema as lazySchema18, zodSchema as zodSchema18 } from "@ai-sdk/provider-utils";
-import { z as z20 } from "zod/v4";
-var openaiSpeechProviderOptionsSchema = lazySchema18(
-  () => zodSchema18(
-    z20.object({
-      instructions: z20.string().nullish(),
-      speed: z20.number().min(0.25).max(4).default(1).nullish()
+import { lazySchema as lazySchema19, zodSchema as zodSchema19 } from "@ai-sdk/provider-utils";
+import { z as z21 } from "zod/v4";
+var openaiSpeechProviderOptionsSchema = lazySchema19(
+  () => zodSchema19(
+    z21.object({
+      instructions: z21.string().nullish(),
+      speed: z21.number().min(0.25).max(4).default(1).nullish()
     })
   )
 );
@@ -5094,33 +5257,33 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/transcription/openai-transcription-api.ts
-import { lazySchema as lazySchema19, zodSchema as zodSchema19 } from "@ai-sdk/provider-utils";
-import { z as z21 } from "zod/v4";
-var openaiTranscriptionResponseSchema = lazySchema19(
-  () => zodSchema19(
-    z21.object({
-      text: z21.string(),
-      language: z21.string().nullish(),
-      duration: z21.number().nullish(),
-      words: z21.array(
-        z21.object({
-          word: z21.string(),
-          start: z21.number(),
-          end: z21.number()
+import { lazySchema as lazySchema20, zodSchema as zodSchema20 } from "@ai-sdk/provider-utils";
+import { z as z22 } from "zod/v4";
+var openaiTranscriptionResponseSchema = lazySchema20(
+  () => zodSchema20(
+    z22.object({
+      text: z22.string(),
+      language: z22.string().nullish(),
+      duration: z22.number().nullish(),
+      words: z22.array(
+        z22.object({
+          word: z22.string(),
+          start: z22.number(),
+          end: z22.number()
         })
       ).nullish(),
-      segments: z21.array(
-        z21.object({
-          id: z21.number(),
-          seek: z21.number(),
-          start: z21.number(),
-          end: z21.number(),
-          text: z21.string(),
-          tokens: z21.array(z21.number()),
-          temperature: z21.number(),
-          avg_logprob: z21.number(),
-          compression_ratio: z21.number(),
-          no_speech_prob: z21.number()
+      segments: z22.array(
+        z22.object({
+          id: z22.number(),
+          seek: z22.number(),
+          start: z22.number(),
+          end: z22.number(),
+          text: z22.string(),
+          tokens: z22.array(z22.number()),
+          temperature: z22.number(),
+          avg_logprob: z22.number(),
+          compression_ratio: z22.number(),
+          no_speech_prob: z22.number()
         })
       ).nullish()
     })
@@ -5128,33 +5291,33 @@ var openaiTranscriptionResponseSchema = lazySchema19(
 );
 
 // src/transcription/openai-transcription-options.ts
-import { lazySchema as lazySchema20, zodSchema as zodSchema20 } from "@ai-sdk/provider-utils";
-import { z as z22 } from "zod/v4";
-var openAITranscriptionProviderOptions = lazySchema20(
-  () => zodSchema20(
-    z22.object({
+import { lazySchema as lazySchema21, zodSchema as zodSchema21 } from "@ai-sdk/provider-utils";
+import { z as z23 } from "zod/v4";
+var openAITranscriptionProviderOptions = lazySchema21(
+  () => zodSchema21(
+    z23.object({
       /**
        * Additional information to include in the transcription response.
        */
-      include: z22.array(z22.string()).optional(),
+      include: z23.array(z23.string()).optional(),
       /**
        * The language of the input audio in ISO-639-1 format.
        */
-      language: z22.string().optional(),
+      language: z23.string().optional(),
       /**
        * An optional text to guide the model's style or continue a previous audio segment.
        */
-      prompt: z22.string().optional(),
+      prompt: z23.string().optional(),
       /**
        * The sampling temperature, between 0 and 1.
        * @default 0
        */
-      temperature: z22.number().min(0).max(1).default(0).optional(),
+      temperature: z23.number().min(0).max(1).default(0).optional(),
       /**
        * The timestamp granularities to populate for this transcription.
        * @default ['segment']
        */
-      timestampGranularities: z22.array(z22.enum(["word", "segment"])).default(["segment"]).optional()
+      timestampGranularities: z23.array(z23.enum(["word", "segment"])).default(["segment"]).optional()
     })
   )
 );
@@ -5327,7 +5490,7 @@ var OpenAITranscriptionModel = class {
 };
 
 // src/version.ts
-var VERSION = true ? "3.0.0-beta.80" : "0.0.0-test";
+var VERSION = true ? "3.0.0-beta.82" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {