@ai-sdk/openai 3.0.35 → 3.0.37

package/dist/internal/index.mjs

@@ -997,7 +997,7 @@ var OpenAIChatLanguageModel = class {
               for (const toolCallDelta of delta.tool_calls) {
                 const index = toolCallDelta.index;
                 if (toolCalls[index] == null) {
-                  if (toolCallDelta.type !== "function") {
+                  if (toolCallDelta.type != null && toolCallDelta.type !== "function") {
                     throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function' type.`
@@ -2585,9 +2585,10 @@ async function convertToOpenAIResponsesInput({
   hasConversation = false,
   hasLocalShellTool = false,
   hasShellTool = false,
-  hasApplyPatchTool = false
+  hasApplyPatchTool = false,
+  customProviderToolNames
 }) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
   const input = [];
   const warnings = [];
   const processedApprovalIds = /* @__PURE__ */ new Set();
@@ -2756,6 +2757,16 @@ async function convertToOpenAIResponsesInput({
                 });
                 break;
               }
+              if (customProviderToolNames == null ? void 0 : customProviderToolNames.has(resolvedToolName)) {
+                input.push({
+                  type: "custom_tool_call",
+                  call_id: part.toolCallId,
+                  name: resolvedToolName,
+                  input: typeof part.input === "string" ? part.input : JSON.stringify(part.input),
+                  id
+                });
+                break;
+              }
               input.push({
                 type: "function_call",
                 call_id: part.toolCallId,
@@ -2960,6 +2971,61 @@ async function convertToOpenAIResponsesInput({
             });
             continue;
           }
+          if (customProviderToolNames == null ? void 0 : customProviderToolNames.has(resolvedToolName)) {
+            let outputValue;
+            switch (output.type) {
+              case "text":
+              case "error-text":
+                outputValue = output.value;
+                break;
+              case "execution-denied":
+                outputValue = (_l = output.reason) != null ? _l : "Tool execution denied.";
+                break;
+              case "json":
+              case "error-json":
+                outputValue = JSON.stringify(output.value);
+                break;
+              case "content":
+                outputValue = output.value.map((item) => {
+                  var _a2;
+                  switch (item.type) {
+                    case "text":
+                      return { type: "input_text", text: item.text };
+                    case "image-data":
+                      return {
+                        type: "input_image",
+                        image_url: `data:${item.mediaType};base64,${item.data}`
+                      };
+                    case "image-url":
+                      return {
+                        type: "input_image",
+                        image_url: item.url
+                      };
+                    case "file-data":
+                      return {
+                        type: "input_file",
+                        filename: (_a2 = item.filename) != null ? _a2 : "data",
+                        file_data: `data:${item.mediaType};base64,${item.data}`
+                      };
+                    default:
+                      warnings.push({
+                        type: "other",
+                        message: `unsupported custom tool content part type: ${item.type}`
+                      });
+                      return void 0;
+                  }
+                }).filter(isNonNullable);
+                break;
+              default:
+                outputValue = "";
+            }
+            input.push({
+              type: "custom_tool_call_output",
+              call_id: part.toolCallId,
+              output: outputValue
+            });
+            continue;
+          }
           let contentValue;
           switch (output.type) {
             case "text":
@@ -2967,7 +3033,7 @@ async function convertToOpenAIResponsesInput({
               contentValue = output.value;
               break;
             case "execution-denied":
-              contentValue = (_l = output.reason) != null ? _l : "Tool execution denied.";
+              contentValue = (_m = output.reason) != null ? _m : "Tool execution denied.";
               break;
             case "json":
             case "error-json":
@@ -3182,6 +3248,13 @@ var openaiResponsesChunkSchema = lazySchema14(
               })
             ])
           }),
+          z16.object({
+            type: z16.literal("custom_tool_call"),
+            id: z16.string(),
+            call_id: z16.string(),
+            name: z16.string(),
+            input: z16.string()
+          }),
           z16.object({
             type: z16.literal("shell_call"),
             id: z16.string(),
@@ -3234,6 +3307,14 @@ var openaiResponsesChunkSchema = lazySchema14(
             arguments: z16.string(),
             status: z16.literal("completed")
           }),
+          z16.object({
+            type: z16.literal("custom_tool_call"),
+            id: z16.string(),
+            call_id: z16.string(),
+            name: z16.string(),
+            input: z16.string(),
+            status: z16.literal("completed")
+          }),
           z16.object({
             type: z16.literal("code_interpreter_call"),
             id: z16.string(),
@@ -3417,6 +3498,12 @@ var openaiResponsesChunkSchema = lazySchema14(
         output_index: z16.number(),
         delta: z16.string()
       }),
+      z16.object({
+        type: z16.literal("response.custom_tool_call_input.delta"),
+        item_id: z16.string(),
+        output_index: z16.number(),
+        delta: z16.string()
+      }),
       z16.object({
         type: z16.literal("response.image_generation_call.partial_image"),
         item_id: z16.string(),
@@ -3664,6 +3751,13 @@ var openaiResponsesResponseSchema = lazySchema14(
             arguments: z16.string(),
             id: z16.string()
           }),
+          z16.object({
+            type: z16.literal("custom_tool_call"),
+            call_id: z16.string(),
+            name: z16.string(),
+            input: z16.string(),
+            id: z16.string()
+          }),
           z16.object({
             type: z16.literal("computer_call"),
             id: z16.string(),
@@ -4167,139 +4261,115 @@ var imageGeneration = (args = {}) => {
   return imageGenerationToolFactory(args);
 };
 
-// src/tool/mcp.ts
+// src/tool/custom.ts
 import {
-  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema7,
+  createProviderToolFactory,
   lazySchema as lazySchema19,
   zodSchema as zodSchema19
 } from "@ai-sdk/provider-utils";
 import { z as z21 } from "zod/v4";
-var jsonValueSchema = z21.lazy(
-  () => z21.union([
-    z21.string(),
-    z21.number(),
-    z21.boolean(),
-    z21.null(),
-    z21.array(jsonValueSchema),
-    z21.record(z21.string(), jsonValueSchema)
-  ])
-);
-var mcpArgsSchema = lazySchema19(
+var customArgsSchema = lazySchema19(
   () => zodSchema19(
     z21.object({
-      serverLabel: z21.string(),
-      allowedTools: z21.union([
-        z21.array(z21.string()),
+      name: z21.string(),
+      description: z21.string().optional(),
+      format: z21.union([
         z21.object({
-          readOnly: z21.boolean().optional(),
-          toolNames: z21.array(z21.string()).optional()
-        })
-      ]).optional(),
-      authorization: z21.string().optional(),
-      connectorId: z21.string().optional(),
-      headers: z21.record(z21.string(), z21.string()).optional(),
-      requireApproval: z21.union([
-        z21.enum(["always", "never"]),
+          type: z21.literal("grammar"),
+          syntax: z21.enum(["regex", "lark"]),
+          definition: z21.string()
+        }),
         z21.object({
-          never: z21.object({
-            toolNames: z21.array(z21.string()).optional()
-          }).optional()
+          type: z21.literal("text")
         })
-      ]).optional(),
-      serverDescription: z21.string().optional(),
-      serverUrl: z21.string().optional()
-    }).refine(
-      (v) => v.serverUrl != null || v.connectorId != null,
-      "One of serverUrl or connectorId must be provided."
-    )
-  )
-);
-var mcpInputSchema = lazySchema19(() => zodSchema19(z21.object({})));
-var mcpOutputSchema = lazySchema19(
-  () => zodSchema19(
-    z21.object({
-      type: z21.literal("call"),
-      serverLabel: z21.string(),
-      name: z21.string(),
-      arguments: z21.string(),
-      output: z21.string().nullish(),
-      error: z21.union([z21.string(), jsonValueSchema]).optional()
+      ]).optional()
     })
   )
 );
-var mcpToolFactory = createProviderToolFactoryWithOutputSchema7({
-  id: "openai.mcp",
-  inputSchema: mcpInputSchema,
-  outputSchema: mcpOutputSchema
+var customInputSchema = lazySchema19(() => zodSchema19(z21.string()));
+var customToolFactory = createProviderToolFactory({
+  id: "openai.custom",
+  inputSchema: customInputSchema
 });
 
-// src/tool/web-search.ts
+// src/tool/mcp.ts
 import {
-  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema8,
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema7,
   lazySchema as lazySchema20,
   zodSchema as zodSchema20
 } from "@ai-sdk/provider-utils";
 import { z as z22 } from "zod/v4";
-var webSearchArgsSchema = lazySchema20(
-  () => zodSchema20(
-    z22.object({
-      externalWebAccess: z22.boolean().optional(),
-      filters: z22.object({ allowedDomains: z22.array(z22.string()).optional() }).optional(),
-      searchContextSize: z22.enum(["low", "medium", "high"]).optional(),
-      userLocation: z22.object({
-        type: z22.literal("approximate"),
-        country: z22.string().optional(),
-        city: z22.string().optional(),
-        region: z22.string().optional(),
-        timezone: z22.string().optional()
-      }).optional()
-    })
-  )
+var jsonValueSchema = z22.lazy(
+  () => z22.union([
+    z22.string(),
+    z22.number(),
+    z22.boolean(),
+    z22.null(),
+    z22.array(jsonValueSchema),
+    z22.record(z22.string(), jsonValueSchema)
+  ])
 );
-var webSearchInputSchema = lazySchema20(() => zodSchema20(z22.object({})));
-var webSearchOutputSchema = lazySchema20(
+var mcpArgsSchema = lazySchema20(
   () => zodSchema20(
     z22.object({
-      action: z22.discriminatedUnion("type", [
-        z22.object({
-          type: z22.literal("search"),
-          query: z22.string().optional()
-        }),
+      serverLabel: z22.string(),
+      allowedTools: z22.union([
+        z22.array(z22.string()),
         z22.object({
-          type: z22.literal("openPage"),
-          url: z22.string().nullish()
-        }),
+          readOnly: z22.boolean().optional(),
+          toolNames: z22.array(z22.string()).optional()
+        })
+      ]).optional(),
+      authorization: z22.string().optional(),
+      connectorId: z22.string().optional(),
+      headers: z22.record(z22.string(), z22.string()).optional(),
+      requireApproval: z22.union([
+        z22.enum(["always", "never"]),
         z22.object({
-          type: z22.literal("findInPage"),
-          url: z22.string().nullish(),
-          pattern: z22.string().nullish()
+          never: z22.object({
+            toolNames: z22.array(z22.string()).optional()
+          }).optional()
         })
       ]).optional(),
-      sources: z22.array(
-        z22.discriminatedUnion("type", [
-          z22.object({ type: z22.literal("url"), url: z22.string() }),
-          z22.object({ type: z22.literal("api"), name: z22.string() })
-        ])
-      ).optional()
+      serverDescription: z22.string().optional(),
+      serverUrl: z22.string().optional()
+    }).refine(
+      (v) => v.serverUrl != null || v.connectorId != null,
+      "One of serverUrl or connectorId must be provided."
+    )
+  )
+);
+var mcpInputSchema = lazySchema20(() => zodSchema20(z22.object({})));
+var mcpOutputSchema = lazySchema20(
+  () => zodSchema20(
+    z22.object({
+      type: z22.literal("call"),
+      serverLabel: z22.string(),
+      name: z22.string(),
+      arguments: z22.string(),
+      output: z22.string().nullish(),
+      error: z22.union([z22.string(), jsonValueSchema]).optional()
     })
   )
 );
-var webSearchToolFactory = createProviderToolFactoryWithOutputSchema8({
-  id: "openai.web_search",
-  inputSchema: webSearchInputSchema,
-  outputSchema: webSearchOutputSchema
+var mcpToolFactory = createProviderToolFactoryWithOutputSchema7({
+  id: "openai.mcp",
+  inputSchema: mcpInputSchema,
+  outputSchema: mcpOutputSchema
 });
 
-// src/tool/web-search-preview.ts
+// src/tool/web-search.ts
 import {
-  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema9,
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema8,
   lazySchema as lazySchema21,
   zodSchema as zodSchema21
 } from "@ai-sdk/provider-utils";
 import { z as z23 } from "zod/v4";
-var webSearchPreviewArgsSchema = lazySchema21(
+var webSearchArgsSchema = lazySchema21(
   () => zodSchema21(
     z23.object({
+      externalWebAccess: z23.boolean().optional(),
+      filters: z23.object({ allowedDomains: z23.array(z23.string()).optional() }).optional(),
       searchContextSize: z23.enum(["low", "medium", "high"]).optional(),
       userLocation: z23.object({
         type: z23.literal("approximate"),
@@ -4311,10 +4381,8 @@ var webSearchPreviewArgsSchema = lazySchema21(
     })
   )
 );
-var webSearchPreviewInputSchema = lazySchema21(
-  () => zodSchema21(z23.object({}))
-);
-var webSearchPreviewOutputSchema = lazySchema21(
+var webSearchInputSchema = lazySchema21(() => zodSchema21(z23.object({})));
+var webSearchOutputSchema = lazySchema21(
   () => zodSchema21(
     z23.object({
       action: z23.discriminatedUnion("type", [
@@ -4331,6 +4399,63 @@ var webSearchPreviewOutputSchema = lazySchema21(
           url: z23.string().nullish(),
           pattern: z23.string().nullish()
         })
+      ]).optional(),
+      sources: z23.array(
+        z23.discriminatedUnion("type", [
+          z23.object({ type: z23.literal("url"), url: z23.string() }),
+          z23.object({ type: z23.literal("api"), name: z23.string() })
+        ])
+      ).optional()
+    })
+  )
+);
+var webSearchToolFactory = createProviderToolFactoryWithOutputSchema8({
+  id: "openai.web_search",
+  inputSchema: webSearchInputSchema,
+  outputSchema: webSearchOutputSchema
+});
+
+// src/tool/web-search-preview.ts
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema9,
+  lazySchema as lazySchema22,
+  zodSchema as zodSchema22
+} from "@ai-sdk/provider-utils";
+import { z as z24 } from "zod/v4";
+var webSearchPreviewArgsSchema = lazySchema22(
+  () => zodSchema22(
+    z24.object({
+      searchContextSize: z24.enum(["low", "medium", "high"]).optional(),
+      userLocation: z24.object({
+        type: z24.literal("approximate"),
+        country: z24.string().optional(),
+        city: z24.string().optional(),
+        region: z24.string().optional(),
+        timezone: z24.string().optional()
+      }).optional()
+    })
+  )
+);
+var webSearchPreviewInputSchema = lazySchema22(
+  () => zodSchema22(z24.object({}))
+);
+var webSearchPreviewOutputSchema = lazySchema22(
+  () => zodSchema22(
+    z24.object({
+      action: z24.discriminatedUnion("type", [
+        z24.object({
+          type: z24.literal("search"),
+          query: z24.string().optional()
+        }),
+        z24.object({
+          type: z24.literal("openPage"),
+          url: z24.string().nullish()
+        }),
+        z24.object({
+          type: z24.literal("findInPage"),
+          url: z24.string().nullish(),
+          pattern: z24.string().nullish()
+        })
       ]).optional()
     })
   )
@@ -4344,14 +4469,18 @@ var webSearchPreview = createProviderToolFactoryWithOutputSchema9({
 // src/responses/openai-responses-prepare-tools.ts
 async function prepareResponsesTools({
   tools,
-  toolChoice
+  toolChoice,
+  toolNameMapping,
+  customProviderToolNames
 }) {
+  var _a;
   tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
   const toolWarnings = [];
   if (tools == null) {
     return { tools: void 0, toolChoice: void 0, toolWarnings };
   }
   const openaiTools = [];
+  const resolvedCustomProviderToolNames = customProviderToolNames != null ? customProviderToolNames : /* @__PURE__ */ new Set();
   for (const tool of tools) {
     switch (tool.type) {
       case "function":
@@ -4493,6 +4622,20 @@ async function prepareResponsesTools({
             });
             break;
           }
+          case "openai.custom": {
+            const args = await validateTypes2({
+              value: tool.args,
+              schema: customArgsSchema
+            });
+            openaiTools.push({
+              type: "custom",
+              name: args.name,
+              description: args.description,
+              format: args.format
+            });
+            resolvedCustomProviderToolNames.add(args.name);
+            break;
+          }
         }
         break;
       }
@@ -4513,12 +4656,14 @@ async function prepareResponsesTools({
     case "none":
     case "required":
       return { tools: openaiTools, toolChoice: type, toolWarnings };
-    case "tool":
+    case "tool": {
+      const resolvedToolName = (_a = toolNameMapping == null ? void 0 : toolNameMapping.toProviderToolName(toolChoice.toolName)) != null ? _a : toolChoice.toolName;
       return {
         tools: openaiTools,
-        toolChoice: toolChoice.toolName === "code_interpreter" || toolChoice.toolName === "file_search" || toolChoice.toolName === "image_generation" || toolChoice.toolName === "web_search_preview" || toolChoice.toolName === "web_search" || toolChoice.toolName === "mcp" || toolChoice.toolName === "apply_patch" ? { type: toolChoice.toolName } : { type: "function", name: toolChoice.toolName },
+        toolChoice: resolvedToolName === "code_interpreter" || resolvedToolName === "file_search" || resolvedToolName === "image_generation" || resolvedToolName === "web_search_preview" || resolvedToolName === "web_search" || resolvedToolName === "mcp" || resolvedToolName === "apply_patch" ? { type: resolvedToolName } : resolvedCustomProviderToolNames.has(resolvedToolName) ? { type: "custom", name: resolvedToolName } : { type: "function", name: resolvedToolName },
         toolWarnings
       };
+    }
     default: {
       const _exhaustiveCheck = type;
       throw new UnsupportedFunctionalityError5({
@@ -4669,7 +4814,19 @@ var OpenAIResponsesLanguageModel = class {
         "openai.web_search_preview": "web_search_preview",
         "openai.mcp": "mcp",
         "openai.apply_patch": "apply_patch"
-      }
+      },
+      resolveProviderToolName: (tool) => tool.id === "openai.custom" ? tool.args.name : void 0
+    });
+    const customProviderToolNames = /* @__PURE__ */ new Set();
+    const {
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      toolWarnings
+    } = await prepareResponsesTools({
+      tools,
+      toolChoice,
+      toolNameMapping,
+      customProviderToolNames
     });
     const { input, warnings: inputWarnings } = await convertToOpenAIResponsesInput({
       prompt,
@@ -4681,7 +4838,8 @@ var OpenAIResponsesLanguageModel = class {
       hasConversation: (openaiOptions == null ? void 0 : openaiOptions.conversation) != null,
       hasLocalShellTool: hasOpenAITool("openai.local_shell"),
       hasShellTool: hasOpenAITool("openai.shell"),
-      hasApplyPatchTool: hasOpenAITool("openai.apply_patch")
+      hasApplyPatchTool: hasOpenAITool("openai.apply_patch"),
+      customProviderToolNames: customProviderToolNames.size > 0 ? customProviderToolNames : void 0
     });
     warnings.push(...inputWarnings);
     const strictJsonSchema = (_d = openaiOptions == null ? void 0 : openaiOptions.strictJsonSchema) != null ? _d : true;
@@ -4814,14 +4972,6 @@ var OpenAIResponsesLanguageModel = class {
       });
       delete baseArgs.service_tier;
     }
-    const {
-      tools: openaiTools,
-      toolChoice: openaiToolChoice,
-      toolWarnings
-    } = await prepareResponsesTools({
-      tools,
-      toolChoice
-    });
     const shellToolEnvType = (_i = (_h = (_g = tools == null ? void 0 : tools.find(
       (tool) => tool.type === "provider" && tool.id === "openai.shell"
     )) == null ? void 0 : _g.args) == null ? void 0 : _h.environment) == null ? void 0 : _i.type;
@@ -5071,6 +5221,22 @@ var OpenAIResponsesLanguageModel = class {
           });
           break;
         }
+        case "custom_tool_call": {
+          hasFunctionCall = true;
+          const toolName = toolNameMapping.toCustomToolName(part.name);
+          content.push({
+            type: "tool-call",
+            toolCallId: part.call_id,
+            toolName,
+            input: JSON.stringify(part.input),
+            providerMetadata: {
+              [providerOptionsName]: {
+                itemId: part.id
+              }
+            }
+          });
+          break;
+        }
         case "web_search_call": {
           content.push({
             type: "tool-call",
@@ -5329,6 +5495,19 @@ var OpenAIResponsesLanguageModel = class {
                   id: value.item.call_id,
                   toolName: value.item.name
                 });
+              } else if (value.item.type === "custom_tool_call") {
+                const toolName = toolNameMapping.toCustomToolName(
+                  value.item.name
+                );
+                ongoingToolCalls[value.output_index] = {
+                  toolName,
+                  toolCallId: value.item.call_id
+                };
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: value.item.call_id,
+                  toolName
+                });
               } else if (value.item.type === "web_search_call") {
                 ongoingToolCalls[value.output_index] = {
                   toolName: toolNameMapping.toCustomToolName(
@@ -5513,6 +5692,27 @@ var OpenAIResponsesLanguageModel = class {
                     }
                   }
                 });
+              } else if (value.item.type === "custom_tool_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                hasFunctionCall = true;
+                const toolName = toolNameMapping.toCustomToolName(
+                  value.item.name
+                );
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: value.item.call_id
+                });
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.call_id,
+                  toolName,
+                  input: JSON.stringify(value.item.input),
+                  providerMetadata: {
+                    [providerOptionsName]: {
+                      itemId: value.item.id
+                    }
+                  }
+                });
               } else if (value.item.type === "web_search_call") {
                 ongoingToolCalls[value.output_index] = void 0;
                 controller.enqueue({
@@ -5762,6 +5962,15 @@ var OpenAIResponsesLanguageModel = class {
                   delta: value.delta
                 });
               }
+            } else if (isResponseCustomToolCallInputDeltaChunk(value)) {
+              const toolCall = ongoingToolCalls[value.output_index];
+              if (toolCall != null) {
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.toolCallId,
+                  delta: value.delta
+                });
+              }
             } else if (isResponseApplyPatchCallOperationDiffDeltaChunk(value)) {
               const toolCall = ongoingToolCalls[value.output_index];
               if (toolCall == null ? void 0 : toolCall.applyPatch) {
@@ -6022,6 +6231,9 @@ function isResponseCreatedChunk(chunk) {
 function isResponseFunctionCallArgumentsDeltaChunk(chunk) {
   return chunk.type === "response.function_call_arguments.delta";
 }
+function isResponseCustomToolCallInputDeltaChunk(chunk) {
+  return chunk.type === "response.custom_tool_call_input.delta";
+}
 function isResponseImageGenerationCallPartialImageChunk(chunk) {
   return chunk.type === "response.image_generation_call.partial_image";
 }