@ai-sdk/openai 3.0.97 → 3.0.98

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @ai-sdk/openai
 
+## 3.0.98
+
+### Patch Changes
+
+- 91880b9: fix(openai): support built-in and provider-defined tools in the Responses `allowedTools` option
+
+  `allowedTools` emitted every allow-list entry as `{ type: 'function', name }`, but OpenAI identifies
+  built-in tools by type. Allow-listing a declared provider-defined tool (web search, image generation,
+  MCP, custom, ...) therefore failed with `Tool choice '<name>' not found in 'tools' parameter`. Entries
+  are now derived from the declared tool, including the MCP server label and custom tool name.
+
+  Tools that OpenAI cannot allow-list (the tool search tool, deferred tools, and namespaced tools) are
+  dropped from the allow-list with a warning, and an error is thrown if that would leave the allow-list
+  empty rather than silently sending an unrestricted request.
+
+  Ambiguous names are now reported instead of resolved silently. A name that matches both a declared tool
+  and another tool's provider tool name resolves to the declared tool and warns; a provider tool name
+  shared by several tools in the same request (two MCP servers, for example) is dropped with a warning.
+  A name that matches no declared tool keeps its existing behavior and is now warned about.
+
 ## 3.0.97
 
 ### Patch Changes

package/dist/index.js

@@ -4888,7 +4888,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) {
@@ -4897,6 +4897,20 @@ async function prepareResponsesTools({
   const openaiTools2 = [];
   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": {
@@ -4926,9 +4940,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 = openaiTools2.length;
         switch (tool.id) {
           case "openai.file_search": {
             const args = await (0, import_provider_utils29.validateTypes)({
@@ -5089,6 +5118,14 @@ async function prepareResponsesTools({
             break;
           }
         }
+        if (openaiTools2.length > openaiToolCountBefore) {
+          const openaiTool = openaiTools2[openaiToolCountBefore];
+          recordAllowedTool(
+            tool.name,
+            toAllowedToolResolution(openaiTool),
+            toolNameMapping == null ? void 0 : toolNameMapping.toProviderToolName(tool.name)
+          );
+        }
         break;
       }
       default:
@@ -5100,18 +5137,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 import_provider8.UnsupportedFunctionalityError({
+        functionality: `allowedTools with only tools that cannot be allow-listed (${droppedToolNames.join(
+          ", "
+        )})`
+      });
+    }
     return {
       tools: openaiTools2,
       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
     };
@@ -5126,7 +5208,7 @@ async function prepareResponsesTools({
     case "required":
       return { tools: openaiTools2, 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: openaiTools2,
         toolChoice: resolvedToolName === "code_interpreter" || resolvedToolName === "file_search" || resolvedToolName === "image_generation" || resolvedToolName === "web_search_preview" || resolvedToolName === "web_search" || resolvedToolName === "mcp" || resolvedToolName === "apply_patch" ? { type: resolvedToolName } : resolvedCustomProviderToolNames.has(resolvedToolName) ? { type: "custom", name: resolvedToolName } : { type: "function", name: resolvedToolName },
@@ -5141,6 +5223,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
@@ -7357,7 +7484,7 @@ var OpenAITranscriptionModel = class {
 };
 
 // src/version.ts
-var VERSION = true ? "3.0.97" : "0.0.0-test";
+var VERSION = true ? "3.0.98" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {