refactor: remove Agent-level tool filtering logic

Author: devtalker

docs/mcp.md

@@ -43,11 +43,7 @@ agent=Agent(
 
 ## Tool filtering
 
-You can filter which tools are available to your Agent in two ways:
-
-### Server-level filtering
-
-Each MCP server instance can be configured with `allowed_tools` and `excluded_tools` parameters to control which tools it exposes:
+You can filter which tools are available to your Agent using server-level filtering:
 
 ```python
 # Only expose specific tools from this server
@@ -69,29 +65,6 @@ server = MCPServerStdio(
 )
 ```
 
-### Agent-level filtering
-
-You can also filter tools at the Agent level using the `mcp_config` parameter. This allows you to control which tools are available across all MCP servers:
-
-```python
-agent = Agent(
-    name="Assistant",
-    instructions="Use the tools to achieve the task",
-    mcp_servers=[server1, server2, server3],
-    mcp_config={
-        "allowed_tools": {
-            "server1": ["read_file", "write_file"],  # Only these tools from server1
-            "server2": ["search"],                   # Only search tool from server2
-        },
-        "excluded_tools": {
-            "server3": ["dangerous_tool"],           # Exclude this tool from server3
-        }
-    }
-)
-```
-
-**Filtering priority**: Server-level filtering is applied first, then Agent-level filtering. This allows for fine-grained control where servers can limit their exposed tools, and Agents can further restrict which tools they use.
-
 ## Caching
 
 Every time an Agent runs, it calls `list_tools()` on the MCP server. This can be a latency hit, especially if the server is a remote server. To automatically cache the list of tools, you can pass `cache_tools_list=True` to [`MCPServerStdio`][agents.mcp.server.MCPServerStdio], [`MCPServerSse`][agents.mcp.server.MCPServerSse], and [`MCPServerStreamableHttp`][agents.mcp.server.MCPServerStreamableHttp]. You should only do this if you're certain the tool list will not change.

src/agents/agent.py

@@ -62,10 +62,6 @@ class MCPConfig(TypedDict):
     """If True, we will attempt to convert the MCP schemas to strict-mode schemas. This is a
     best-effort conversion, so some schemas may not be convertible. Defaults to False.
     """
-    allowed_tools: NotRequired[dict[str, list[str]]]
-    """Optional: server_name -> allowed tool names (whitelist)"""
-    excluded_tools: NotRequired[dict[str, list[str]]]
-    """Optional: server_name -> excluded tool names (blacklist)"""
 
 
 @dataclass
@@ -249,14 +245,7 @@ async def get_system_prompt(self, run_context: RunContextWrapper[TContext]) -> s
     async def get_mcp_tools(self) -> list[Tool]:
         """Fetches the available tools from the MCP servers."""
         convert_schemas_to_strict = self.mcp_config.get("convert_schemas_to_strict", False)
-        allowed_tools_map = self.mcp_config.get("allowed_tools", {})
-        excluded_tools_map = self.mcp_config.get("excluded_tools", {})
-        return await MCPUtil.get_all_function_tools(
-            self.mcp_servers,
-            convert_schemas_to_strict,
-            allowed_tools_map,
-            excluded_tools_map,
-        )
+        return await MCPUtil.get_all_function_tools(self.mcp_servers, convert_schemas_to_strict)
 
     async def get_all_tools(self, run_context: RunContextWrapper[Any]) -> list[Tool]:
         """All agent tools, including MCP tools and function tools."""

src/agents/mcp/util.py

@@ -1,6 +1,6 @@
 import functools
 import json
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from agents.strict_schema import ensure_strict_json_schema
 
@@ -22,23 +22,13 @@ class MCPUtil:
 
     @classmethod
     async def get_all_function_tools(
-        cls,
-        servers: list["MCPServer"],
-        convert_schemas_to_strict: bool,
-        allowed_tools_map: Optional[dict[str, list[str]]] = None,
-        excluded_tools_map: Optional[dict[str, list[str]]] = None,
+        cls, servers: list["MCPServer"], convert_schemas_to_strict: bool
     ) -> list[Tool]:
         """Get all function tools from a list of MCP servers."""
         tools = []
         tool_names: set[str] = set()
-        allowed_tools_map = allowed_tools_map or {}
-        excluded_tools_map = excluded_tools_map or {}
         for server in servers:
-            allowed = allowed_tools_map.get(server.name)
-            excluded = excluded_tools_map.get(server.name)
-            server_tools = await cls.get_function_tools(
-                server, convert_schemas_to_strict, allowed, excluded
-            )
+            server_tools = await cls.get_function_tools(server, convert_schemas_to_strict)
             server_tool_names = {tool.name for tool in server_tools}
             if len(server_tool_names & tool_names) > 0:
                 raise UserError(
@@ -52,29 +42,15 @@ async def get_all_function_tools(
 
     @classmethod
     async def get_function_tools(
-        cls,
-        server: "MCPServer",
-        convert_schemas_to_strict: bool,
-        allowed_tools: Optional[list[str]] = None,
-        excluded_tools: Optional[list[str]] = None,
+        cls, server: "MCPServer", convert_schemas_to_strict: bool
     ) -> list[Tool]:
         """Get all function tools from a single MCP server."""
 
         with mcp_tools_span(server=server.name) as span:
             tools = await server.list_tools()
             span.span_data.result = [tool.name for tool in tools]
 
-        # Apply Agent-level filtering (additional filtering on top of server-level filtering)
-        filtered_tools = tools
-        if allowed_tools is not None:
-            filtered_tools = [t for t in filtered_tools if t.name in allowed_tools]
-        if excluded_tools is not None:
-            filtered_tools = [t for t in filtered_tools if t.name not in excluded_tools]
-
-        return [
-            cls.to_function_tool(tool, server, convert_schemas_to_strict)
-            for tool in filtered_tools
-        ]
+        return [cls.to_function_tool(tool, server, convert_schemas_to_strict) for tool in tools]
 
     @classmethod
     def to_function_tool(

tests/mcp/test_tool_filtering.py

@@ -1,8 +1,5 @@
 import pytest
 
-from agents import Agent
-from agents.mcp import MCPUtil
-
 from .helpers import FakeMCPServer
 
 
@@ -82,142 +79,3 @@ async def test_server_both_filters():
     tools = await server.list_tools()
     assert len(tools) == 2
     assert {t.name for t in tools} == {"tool1", "tool2"}
-
-
-@pytest.mark.asyncio
-async def test_agent_allowed_tools():
-    """Test that agent-level allowed_tools filters tools correctly"""
-    server1 = FilterableFakeMCPServer(server_name="server1")
-    server1.add_tool("tool1", {})
-    server1.add_tool("tool2", {})
-
-    server2 = FilterableFakeMCPServer(server_name="server2")
-    server2.add_tool("tool3", {})
-    server2.add_tool("tool4", {})
-
-    # Create agent with allowed_tools in mcp_config
-    agent = Agent(
-        name="test_agent",
-        mcp_servers=[server1, server2],
-        mcp_config={
-            "allowed_tools": {
-                "server1": ["tool1"],
-                "server2": ["tool3"],
-            }
-        }
-    )
-
-    # Get tools and verify filtering
-    tools = await agent.get_mcp_tools()
-    assert len(tools) == 2
-    assert {t.name for t in tools} == {"tool1", "tool3"}
-
-
-@pytest.mark.asyncio
-async def test_agent_excluded_tools():
-    """Test that agent-level excluded_tools filters tools correctly"""
-    server1 = FilterableFakeMCPServer(server_name="server1")
-    server1.add_tool("tool1", {})
-    server1.add_tool("tool2", {})
-
-    server2 = FilterableFakeMCPServer(server_name="server2")
-    server2.add_tool("tool3", {})
-    server2.add_tool("tool4", {})
-
-    # Create agent with excluded_tools in mcp_config
-    agent = Agent(
-        name="test_agent",
-        mcp_servers=[server1, server2],
-        mcp_config={
-            "excluded_tools": {
-                "server1": ["tool2"],
-                "server2": ["tool4"],
-            }
-        }
-    )
-
-    # Get tools and verify filtering
-    tools = await agent.get_mcp_tools()
-    assert len(tools) == 2
-    assert {t.name for t in tools} == {"tool1", "tool3"}
-
-
-@pytest.mark.asyncio
-async def test_combined_filtering():
-    """Test that server-level and agent-level filtering work together correctly"""
-    # Server with its own filtering
-    server = FilterableFakeMCPServer(server_name="test_server")
-    server.add_tool("tool1", {})
-    server.add_tool("tool2", {})
-    server.add_tool("tool3", {})
-    server.add_tool("tool4", {})
-    server.allowed_tools = ["tool1", "tool2", "tool3"]  # Server only exposes these
-
-    # Agent with additional filtering
-    agent = Agent(
-        name="test_agent",
-        mcp_servers=[server],
-        mcp_config={
-            "excluded_tools": {
-                "test_server": ["tool3"],  # Agent excludes this one
-            }
-        }
-    )
-
-    # Get tools and verify filtering
-    tools = await agent.get_mcp_tools()
-    assert len(tools) == 2
-    assert {t.name for t in tools} == {"tool1", "tool2"}
-
-
-@pytest.mark.asyncio
-async def test_util_direct_filtering():
-    """Test MCPUtil.get_all_function_tools with filtering parameters"""
-    server1 = FilterableFakeMCPServer(server_name="server1")
-    server1.add_tool("tool1", {})
-    server1.add_tool("tool2", {})
-
-    server2 = FilterableFakeMCPServer(server_name="server2")
-    server2.add_tool("tool3", {})
-    server2.add_tool("tool4", {})
-
-    # Test direct filtering through MCPUtil
-    allowed_tools_map = {"server1": ["tool1"]}
-    excluded_tools_map = {"server2": ["tool4"]}
-
-    tools = await MCPUtil.get_all_function_tools(
-        [server1, server2],
-        convert_schemas_to_strict=False,
-        allowed_tools_map=allowed_tools_map,
-        excluded_tools_map=excluded_tools_map
-    )
-
-    assert len(tools) == 2
-    assert {t.name for t in tools} == {"tool1", "tool3"}
-
-
-@pytest.mark.asyncio
-async def test_filtering_priority():
-    """Test that server-level filtering takes priority over agent-level filtering"""
-    # Server only exposes tool1 and tool2
-    server = FilterableFakeMCPServer(server_name="test_server")
-    server.add_tool("tool1", {})
-    server.add_tool("tool2", {})
-    server.add_tool("tool3", {})
-    server.allowed_tools = ["tool1", "tool2"]
-
-    # Agent tries to allow tool3 (which server doesn't expose)
-    agent = Agent(
-        name="test_agent",
-        mcp_servers=[server],
-        mcp_config={
-            "allowed_tools": {
-                "test_server": ["tool2", "tool3"],  # tool3 isn't available from server
-            }
-        }
-    )
-
-    # Get tools and verify filtering
-    tools = await agent.get_mcp_tools()
-    assert len(tools) == 1
-    assert tools[0].name == "tool2"  # Only tool2 passes both filters