@ai-sdk/openai 3.0.97 → 3.0.98

package/dist/internal/index.mjs

@@ -5236,7 +5236,7 @@ async function prepareResponsesTools({
   toolNameMapping,
   customProviderToolNames
 }) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
   const toolWarnings = [];
   if (tools == null) {
@@ -5245,6 +5245,20 @@ async function prepareResponsesTools({
   const openaiTools = [];
   const namespaceTools = /* @__PURE__ */ new Map();
   const resolvedCustomProviderToolNames = customProviderToolNames != null ? customProviderToolNames : /* @__PURE__ */ new Set();
+  const allowedToolResolutions = /* @__PURE__ */ new Map();
+  const allowedToolAliases = /* @__PURE__ */ new Map();
+  const recordAllowedTool = (toolName, resolution, canonicalName) => {
+    allowedToolResolutions.set(toolName, resolution);
+    if (canonicalName == null || canonicalName === toolName) {
+      return;
+    }
+    const existingAlias = allowedToolAliases.get(canonicalName);
+    if (existingAlias == null) {
+      allowedToolAliases.set(canonicalName, resolution);
+    } else if (existingAlias !== "ambiguous" && !isSameAllowedTool(existingAlias, resolution)) {
+      allowedToolAliases.set(canonicalName, "ambiguous");
+    }
+  };
   for (const tool of tools) {
     switch (tool.type) {
       case "function": {
@@ -5274,9 +5288,24 @@ async function prepareResponsesTools({
           }
           namespaceTool.tools.push(openaiFunctionTool);
         }
+        recordAllowedTool(
+          tool.name,
+          namespace != null ? {
+            supported: false,
+            reason: "tools inside an OpenAI tool namespace are not visible to tool_choice.allowed_tools"
+          } : (openaiOptions == null ? void 0 : openaiOptions.deferLoading) === true ? {
+            supported: false,
+            reason: "deferred tools are not visible to tool_choice.allowed_tools"
+          } : {
+            supported: true,
+            entry: { type: "function", name: tool.name }
+          },
+          void 0
+        );
         break;
       }
       case "provider": {
+        const openaiToolCountBefore = openaiTools.length;
         switch (tool.id) {
           case "openai.file_search": {
             const args = await validateTypes2({
@@ -5437,6 +5466,14 @@ async function prepareResponsesTools({
             break;
           }
         }
+        if (openaiTools.length > openaiToolCountBefore) {
+          const openaiTool = openaiTools[openaiToolCountBefore];
+          recordAllowedTool(
+            tool.name,
+            toAllowedToolResolution(openaiTool),
+            toolNameMapping == null ? void 0 : toolNameMapping.toProviderToolName(tool.name)
+          );
+        }
         break;
       }
       default:
@@ -5448,18 +5485,63 @@ async function prepareResponsesTools({
     }
   }
   if (allowedTools != null) {
+    const allowedToolEntries = [];
+    const droppedToolNames = [];
+    for (const name of allowedTools.toolNames) {
+      const directResolution = allowedToolResolutions.get(name);
+      const resolution = directResolution != null ? directResolution : allowedToolAliases.get(name);
+      if (directResolution != null && allowedToolAliases.has(name)) {
+        toolWarnings.push({
+          type: "unsupported",
+          feature: `allowedTools entry "${name}"`,
+          details: "this name is both a tool name and the provider tool name of another tool in this request; the tool with this name is allowed"
+        });
+      }
+      if (resolution === "ambiguous") {
+        toolWarnings.push({
+          type: "unsupported",
+          feature: `allowedTools entry "${name}"`,
+          details: "several tools in this request share this provider tool name; use the tool name from the tools for this request instead"
+        });
+        droppedToolNames.push(name);
+        continue;
+      }
+      if (resolution == null) {
+        toolWarnings.push({
+          type: "unsupported",
+          feature: `allowedTools entry "${name}"`,
+          details: "the tool is not part of the tools for this request and is sent as a function tool"
+        });
+        allowedToolEntries.push({
+          type: "function",
+          name: (_b = toolNameMapping == null ? void 0 : toolNameMapping.toProviderToolName(name)) != null ? _b : name
+        });
+        continue;
+      }
+      if (!resolution.supported) {
+        toolWarnings.push({
+          type: "unsupported",
+          feature: `allowedTools entry "${name}"`,
+          details: `${resolution.reason}; the tool is removed from the allowed tools`
+        });
+        droppedToolNames.push(name);
+        continue;
+      }
+      allowedToolEntries.push(resolution.entry);
+    }
+    if (allowedToolEntries.length === 0) {
+      throw new UnsupportedFunctionalityError5({
+        functionality: `allowedTools with only tools that cannot be allow-listed (${droppedToolNames.join(
+          ", "
+        )})`
+      });
+    }
     return {
       tools: openaiTools,
       toolChoice: {
         type: "allowed_tools",
-        mode: (_b = allowedTools.mode) != null ? _b : "auto",
-        tools: allowedTools.toolNames.map((name) => {
-          var _a2;
-          return {
-            type: "function",
-            name: (_a2 = toolNameMapping == null ? void 0 : toolNameMapping.toProviderToolName(name)) != null ? _a2 : name
-          };
-        })
+        mode: (_c = allowedTools.mode) != null ? _c : "auto",
+        tools: allowedToolEntries
       },
       toolWarnings
     };
@@ -5474,7 +5556,7 @@ async function prepareResponsesTools({
     case "required":
       return { tools: openaiTools, toolChoice: type, toolWarnings };
     case "tool": {
-      const resolvedToolName = (_c = toolNameMapping == null ? void 0 : toolNameMapping.toProviderToolName(toolChoice.toolName)) != null ? _c : toolChoice.toolName;
+      const resolvedToolName = (_d = toolNameMapping == null ? void 0 : toolNameMapping.toProviderToolName(toolChoice.toolName)) != null ? _d : toolChoice.toolName;
       return {
         tools: openaiTools,
         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 },
@@ -5489,6 +5571,51 @@ async function prepareResponsesTools({
     }
   }
 }
+function allowedToolKey(entry) {
+  switch (entry.type) {
+    case "mcp":
+      return `mcp:${entry.server_label}`;
+    case "function":
+    case "custom":
+      return `${entry.type}:${entry.name}`;
+    default:
+      return entry.type;
+  }
+}
+function isSameAllowedTool(a, b) {
+  if (a.supported && b.supported) {
+    return allowedToolKey(a.entry) === allowedToolKey(b.entry);
+  }
+  if (!a.supported && !b.supported) {
+    return a.reason === b.reason;
+  }
+  return false;
+}
+function toAllowedToolResolution(tool) {
+  switch (tool.type) {
+    case "custom":
+      return { supported: true, entry: { type: "custom", name: tool.name } };
+    case "mcp":
+      return {
+        supported: true,
+        entry: { type: "mcp", server_label: tool.server_label }
+      };
+    case "file_search":
+    case "web_search":
+    case "web_search_preview":
+    case "image_generation":
+    case "code_interpreter":
+    case "apply_patch":
+    case "shell":
+    case "local_shell":
+      return { supported: true, entry: { type: tool.type } };
+    default:
+      return {
+        supported: false,
+        reason: `OpenAI does not support ${tool.type} tools in tool_choice.allowed_tools`
+      };
+  }
+}
 function prepareFunctionTool({
   tool,
   options