agentpool 2.2.3__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool_toolsets/mcp_discovery/toolset.py

@@ -17,7 +17,9 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from pydantic import HttpUrl
+from pydantic_ai import RunContext  # noqa: TC002
 
+from agentpool.agents.context import AgentContext  # noqa: TC001
 from agentpool.log import get_logger
 from agentpool.mcp_server.client import MCPClient
 from agentpool.mcp_server.registries.official_registry_client import (
@@ -28,7 +30,10 @@ from agentpool.resource_providers import ResourceProvider
 
 
 if TYPE_CHECKING:
-    from agentpool.agents.context import AgentContext
+    from collections.abc import Sequence
+
+    from fastmcp.client.sampling import SamplingHandler
+
     from agentpool.mcp_server.registries.official_registry_client import RegistryServer
     from agentpool.tools.base import Tool
     from agentpool_config.mcp_server import MCPServerConfig
@@ -58,6 +63,7 @@ class MCPDiscoveryToolset(ResourceProvider):
         registry_url: str = "https://registry.modelcontextprotocol.io",
         allowed_servers: list[str] | None = None,
         blocked_servers: list[str] | None = None,
+        sampling_callback: SamplingHandler[Any, Any] | None = None,
     ) -> None:
         """Initialize the MCP Discovery toolset.
 
@@ -66,6 +72,7 @@ class MCPDiscoveryToolset(ResourceProvider):
             registry_url: Base URL for the MCP registry API
             allowed_servers: If set, only these server names can be used
             blocked_servers: Server names that cannot be used
+            sampling_callback: Callback for MCP sampling requests
         """
         super().__init__(name=name)
         self._registry_url = registry_url
@@ -75,6 +82,7 @@ class MCPDiscoveryToolset(ResourceProvider):
         self._tools_cache: dict[str, list[dict[str, Any]]] = {}
         self._allowed_servers = set(allowed_servers) if allowed_servers else None
         self._blocked_servers = set(blocked_servers) if blocked_servers else set()
+        self._sampling_callback = sampling_callback
         self._tools: list[Tool] | None = None
         # Lazy-loaded semantic search components
         self._db: Any = None
@@ -191,7 +199,7 @@ class MCPDiscoveryToolset(ResourceProvider):
             del self._connections[server_name]
 
         config = await self._get_server_config(server_name)
-        client = MCPClient(config=config)
+        client = MCPClient(config=config, sampling_callback=self._sampling_callback)
         await client.__aenter__()
         self._connections[server_name] = client
         logger.info("Connected to MCP server", server=server_name)
@@ -207,7 +215,7 @@ class MCPDiscoveryToolset(ResourceProvider):
                 logger.warning("Error closing connection", server=name, error=e)
         self._connections.clear()
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get the discovery tools."""
         if self._tools is not None:
             return self._tools
@@ -387,6 +395,7 @@ class MCPDiscoveryToolset(ResourceProvider):
 
     async def call_mcp_tool(  # noqa: D417
         self,
+        ctx: RunContext,
         agent_ctx: AgentContext,
         server_name: str,
         tool_name: str,
@@ -397,6 +406,9 @@ class MCPDiscoveryToolset(ResourceProvider):
         Use this to execute a specific tool on an MCP server. The server
         connection is reused if already established.
 
+        This properly supports progress reporting, elicitation, and sampling
+        through the AgentContext integration.
+
         Args:
             server_name: Name of the MCP server (e.g., "com.github/github")
             tool_name: Name of the tool to call
@@ -416,21 +428,15 @@ class MCPDiscoveryToolset(ResourceProvider):
         try:
             client = await self._get_connection(server_name)
 
-            # Extract text content from result
-            from mcp.types import TextContent
-
-            result = await client._client.call_tool(tool_name, arguments or {})
-
-            # Process result content
-            text_parts = [
-                content.text for content in result.content if isinstance(content, TextContent)
-            ]
-
-            if text_parts:
-                return "\n".join(text_parts)
+            # Use MCPClient.call_tool which handles progress, elicitation, and sampling
+            return await client.call_tool(
+                name=tool_name,
+                run_context=ctx,
+                arguments=arguments or {},
+                agent_ctx=agent_ctx,
+            )
 
-            # Return raw result if no text content
-            return str(result)
+            # Result is already processed by MCPClient (ToolReturn, str, or structured data)
 
         except MCPRegistryError as e:
             return f"Error: {e}"
@@ -452,3 +458,54 @@ class MCPDiscoveryToolset(ResourceProvider):
             self._tmpdir = None
         self._db = None
         self._table = None
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    from agentpool.agents.agent import Agent
+
+    async def main() -> None:
+        """End-to-end example: Add MCP discovery toolset to an agent and call a tool."""
+        # Create the discovery toolset
+        toolset = MCPDiscoveryToolset(
+            name="mcp_discovery",
+            # Optionally restrict to specific servers for safety
+            # allowed_servers=["@modelcontextprotocol/server-everything"],
+        )
+
+        # Create an AgentPool agent with the toolset
+        agent = Agent(
+            model="openai:gpt-4o",
+            system_prompt="""
+            You are a helpful assistant with access to MCP servers.
+            Use the MCP discovery tools to search for and use tools from the MCP ecosystem.
+            """,
+            toolsets=[toolset],
+        )
+
+        async with agent:
+            # Example 1: Search for servers
+            print("\n=== Example 1: Search for file system servers ===")
+            result = await agent.run(
+                "Search for MCP servers related to file systems and show me the top 3 results"
+            )
+            print(result.data)
+
+            # Example 2: List tools from a specific server
+            print("\n=== Example 2: List tools from a server ===")
+            result = await agent.run(
+                "List the tools available on the '@modelcontextprotocol/server-everything' server"
+            )
+            print(result.data)
+
+            # Example 3: Call a tool (using a safe, read-only tool for demo)
+            print("\n=== Example 3: Call a tool ===")
+            result = await agent.run(
+                """Use the MCP discovery to call the 'echo' tool from
+                '@modelcontextprotocol/server-everything' with the argument
+                message='Hello from MCP Discovery!'"""
+            )
+            print(result.data)
+
+    asyncio.run(main())

agentpool_toolsets/mcp_run_toolset.py

@@ -12,6 +12,8 @@ from agentpool.resource_providers import ResourceProvider
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from contextlib import AbstractAsyncContextManager
     from types import TracebackType
 
     from mcp import ClientSession
@@ -44,15 +46,14 @@ class McpRunTools(ResourceProvider):
         self.client = Client(session_id=id_, config=config)
         self._tools: list[Tool] | None = None
         self._session: ClientSession | None = None
-        self._mcp_client_ctx: Any = None  # Context manager for persistent connection
+        # Context manager for persistent connection
+        self._mcp_client_ctx: AbstractAsyncContextManager[ClientSession] | None = None
 
     async def __aenter__(self) -> Self:
         """Start persistent SSE connection."""
-        # Create MCPClient from mcp_run
         mcp_client = self.client.mcp_sse()
         self._mcp_client_ctx = mcp_client.connect()
         self._session = await self._mcp_client_ctx.__aenter__()
-
         # Set up notification handler for tool changes
         # The MCP ClientSession dispatches notifications via _received_notification
         # We monkey-patch it to intercept ToolListChangedNotification
@@ -64,7 +65,6 @@ class McpRunTools(ResourceProvider):
             if isinstance(notification.root, ToolListChangedNotification):
                 logger.info("MCP.run tool list changed notification received")
                 await self._on_tools_changed()
-            # Call original handler
             await original_handler(notification)
 
         self._session._received_notification = notification_handler  # type: ignore[method-assign]
@@ -89,7 +89,7 @@ class McpRunTools(ResourceProvider):
         self._tools = None
         await self.tools_changed.emit(self.create_change_event("tools"))
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get tools from MCP.run."""
         # Return cached tools if available
         if self._tools is not None:
@@ -97,8 +97,7 @@ class McpRunTools(ResourceProvider):
 
         self._tools = []
         for name, tool in self.client.tools.items():
-            # Capture session for use in tool calls
-            session = self._session
+            session = self._session  # Capture session for use in tool calls
 
             async def run(
                 tool_name: str = name,
@@ -113,11 +112,9 @@ class McpRunTools(ResourceProvider):
                     return await new_session.call_tool(tool_name, arguments=input_dict)  # type: ignore[no-any-return]
 
             run.__name__ = name
-            wrapped_tool = self.create_tool(
-                run, schema_override=cast(OpenAIFunctionDefinition, tool.input_schema)
-            )
+            schema = cast(OpenAIFunctionDefinition, tool.input_schema)
+            wrapped_tool = self.create_tool(run, schema_override=schema)
             self._tools.append(wrapped_tool)
-
         return self._tools
 
     async def refresh_tools(self) -> None:

agentpool_toolsets/notifications.py

@@ -11,7 +11,7 @@ from agentpool.resource_providers import ResourceProvider
 
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
+    from collections.abc import Mapping, Sequence
 
     from agentpool.tools.base import Tool
 
@@ -19,6 +19,35 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
+def get_schema(channel_names: list[str] | None) -> OpenAIFunctionDefinition:
+    properties: dict[str, Any] = {
+        "message": {"type": "string", "description": "The notification message body"},
+        "title": {"type": "string", "description": "Optional notification title"},
+    }
+
+    if channel_names:
+        properties["channel"] = {
+            "type": "string",
+            "enum": channel_names,
+            "description": "Send to a specific channel. If not specified, sends to all channels.",
+        }
+    else:
+        properties["channel"] = {
+            "type": "string",
+            "description": "Send to a specific channel. If not specified, sends to all channels.",
+        }
+
+    return OpenAIFunctionDefinition(
+        name="send_notification",
+        description=(
+            "Send a notification via configured channels. "
+            "Specify a channel name to send to that channel only, "
+            "or omit to broadcast to all channels."
+        ),
+        parameters={"type": "object", "properties": properties, "required": ["message"]},
+    )
+
+
 class NotificationsTools(ResourceProvider):
     """Provider for Apprise-based notification tools.
 
@@ -53,44 +82,15 @@ class NotificationsTools(ResourceProvider):
                 self._apprise.add(url, tag=channel_name)
                 logger.debug("Added notification URL", channel=channel_name, url=url[:30] + "...")
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get notification tools with dynamic schema based on configured channels."""
         if self._tools is not None:
             return self._tools
 
         channel_names = sorted(self.channels.keys())
-        # Build schema with enum for available channels
-        properties: dict[str, Any] = {
-            "message": {"type": "string", "description": "The notification message body"},
-            "title": {"type": "string", "description": "Optional notification title"},
-        }
-
-        if channel_names:
-            properties["channel"] = {
-                "type": "string",
-                "enum": channel_names,
-                "description": "Send to a specific channel. If not specified, sends to all channels.",  # noqa: E501
-            }
-        else:
-            properties["channel"] = {
-                "type": "string",
-                "description": "Send to a specific channel. If not specified, sends to all channels.",  # noqa: E501
-            }
-
-        schema_override = OpenAIFunctionDefinition(
-            name="send_notification",
-            description=(
-                "Send a notification via configured channels. "
-                "Specify a channel name to send to that channel only, "
-                "or omit to broadcast to all channels."
-            ),
-            parameters={"type": "object", "properties": properties, "required": ["message"]},
-        )
-
+        schema = get_schema(channel_names)
         self._tools = [
-            self.create_tool(
-                self.send_notification, schema_override=schema_override, open_world=True
-            )
+            self.create_tool(self.send_notification, schema_override=schema, open_world=True)
         ]
         return self._tools
 

agentpool_toolsets/openapi.py

@@ -13,6 +13,8 @@ from agentpool.resource_providers import ResourceProvider
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     import httpx
     from upathtools import JoinablePathLike
 
@@ -41,7 +43,7 @@ class OpenAPITools(ResourceProvider):
         self._operations: dict[str, Any] = {}
         self._factory: OpenAPICallableFactory | None = None
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get all API operations as tools."""
         if not self._spec:
             await self._load_spec()

agentpool_toolsets/search_toolset.py

@@ -9,6 +9,8 @@ from agentpool.resource_providers import ResourceProvider
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from searchly.base import (
         CountryCode,
         LanguageCode,
@@ -178,7 +180,7 @@ class SearchTools(ResourceProvider):
 
         return formatted
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get search tools from configured providers."""
         tools: list[Tool] = []
         if self._web_provider:

agentpool_config/resources.py

@@ -1,33 +0,0 @@
-"""Models for resource information."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Self
-
-
-if TYPE_CHECKING:
-    from mcp.types import Resource as MCPResource
-
-
-@dataclass
-class ResourceInfo:
-    """Information about an available resource.
-
-    This class provides essential information about a resource that can be loaded.
-    Use the resource name with load_resource() to access the actual content.
-    """
-
-    name: str
-    """Name of the resource, use this with load_resource()"""
-
-    uri: str
-    """URI identifying the resource location"""
-
-    description: str | None = None
-    """Optional description of the resource's content or purpose"""
-
-    @classmethod
-    async def from_mcp_resource(cls, resource: MCPResource) -> Self:
-        """Create ResourceInfo from MCP resource."""
-        return cls(name=resource.name, uri=str(resource.uri), description=resource.description)

agentpool_server/acp_server/acp_tools.py

@@ -1,43 +0,0 @@
-"""ACP resource providers."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from exxec.acp_provider import ACPExecutionEnvironment
-
-from agentpool.resource_providers import PlanProvider
-from agentpool_toolsets.builtin import CodeTools, ExecutionEnvironmentTools
-from agentpool_toolsets.fsspec_toolset import FSSpecTools
-
-
-if TYPE_CHECKING:
-    from agentpool.resource_providers.aggregating import AggregatingResourceProvider
-    from agentpool_server.acp_server.session import ACPSession
-
-
-def get_acp_provider(session: ACPSession) -> AggregatingResourceProvider:
-    """Create aggregated resource provider with ACP-specific toolsets.
-
-    Args:
-        session: The ACP session to create providers for
-
-    Returns:
-        AggregatingResourceProvider with execution, filesystem, and code tools
-    """
-    from agentpool.resource_providers.aggregating import AggregatingResourceProvider
-
-    execution_env = ACPExecutionEnvironment(
-        fs=session.fs, requests=session.requests, cwd=session.cwd
-    )
-
-    providers = [
-        PlanProvider(),
-        ExecutionEnvironmentTools(env=execution_env, name=f"acp_execution_{session.session_id}"),
-        FSSpecTools(execution_env, name=f"acp_fs_{session.session_id}", cwd=session.cwd),
-        CodeTools(execution_env, name=f"acp_code_{session.session_id}", cwd=session.cwd),
-    ]
-    return AggregatingResourceProvider(providers=providers, name=f"acp_{session.session_id}")
-
-
-__all__ = ["get_acp_provider"]

agentpool_server/acp_server/commands/spawn.py

@@ -1,210 +0,0 @@
-"""Spawn subagent slash command."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-import uuid
-
-from pydantic_ai import (
-    FinalResultEvent,
-    FunctionToolCallEvent,
-    FunctionToolResultEvent,
-    PartDeltaEvent,
-    PartStartEvent,
-    RetryPromptPart,
-    TextPart,
-    TextPartDelta,
-    ThinkingPart,
-    ThinkingPartDelta,
-    ToolCallPartDelta,
-    ToolReturnPart,
-)
-from slashed import CommandContext, CommandError  # noqa: TC002
-
-from agentpool.agents.events import StreamCompleteEvent, ToolCallProgressEvent
-from agentpool.log import get_logger
-from agentpool.messaging.context import NodeContext  # noqa: TC001
-from agentpool_commands.base import NodeCommand
-from agentpool_server.acp_server.session import ACPSession  # noqa: TC001
-
-
-if TYPE_CHECKING:
-    from agentpool.agents.events import RichAgentStreamEvent
-
-
-logger = get_logger(__name__)
-
-
-class SpawnSubagentCommand(NodeCommand):
-    """Spawn a subagent to execute a specific task.
-
-    The subagent runs concurrently and reports progress in a dedicated tool call box.
-
-    Usage:
-      /spawn "agent-name" "prompt for the subagent"
-      /spawn "code-reviewer" "Review the main.py file for potential bugs"
-    """
-
-    name = "spawn"
-    category = "agents"
-
-    async def execute_command(
-        self,
-        ctx: CommandContext[NodeContext[ACPSession]],
-        agent_name: str,
-        task_prompt: str,
-    ) -> None:
-        """Spawn a subagent to execute a task.
-
-        Args:
-            ctx: Command context with ACP session
-            agent_name: Name of the agent to spawn
-            task_prompt: Task prompt for the subagent
-        """
-        session = ctx.context.data
-        assert session, "ACP session required for spawn command"
-        # Generate unique tool call ID
-        tool_call_id = f"spawn-{agent_name}-{uuid.uuid4().hex[:8]}"
-        try:
-            # Check if agent exists in pool
-            if not session.agent_pool or agent_name not in session.agent_pool.agents:
-                available = list(session.agent_pool.agents.keys())
-                error_msg = f"Agent {agent_name!r} not found. Available agents: {available}"
-                await ctx.print(f"❌ {error_msg}")
-                return
-
-            target_agent = session.agent_pool.get_agent(agent_name)
-            await session.notifications.tool_call_start(
-                tool_call_id=tool_call_id,
-                title=f"Spawning agent: {agent_name}",
-                kind="execute",
-                raw_input={
-                    "agent_name": agent_name,
-                    "task_prompt": task_prompt,
-                },
-            )
-
-            aggregated_content: list[str] = []  # Aggregate output as we stream
-            try:
-                # Run the subagent and handle events
-                async for event in target_agent.run_stream(task_prompt):
-                    await _handle_subagent_event(event, tool_call_id, aggregated_content, session)
-
-                final_content = "".join(aggregated_content).strip()
-                await session.notifications.tool_call_progress(
-                    tool_call_id=tool_call_id,
-                    status="completed",
-                    content=[final_content] if final_content else None,
-                )
-            except Exception as e:
-                error_msg = f"Subagent execution failed: {e}"
-                logger.exception("Subagent execution error", error=str(e))
-                await session.notifications.tool_call_progress(
-                    tool_call_id=tool_call_id,
-                    status="failed",
-                    raw_output=error_msg,
-                )
-
-        except Exception as e:
-            error_msg = f"Failed to spawn agent '{agent_name}': {e}"
-            logger.exception("Spawn command error", error=str(e))
-            raise CommandError(error_msg) from e
-
-
-async def _handle_subagent_event(
-    event: RichAgentStreamEvent[Any],
-    tool_call_id: str,
-    aggregated_content: list[str],
-    session: ACPSession,
-) -> None:
-    """Handle events from spawned subagent and convert to tool_call_progress.
-
-    Args:
-        event: Event from the subagent stream
-        tool_call_id: ID of the tool call box
-        aggregated_content: List to accumulate content for final display
-        session: ACP session for notifications
-    """
-    match event:
-        case (
-            PartStartEvent(part=TextPart(content=delta))
-            | PartDeltaEvent(delta=TextPartDelta(content_delta=delta))
-        ):
-            # Subagent text output → accumulate and update progress
-            aggregated_content.append(delta)
-            await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
-                status="in_progress",
-                content=["".join(aggregated_content)],
-            )
-
-        case (
-            PartStartEvent(part=ThinkingPart(content=delta))
-            | PartDeltaEvent(delta=ThinkingPartDelta(content_delta=delta))
-        ):
-            # Subagent thinking → show thinking indicator
-            if delta:
-                thinking_text = f"💭 {delta}"
-                aggregated_content.append(thinking_text)
-                await session.notifications.tool_call_progress(
-                    tool_call_id=tool_call_id,
-                    status="in_progress",
-                    content=["".join(aggregated_content)],
-                )
-
-        case FunctionToolCallEvent(part=part):
-            # Subagent calls a tool → show nested tool call
-            tool_text = f"\n🔧 Using tool: {part.tool_name}\n"
-            aggregated_content.append(tool_text)
-            await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
-                status="in_progress",
-                content=["".join(aggregated_content)],
-            )
-
-        case FunctionToolResultEvent(
-            result=ToolReturnPart(content=content, tool_name=tool_name),
-        ):
-            # Subagent tool completes → show tool result
-            result_text = f"✅ {tool_name}: {content}\n"
-            aggregated_content.append(result_text)
-            await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
-                status="in_progress",
-                content=["".join(aggregated_content)],
-            )
-
-        case FunctionToolResultEvent(
-            result=RetryPromptPart(tool_name=tool_name) as result,
-        ):
-            # Tool call failed and needs retry
-            error_message = result.model_response()
-            error_text = f"❌ {tool_name or 'unknown'}: Error: {error_message}\n"
-            aggregated_content.append(error_text)
-            await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
-                status="in_progress",
-                content=["".join(aggregated_content)],
-            )
-
-        case ToolCallProgressEvent(message=message, tool_name=tool_name):
-            # Progress event from tools
-            if message:
-                progress_text = f"🔄 {tool_name}: {message}\n"
-                aggregated_content.append(progress_text)
-                await session.notifications.tool_call_progress(
-                    tool_call_id=tool_call_id,
-                    status="in_progress",
-                    content=["".join(aggregated_content)],
-                )
-
-        case (
-            PartStartEvent()
-            | PartDeltaEvent(delta=ToolCallPartDelta())
-            | FinalResultEvent()
-            | StreamCompleteEvent()
-        ):
-            pass  # These events don't need special handling
-
-        case _:
-            logger.debug("Unhandled subagent event", event_type=type(event).__name__)