@zenning/openai 1.4.2 → 1.4.4

package/internal/dist/index.js

@@ -1898,7 +1898,7 @@ var OpenAISpeechModel = class {
 
 // src/responses/openai-responses-language-model.ts
 var import_provider_utils10 = require("@ai-sdk/provider-utils");
-var import_zod8 = require("zod");
+var import_zod12 = require("zod");
 
 // src/responses/convert-to-openai-responses-messages.ts
 var import_provider7 = require("@ai-sdk/provider");
@@ -2042,6 +2042,71 @@ function mapOpenAIResponseFinishReason({
 
 // src/responses/openai-responses-prepare-tools.ts
 var import_provider8 = require("@ai-sdk/provider");
+
+// src/tool/code-interpreter.ts
+var import_zod8 = require("zod");
+var codeInterpreterArgsSchema = import_zod8.z.object({
+  container: import_zod8.z.union([
+    import_zod8.z.string(),
+    import_zod8.z.object({
+      fileIds: import_zod8.z.array(import_zod8.z.string()).optional()
+    })
+  ]).optional()
+});
+
+// src/tool/file-search.ts
+var import_zod9 = require("zod");
+var comparisonFilterSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  type: import_zod9.z.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+  value: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number(), import_zod9.z.boolean()])
+});
+var compoundFilterSchema = import_zod9.z.object({
+  type: import_zod9.z.enum(["and", "or"]),
+  filters: import_zod9.z.array(
+    import_zod9.z.union([comparisonFilterSchema, import_zod9.z.lazy(() => compoundFilterSchema)])
+  )
+});
+var filtersSchema = import_zod9.z.union([comparisonFilterSchema, compoundFilterSchema]);
+var fileSearchArgsSchema = import_zod9.z.object({
+  vectorStoreIds: import_zod9.z.array(import_zod9.z.string()).optional(),
+  maxNumResults: import_zod9.z.number().optional(),
+  ranking: import_zod9.z.object({
+    ranker: import_zod9.z.enum(["auto", "default-2024-08-21"]).optional()
+  }).optional(),
+  filters: filtersSchema.optional()
+});
+
+// src/tool/web-search.ts
+var import_zod10 = require("zod");
+var webSearchArgsSchema = import_zod10.z.object({
+  filters: import_zod10.z.object({
+    allowedDomains: import_zod10.z.array(import_zod10.z.string()).optional()
+  }).optional(),
+  searchContextSize: import_zod10.z.enum(["low", "medium", "high"]).optional(),
+  userLocation: import_zod10.z.object({
+    type: import_zod10.z.literal("approximate"),
+    country: import_zod10.z.string().optional(),
+    city: import_zod10.z.string().optional(),
+    region: import_zod10.z.string().optional(),
+    timezone: import_zod10.z.string().optional()
+  }).optional()
+});
+
+// src/tool/web-search-preview.ts
+var import_zod11 = require("zod");
+var webSearchPreviewArgsSchema = import_zod11.z.object({
+  searchContextSize: import_zod11.z.enum(["low", "medium", "high"]).optional(),
+  userLocation: import_zod11.z.object({
+    type: import_zod11.z.literal("approximate"),
+    country: import_zod11.z.string().optional(),
+    city: import_zod11.z.string().optional(),
+    region: import_zod11.z.string().optional(),
+    timezone: import_zod11.z.string().optional()
+  }).optional()
+});
+
+// src/responses/openai-responses-prepare-tools.ts
 function prepareResponsesTools({
   mode,
   strict
@@ -2067,31 +2132,48 @@ function prepareResponsesTools({
         break;
       case "provider-defined":
         switch (tool.id) {
-          case "openai.file_search":
+          case "openai.file_search": {
+            const args = fileSearchArgsSchema.parse(tool.args);
             openaiTools.push({
               type: "file_search",
-              vector_store_ids: tool.args.vectorStoreIds,
-              max_num_results: tool.args.maxNumResults,
-              ranking: tool.args.ranking,
-              filters: tool.args.filters
+              vector_store_ids: args.vectorStoreIds,
+              max_num_results: args.maxNumResults,
+              ranking_options: args.ranking ? { ranker: args.ranking.ranker } : void 0,
+              filters: args.filters
             });
             break;
-          case "openai.web_search_preview":
+          }
+          case "openai.web_search_preview": {
+            const args = webSearchPreviewArgsSchema.parse(tool.args);
             openaiTools.push({
               type: "web_search_preview",
-              search_context_size: tool.args.searchContextSize,
-              user_location: tool.args.userLocation
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation
+            });
+            break;
+          }
+          case "openai.web_search": {
+            const args = webSearchArgsSchema.parse(tool.args);
+            openaiTools.push({
+              type: "web_search",
+              filters: args.filters != null ? { allowed_domains: args.filters.allowedDomains } : void 0,
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation
             });
             break;
-          case "openai.code_interpreter":
+          }
+          case "openai.code_interpreter": {
+            const args = codeInterpreterArgsSchema.parse(tool.args);
             openaiTools.push({
               type: "code_interpreter",
-              container: tool.args.container
+              container: args.container == null ? { type: "auto", file_ids: void 0 } : typeof args.container === "string" ? args.container : { type: "auto", file_ids: args.container.fileIds }
             });
             break;
-          default:
+          }
+          default: {
             toolWarnings.push({ type: "unsupported-tool", tool });
             break;
+          }
         }
         break;
       default:
@@ -2108,34 +2190,12 @@ function prepareResponsesTools({
     case "none":
     case "required":
       return { tools: openaiTools, tool_choice: type, toolWarnings };
-    case "tool": {
-      if (toolChoice.toolName === "web_search_preview") {
-        return {
-          tools: openaiTools,
-          tool_choice: {
-            type: "web_search_preview"
-          },
-          toolWarnings
-        };
-      }
-      if (toolChoice.toolName === "code_interpreter") {
-        return {
-          tools: openaiTools,
-          tool_choice: {
-            type: "code_interpreter"
-          },
-          toolWarnings
-        };
-      }
+    case "tool":
       return {
         tools: openaiTools,
-        tool_choice: {
-          type: "function",
-          name: toolChoice.toolName
-        },
+        tool_choice: toolChoice.toolName === "code_interpreter" || toolChoice.toolName === "file_search" || toolChoice.toolName === "web_search_preview" || toolChoice.toolName === "web_search" ? { type: toolChoice.toolName } : { type: "function", name: toolChoice.toolName },
         toolWarnings
       };
-    }
     default: {
       const _exhaustiveCheck = type;
       throw new import_provider8.UnsupportedFunctionalityError({
@@ -2349,55 +2409,107 @@ var OpenAIResponsesLanguageModel = class {
       body,
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: (0, import_provider_utils10.createJsonResponseHandler)(
-        import_zod8.z.object({
-          id: import_zod8.z.string(),
-          created_at: import_zod8.z.number(),
-          model: import_zod8.z.string(),
-          output: import_zod8.z.array(
-            import_zod8.z.discriminatedUnion("type", [
-              import_zod8.z.object({
-                type: import_zod8.z.literal("message"),
-                role: import_zod8.z.literal("assistant"),
-                content: import_zod8.z.array(
-                  import_zod8.z.object({
-                    type: import_zod8.z.literal("output_text"),
-                    text: import_zod8.z.string(),
-                    annotations: import_zod8.z.array(
-                      import_zod8.z.object({
-                        type: import_zod8.z.literal("url_citation"),
-                        start_index: import_zod8.z.number(),
-                        end_index: import_zod8.z.number(),
-                        url: import_zod8.z.string(),
-                        title: import_zod8.z.string()
-                      })
+        import_zod12.z.object({
+          id: import_zod12.z.string(),
+          created_at: import_zod12.z.number(),
+          model: import_zod12.z.string(),
+          output: import_zod12.z.array(
+            import_zod12.z.discriminatedUnion("type", [
+              import_zod12.z.object({
+                type: import_zod12.z.literal("message"),
+                role: import_zod12.z.literal("assistant"),
+                content: import_zod12.z.array(
+                  import_zod12.z.object({
+                    type: import_zod12.z.literal("output_text"),
+                    text: import_zod12.z.string(),
+                    annotations: import_zod12.z.array(
+                      import_zod12.z.discriminatedUnion("type", [
+                        import_zod12.z.object({
+                          type: import_zod12.z.literal("url_citation"),
+                          start_index: import_zod12.z.number(),
+                          end_index: import_zod12.z.number(),
+                          url: import_zod12.z.string(),
+                          title: import_zod12.z.string()
+                        }),
+                        import_zod12.z.object({
+                          type: import_zod12.z.literal("file_citation"),
+                          file_id: import_zod12.z.string(),
+                          filename: import_zod12.z.string().nullish(),
+                          index: import_zod12.z.number().nullish(),
+                          start_index: import_zod12.z.number().nullish(),
+                          end_index: import_zod12.z.number().nullish(),
+                          quote: import_zod12.z.string().nullish()
+                        }),
+                        import_zod12.z.object({
+                          type: import_zod12.z.literal("container_file_citation")
+                        })
+                      ])
                     )
                   })
                 )
               }),
-              import_zod8.z.object({
-                type: import_zod8.z.literal("function_call"),
-                call_id: import_zod8.z.string(),
-                name: import_zod8.z.string(),
-                arguments: import_zod8.z.string()
+              import_zod12.z.object({
+                type: import_zod12.z.literal("code_interpreter_call")
               }),
-              import_zod8.z.object({
-                type: import_zod8.z.literal("web_search_call")
+              import_zod12.z.object({
+                type: import_zod12.z.literal("function_call"),
+                call_id: import_zod12.z.string(),
+                name: import_zod12.z.string(),
+                arguments: import_zod12.z.string()
               }),
-              import_zod8.z.object({
-                type: import_zod8.z.literal("computer_call")
+              import_zod12.z.object({
+                type: import_zod12.z.literal("web_search_call"),
+                id: import_zod12.z.string(),
+                status: import_zod12.z.string().optional(),
+                action: import_zod12.z.discriminatedUnion("type", [
+                  import_zod12.z.object({
+                    type: import_zod12.z.literal("search"),
+                    query: import_zod12.z.string().nullish()
+                  }),
+                  import_zod12.z.object({
+                    type: import_zod12.z.literal("open_page"),
+                    url: import_zod12.z.string()
+                  }),
+                  import_zod12.z.object({
+                    type: import_zod12.z.literal("find"),
+                    url: import_zod12.z.string(),
+                    pattern: import_zod12.z.string()
+                  })
+                ]).nullish()
+              }),
+              import_zod12.z.object({
+                type: import_zod12.z.literal("computer_call"),
+                id: import_zod12.z.string(),
+                status: import_zod12.z.string().optional()
+              }),
+              import_zod12.z.object({
+                type: import_zod12.z.literal("file_search_call"),
+                id: import_zod12.z.string(),
+                status: import_zod12.z.string().optional(),
+                queries: import_zod12.z.array(import_zod12.z.string()).nullish(),
+                results: import_zod12.z.array(
+                  import_zod12.z.object({
+                    attributes: import_zod12.z.object({
+                      file_id: import_zod12.z.string(),
+                      filename: import_zod12.z.string(),
+                      score: import_zod12.z.number(),
+                      text: import_zod12.z.string()
+                    })
+                  })
+                ).nullish()
               }),
-              import_zod8.z.object({
-                type: import_zod8.z.literal("reasoning"),
-                summary: import_zod8.z.array(
-                  import_zod8.z.object({
-                    type: import_zod8.z.literal("summary_text"),
-                    text: import_zod8.z.string()
+              import_zod12.z.object({
+                type: import_zod12.z.literal("reasoning"),
+                summary: import_zod12.z.array(
+                  import_zod12.z.object({
+                    type: import_zod12.z.literal("summary_text"),
+                    text: import_zod12.z.string()
                   })
                 )
               })
             ])
           ),
-          incomplete_details: import_zod8.z.object({ reason: import_zod8.z.string() }).nullable(),
+          incomplete_details: import_zod12.z.object({ reason: import_zod12.z.string() }).nullable(),
           usage: usageSchema
         })
       ),
@@ -2405,12 +2517,38 @@ var OpenAIResponsesLanguageModel = class {
       fetch: this.config.fetch
     });
     const outputTextElements = response.output.filter((output) => output.type === "message").flatMap((output) => output.content).filter((content) => content.type === "output_text");
-    const toolCalls = response.output.filter((output) => output.type === "function_call").map((output) => ({
-      toolCallType: "function",
-      toolCallId: output.call_id,
-      toolName: output.name,
-      args: output.arguments
-    }));
+    const toolCalls = [];
+    for (const output of response.output) {
+      if (output.type === "function_call") {
+        toolCalls.push({
+          toolCallType: "function",
+          toolCallId: output.call_id,
+          toolName: output.name,
+          args: output.arguments
+        });
+      } else if (output.type === "web_search_call") {
+        toolCalls.push({
+          toolCallType: "function",
+          toolCallId: output.id,
+          toolName: "web_search_preview",
+          args: JSON.stringify({ action: output.action })
+        });
+      } else if (output.type === "computer_call") {
+        toolCalls.push({
+          toolCallType: "function",
+          toolCallId: output.id,
+          toolName: "computer_use",
+          args: ""
+        });
+      } else if (output.type === "file_search_call") {
+        toolCalls.push({
+          toolCallType: "function",
+          toolCallId: output.id,
+          toolName: "file_search",
+          args: ""
+        });
+      }
+    }
     const reasoningSummary = (_b = (_a = response.output.find((item) => item.type === "reasoning")) == null ? void 0 : _a.summary) != null ? _b : null;
     console.log(JSON.stringify({
       msg: "ai-sdk: content annotations",
@@ -2420,13 +2558,29 @@ var OpenAIResponsesLanguageModel = class {
       text: outputTextElements.map((content) => content.text).join("\n"),
       sources: outputTextElements.flatMap(
         (content) => content.annotations.map((annotation) => {
-          var _a2, _b2, _c2;
-          return {
-            sourceType: "url",
-            id: (_c2 = (_b2 = (_a2 = this.config).generateId) == null ? void 0 : _b2.call(_a2)) != null ? _c2 : (0, import_provider_utils10.generateId)(),
-            url: annotation.url,
-            title: annotation.title
-          };
+          var _a2, _b2, _c2, _d2, _e2, _f2, _g2, _h, _i, _j, _k;
+          if (annotation.type === "url_citation") {
+            return {
+              sourceType: "url",
+              id: (_c2 = (_b2 = (_a2 = this.config).generateId) == null ? void 0 : _b2.call(_a2)) != null ? _c2 : (0, import_provider_utils10.generateId)(),
+              url: annotation.url,
+              title: annotation.title
+            };
+          } else if (annotation.type === "file_citation") {
+            return {
+              sourceType: "url",
+              id: (_f2 = (_e2 = (_d2 = this.config).generateId) == null ? void 0 : _e2.call(_d2)) != null ? _f2 : (0, import_provider_utils10.generateId)(),
+              url: `file://${annotation.file_id}`,
+              title: (_h = (_g2 = annotation.quote) != null ? _g2 : annotation.filename) != null ? _h : "Document"
+            };
+          } else {
+            return {
+              sourceType: "url",
+              id: (_k = (_j = (_i = this.config).generateId) == null ? void 0 : _j.call(_i)) != null ? _k : (0, import_provider_utils10.generateId)(),
+              url: "",
+              title: "Unknown Source"
+            };
+          }
         })
       ),
       finishReason: mapOpenAIResponseFinishReason({
@@ -2500,7 +2654,7 @@ var OpenAIResponsesLanguageModel = class {
       stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -2520,6 +2674,42 @@ var OpenAIResponsesLanguageModel = class {
                   toolName: value.item.name,
                   argsTextDelta: value.item.arguments
                 });
+              } else if (value.item.type === "web_search_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: "web_search_preview",
+                  toolCallId: value.item.id
+                };
+                controller.enqueue({
+                  type: "tool-call-delta",
+                  toolCallType: "function",
+                  toolCallId: value.item.id,
+                  toolName: "web_search_preview",
+                  argsTextDelta: JSON.stringify({ action: value.item.action })
+                });
+              } else if (value.item.type === "computer_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: "computer_use",
+                  toolCallId: value.item.id
+                };
+                controller.enqueue({
+                  type: "tool-call-delta",
+                  toolCallType: "function",
+                  toolCallId: value.item.id,
+                  toolName: "computer_use",
+                  argsTextDelta: ""
+                });
+              } else if (value.item.type === "file_search_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: "file_search",
+                  toolCallId: value.item.id
+                };
+                controller.enqueue({
+                  type: "tool-call-delta",
+                  toolCallType: "function",
+                  toolCallId: value.item.id,
+                  toolName: "file_search",
+                  argsTextDelta: ""
+                });
               }
             } else if (isResponseFunctionCallArgumentsDeltaChunk(value)) {
               const toolCall = ongoingToolCalls[value.output_index];
@@ -2550,16 +2740,51 @@ var OpenAIResponsesLanguageModel = class {
                 type: "reasoning",
                 textDelta: value.delta
               });
-            } else if (isResponseOutputItemDoneChunk(value) && value.item.type === "function_call") {
-              ongoingToolCalls[value.output_index] = void 0;
-              hasToolCalls = true;
-              controller.enqueue({
-                type: "tool-call",
-                toolCallType: "function",
-                toolCallId: value.item.call_id,
-                toolName: value.item.name,
-                args: value.item.arguments
-              });
+            } else if (isResponseOutputItemDoneChunk(value)) {
+              if (value.item.type === "function_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                hasToolCalls = true;
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallType: "function",
+                  toolCallId: value.item.call_id,
+                  toolName: value.item.name,
+                  args: value.item.arguments
+                });
+              } else if (value.item.type === "web_search_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                hasToolCalls = true;
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallType: "function",
+                  toolCallId: value.item.id,
+                  toolName: "web_search_preview",
+                  args: JSON.stringify({ action: value.item.action })
+                });
+              } else if (value.item.type === "computer_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                hasToolCalls = true;
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallType: "function",
+                  toolCallId: value.item.id,
+                  toolName: "computer_use",
+                  args: ""
+                });
+              } else if (value.item.type === "file_search_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                hasToolCalls = true;
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallType: "function",
+                  toolCallId: value.item.id,
+                  toolName: "file_search",
+                  args: JSON.stringify({
+                    queries: value.item.queries,
+                    results: value.item.results
+                  })
+                });
+              }
             } else if (isResponseFinishedChunk(value)) {
               finishReason = mapOpenAIResponseFinishReason({
                 finishReason: (_a = value.response.incomplete_details) == null ? void 0 : _a.reason,
@@ -2574,15 +2799,27 @@ var OpenAIResponsesLanguageModel = class {
                 msg: "ai-sdk: source (stream)",
                 source: value.annotation
               }));
-              controller.enqueue({
-                type: "source",
-                source: {
-                  sourceType: "url",
-                  id: (_h = (_g = (_f = self.config).generateId) == null ? void 0 : _g.call(_f)) != null ? _h : (0, import_provider_utils10.generateId)(),
-                  url: value.annotation.url,
-                  title: value.annotation.title
-                }
-              });
+              if (value.annotation.type === "url_citation") {
+                controller.enqueue({
+                  type: "source",
+                  source: {
+                    sourceType: "url",
+                    id: (_h = (_g = (_f = self.config).generateId) == null ? void 0 : _g.call(_f)) != null ? _h : (0, import_provider_utils10.generateId)(),
+                    url: value.annotation.url,
+                    title: value.annotation.title
+                  }
+                });
+              } else if (value.annotation.type === "file_citation") {
+                controller.enqueue({
+                  type: "source",
+                  source: {
+                    sourceType: "url",
+                    id: (_k = (_j = (_i = self.config).generateId) == null ? void 0 : _j.call(_i)) != null ? _k : (0, import_provider_utils10.generateId)(),
+                    url: `file://${value.annotation.file_id}`,
+                    title: (_m = (_l = value.annotation.quote) != null ? _l : value.annotation.filename) != null ? _m : "Document"
+                  }
+                });
+              }
             }
           },
           flush(controller) {
@@ -2613,86 +2850,168 @@ var OpenAIResponsesLanguageModel = class {
     };
   }
 };
-var usageSchema = import_zod8.z.object({
-  input_tokens: import_zod8.z.number(),
-  input_tokens_details: import_zod8.z.object({ cached_tokens: import_zod8.z.number().nullish() }).nullish(),
-  output_tokens: import_zod8.z.number(),
-  output_tokens_details: import_zod8.z.object({ reasoning_tokens: import_zod8.z.number().nullish() }).nullish()
+var usageSchema = import_zod12.z.object({
+  input_tokens: import_zod12.z.number(),
+  input_tokens_details: import_zod12.z.object({ cached_tokens: import_zod12.z.number().nullish() }).nullish(),
+  output_tokens: import_zod12.z.number(),
+  output_tokens_details: import_zod12.z.object({ reasoning_tokens: import_zod12.z.number().nullish() }).nullish()
 });
-var textDeltaChunkSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("response.output_text.delta"),
-  delta: import_zod8.z.string()
+var textDeltaChunkSchema = import_zod12.z.object({
+  type: import_zod12.z.literal("response.output_text.delta"),
+  delta: import_zod12.z.string()
 });
-var responseFinishedChunkSchema = import_zod8.z.object({
-  type: import_zod8.z.enum(["response.completed", "response.incomplete"]),
-  response: import_zod8.z.object({
-    incomplete_details: import_zod8.z.object({ reason: import_zod8.z.string() }).nullish(),
+var responseFinishedChunkSchema = import_zod12.z.object({
+  type: import_zod12.z.enum(["response.completed", "response.incomplete"]),
+  response: import_zod12.z.object({
+    incomplete_details: import_zod12.z.object({ reason: import_zod12.z.string() }).nullish(),
     usage: usageSchema
   })
 });
-var responseCreatedChunkSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("response.created"),
-  response: import_zod8.z.object({
-    id: import_zod8.z.string(),
-    created_at: import_zod8.z.number(),
-    model: import_zod8.z.string()
+var responseCreatedChunkSchema = import_zod12.z.object({
+  type: import_zod12.z.literal("response.created"),
+  response: import_zod12.z.object({
+    id: import_zod12.z.string(),
+    created_at: import_zod12.z.number(),
+    model: import_zod12.z.string()
   })
 });
-var responseOutputItemDoneSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("response.output_item.done"),
-  output_index: import_zod8.z.number(),
-  item: import_zod8.z.discriminatedUnion("type", [
-    import_zod8.z.object({
-      type: import_zod8.z.literal("message")
+var responseOutputItemDoneSchema = import_zod12.z.object({
+  type: import_zod12.z.literal("response.output_item.done"),
+  output_index: import_zod12.z.number(),
+  item: import_zod12.z.discriminatedUnion("type", [
+    import_zod12.z.object({
+      type: import_zod12.z.literal("message")
     }),
-    import_zod8.z.object({
-      type: import_zod8.z.literal("function_call"),
-      id: import_zod8.z.string(),
-      call_id: import_zod8.z.string(),
-      name: import_zod8.z.string(),
-      arguments: import_zod8.z.string(),
-      status: import_zod8.z.literal("completed")
+    import_zod12.z.object({
+      type: import_zod12.z.literal("function_call"),
+      id: import_zod12.z.string(),
+      call_id: import_zod12.z.string(),
+      name: import_zod12.z.string(),
+      arguments: import_zod12.z.string(),
+      status: import_zod12.z.literal("completed")
+    }),
+    import_zod12.z.object({
+      type: import_zod12.z.literal("web_search_call"),
+      id: import_zod12.z.string(),
+      status: import_zod12.z.string(),
+      action: import_zod12.z.discriminatedUnion("type", [
+        import_zod12.z.object({
+          type: import_zod12.z.literal("search"),
+          query: import_zod12.z.string().nullish()
+        }),
+        import_zod12.z.object({
+          type: import_zod12.z.literal("open_page"),
+          url: import_zod12.z.string()
+        }),
+        import_zod12.z.object({
+          type: import_zod12.z.literal("find"),
+          url: import_zod12.z.string(),
+          pattern: import_zod12.z.string()
+        })
+      ]).nullish()
+    }),
+    import_zod12.z.object({
+      type: import_zod12.z.literal("computer_call"),
+      id: import_zod12.z.string(),
+      status: import_zod12.z.literal("completed")
+    }),
+    import_zod12.z.object({
+      type: import_zod12.z.literal("file_search_call"),
+      id: import_zod12.z.string(),
+      status: import_zod12.z.literal("completed"),
+      queries: import_zod12.z.array(import_zod12.z.string()).nullish(),
+      results: import_zod12.z.array(
+        import_zod12.z.object({
+          attributes: import_zod12.z.object({
+            file_id: import_zod12.z.string(),
+            filename: import_zod12.z.string(),
+            score: import_zod12.z.number(),
+            text: import_zod12.z.string()
+          })
+        })
+      ).nullish()
     })
   ])
 });
-var responseFunctionCallArgumentsDeltaSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("response.function_call_arguments.delta"),
-  item_id: import_zod8.z.string(),
-  output_index: import_zod8.z.number(),
-  delta: import_zod8.z.string()
+var responseFunctionCallArgumentsDeltaSchema = import_zod12.z.object({
+  type: import_zod12.z.literal("response.function_call_arguments.delta"),
+  item_id: import_zod12.z.string(),
+  output_index: import_zod12.z.number(),
+  delta: import_zod12.z.string()
 });
-var responseOutputItemAddedSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("response.output_item.added"),
-  output_index: import_zod8.z.number(),
-  item: import_zod8.z.discriminatedUnion("type", [
-    import_zod8.z.object({
-      type: import_zod8.z.literal("message")
+var responseOutputItemAddedSchema = import_zod12.z.object({
+  type: import_zod12.z.literal("response.output_item.added"),
+  output_index: import_zod12.z.number(),
+  item: import_zod12.z.discriminatedUnion("type", [
+    import_zod12.z.object({
+      type: import_zod12.z.literal("message")
     }),
-    import_zod8.z.object({
-      type: import_zod8.z.literal("function_call"),
-      id: import_zod8.z.string(),
-      call_id: import_zod8.z.string(),
-      name: import_zod8.z.string(),
-      arguments: import_zod8.z.string()
+    import_zod12.z.object({
+      type: import_zod12.z.literal("function_call"),
+      id: import_zod12.z.string(),
+      call_id: import_zod12.z.string(),
+      name: import_zod12.z.string(),
+      arguments: import_zod12.z.string()
+    }),
+    import_zod12.z.object({
+      type: import_zod12.z.literal("web_search_call"),
+      id: import_zod12.z.string(),
+      status: import_zod12.z.string(),
+      action: import_zod12.z.object({
+        type: import_zod12.z.literal("search"),
+        query: import_zod12.z.string().optional()
+      }).nullish()
+    }),
+    import_zod12.z.object({
+      type: import_zod12.z.literal("computer_call"),
+      id: import_zod12.z.string(),
+      status: import_zod12.z.string()
+    }),
+    import_zod12.z.object({
+      type: import_zod12.z.literal("file_search_call"),
+      id: import_zod12.z.string(),
+      status: import_zod12.z.string(),
+      queries: import_zod12.z.array(import_zod12.z.string()).nullish(),
+      results: import_zod12.z.array(
+        import_zod12.z.object({
+          attributes: import_zod12.z.object({
+            file_id: import_zod12.z.string(),
+            filename: import_zod12.z.string(),
+            score: import_zod12.z.number(),
+            text: import_zod12.z.string()
+          })
+        })
+      ).optional()
     })
   ])
 });
-var responseAnnotationAddedSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("response.output_text.annotation.added"),
-  annotation: import_zod8.z.object({
-    type: import_zod8.z.literal("url_citation"),
-    url: import_zod8.z.string(),
-    title: import_zod8.z.string()
-  })
+var responseAnnotationAddedSchema = import_zod12.z.object({
+  type: import_zod12.z.literal("response.output_text.annotation.added"),
+  annotation: import_zod12.z.discriminatedUnion("type", [
+    import_zod12.z.object({
+      type: import_zod12.z.literal("url_citation"),
+      url: import_zod12.z.string(),
+      title: import_zod12.z.string()
+    }),
+    import_zod12.z.object({
+      type: import_zod12.z.literal("file_citation"),
+      file_id: import_zod12.z.string(),
+      filename: import_zod12.z.string().nullish(),
+      index: import_zod12.z.number().nullish(),
+      start_index: import_zod12.z.number().nullish(),
+      end_index: import_zod12.z.number().nullish(),
+      quote: import_zod12.z.string().nullish()
+    })
+  ])
 });
-var responseReasoningSummaryTextDeltaSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("response.reasoning_summary_text.delta"),
-  item_id: import_zod8.z.string(),
-  output_index: import_zod8.z.number(),
-  summary_index: import_zod8.z.number(),
-  delta: import_zod8.z.string()
+var responseReasoningSummaryTextDeltaSchema = import_zod12.z.object({
+  type: import_zod12.z.literal("response.reasoning_summary_text.delta"),
+  item_id: import_zod12.z.string(),
+  output_index: import_zod12.z.number(),
+  summary_index: import_zod12.z.number(),
+  delta: import_zod12.z.string()
 });
-var openaiResponsesChunkSchema = import_zod8.z.union([
+var openaiResponsesChunkSchema = import_zod12.z.union([
   textDeltaChunkSchema,
   responseFinishedChunkSchema,
   responseCreatedChunkSchema,
@@ -2701,7 +3020,7 @@ var openaiResponsesChunkSchema = import_zod8.z.union([
   responseOutputItemAddedSchema,
   responseAnnotationAddedSchema,
   responseReasoningSummaryTextDeltaSchema,
-  import_zod8.z.object({ type: import_zod8.z.string() }).passthrough()
+  import_zod12.z.object({ type: import_zod12.z.string() }).passthrough()
   // fallback for unknown chunks
 ]);
 function isTextDeltaChunk(chunk) {
@@ -2749,18 +3068,18 @@ function getResponsesModelConfig(modelId) {
     requiredAutoTruncation: false
   };
 }
-var openaiResponsesProviderOptionsSchema = import_zod8.z.object({
-  metadata: import_zod8.z.any().nullish(),
-  parallelToolCalls: import_zod8.z.boolean().nullish(),
-  include: import_zod8.z.array(import_zod8.z.string()).nullish(),
-  previousResponseId: import_zod8.z.string().nullish(),
-  forceNoTemperature: import_zod8.z.boolean().nullish(),
-  store: import_zod8.z.boolean().nullish(),
-  user: import_zod8.z.string().nullish(),
-  reasoningEffort: import_zod8.z.string().nullish(),
-  strictSchemas: import_zod8.z.boolean().nullish(),
-  instructions: import_zod8.z.string().nullish(),
-  reasoningSummary: import_zod8.z.string().nullish()
+var openaiResponsesProviderOptionsSchema = import_zod12.z.object({
+  metadata: import_zod12.z.any().nullish(),
+  parallelToolCalls: import_zod12.z.boolean().nullish(),
+  include: import_zod12.z.array(import_zod12.z.string()).nullish(),
+  previousResponseId: import_zod12.z.string().nullish(),
+  forceNoTemperature: import_zod12.z.boolean().nullish(),
+  store: import_zod12.z.boolean().nullish(),
+  user: import_zod12.z.string().nullish(),
+  reasoningEffort: import_zod12.z.string().nullish(),
+  strictSchemas: import_zod12.z.boolean().nullish(),
+  instructions: import_zod12.z.string().nullish(),
+  reasoningSummary: import_zod12.z.string().nullish()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {