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

agentpool/mcp_server/__init__.py

@@ -3,7 +3,6 @@
 from agentpool.mcp_server.client import MCPClient
 from agentpool.mcp_server.tool_bridge import (
     BridgeConfig,
-    ToolBridgeRegistry,
     ToolManagerBridge,
     create_tool_bridge,
 )
@@ -11,7 +10,6 @@ from agentpool.mcp_server.tool_bridge import (
 __all__ = [
     "BridgeConfig",
     "MCPClient",
-    "ToolBridgeRegistry",
     "ToolManagerBridge",
     "create_tool_bridge",
 ]

agentpool/mcp_server/client.py

@@ -28,7 +28,7 @@ from agentpool.log import get_logger
 from agentpool.mcp_server.constants import MCP_TO_LOGGING
 from agentpool.mcp_server.helpers import extract_text_content, mcp_tool_to_fn_schema
 from agentpool.mcp_server.message_handler import MCPMessageHandler
-from agentpool.tools.base import Tool
+from agentpool.tools.base import FunctionTool
 from agentpool.utils.signatures import create_modified_signature
 from agentpool_config.mcp_server import (
     SSEMCPServerConfig,
@@ -56,6 +56,7 @@ if TYPE_CHECKING:
         Implementation,
         Prompt as MCPPrompt,
         Resource as MCPResource,
+        ResourceTemplate,
         TextResourceContents,
         Tool as MCPTool,
     )
@@ -106,12 +107,17 @@ class MCPClient:
         """Check if client is connected by examining session state."""
         return self._client.is_connected()
 
+    def _ensure_connected(self) -> None:
+        """Ensure client is connected, raise RuntimeError if not."""
+        if not self.connected:
+            msg = "Not connected to MCP server"
+            raise RuntimeError(msg)
+
     async def __aenter__(self) -> Self:
         """Enter context manager."""
         try:
             # First attempt with configured auth
             await self._client.__aenter__()  # type: ignore[no-untyped-call]
-
         except Exception as first_error:
             # OAuth fallback for HTTP/SSE if not already using OAuth
             if not isinstance(self.config, StdioMCPServerConfig) and not self.config.auth.oauth:
@@ -237,26 +243,24 @@ class MCPClient:
         )
 
     async def list_tools(self) -> list[MCPTool]:
-        """Get available tools directly from the server."""
-        if not self.connected:
-            msg = "Not connected to MCP server"
-            raise RuntimeError(msg)
+        """Get available tools directly from the server.
 
+        Tools are filtered based on the server config's enabled_tools/disabled_tools settings.
+        """
+        self._ensure_connected()
         try:
             tools = await self._client.list_tools()
-            logger.debug("Listed tools from MCP server", num_tools=len(tools))
+            filtered = [t for t in tools if self.config.is_tool_allowed(t.name)]
+            logger.debug("Listed tools from MCP server", total=len(tools), filtered=len(filtered))
         except Exception as e:  # noqa: BLE001
             logger.warning("Failed to list tools", error=e)
             return []
         else:
-            return tools
+            return filtered
 
     async def list_prompts(self) -> list[MCPPrompt]:
         """Get available prompts from the server."""
-        if not self.connected:
-            msg = "Not connected to MCP server"
-            raise RuntimeError(msg)
-
+        self._ensure_connected()
         try:
             return await self._client.list_prompts()
         except Exception as e:  # noqa: BLE001
@@ -265,31 +269,69 @@ class MCPClient:
 
     async def list_resources(self) -> list[MCPResource]:
         """Get available resources from the server."""
-        if not self.connected:
-            msg = "Not connected to MCP server"
-            raise RuntimeError(msg)
-
+        self._ensure_connected()
         try:
             return await self._client.list_resources()
         except Exception as e:
             msg = f"Failed to list resources: {e}"
             raise RuntimeError(msg) from e
 
+    async def list_resource_templates(self) -> list[ResourceTemplate]:
+        """Get available resource templates from the server.
+
+        Resource templates are URI patterns with placeholders that can be
+        expanded to create concrete resource URIs.
+
+        Example template: "file:///{path}" -> expand with path="config.json"
+        -> "file:///config.json" which can then be read.
+
+        TODO: Integrate resource templates into the ResourceInfo system.
+        Currently templates are separate from resources - we need to decide:
+        - Should templates appear in list_resources() with a flag?
+        - Should ResourceInfo.read() accept kwargs for template expansion?
+        - Should templates have their own ResourceTemplateInfo class?
+
+        Returns:
+            List of resource templates from the server
+        """
+        self._ensure_connected()
+        try:
+            return await self._client.list_resource_templates()
+        except Exception as e:
+            msg = f"Failed to list resource templates: {e}"
+            raise RuntimeError(msg) from e
+
+    async def read_resource(self, uri: str) -> list[TextResourceContents | BlobResourceContents]:
+        """Read resource content by URI.
+
+        Args:
+            uri: URI of the resource to read
+
+        Returns:
+            List of resource contents (text or blob)
+
+        Raises:
+            RuntimeError: If not connected or read fails
+        """
+        self._ensure_connected()
+        try:
+            return await self._client.read_resource(uri)
+        except Exception as e:
+            msg = f"Failed to read resource {uri!r}: {e}"
+            raise RuntimeError(msg) from e
+
     async def get_prompt(
         self, name: str, arguments: dict[str, str] | None = None
     ) -> GetPromptResult:
         """Get a specific prompt's content."""
-        if not self.connected:
-            msg = "Not connected to MCP server"
-            raise RuntimeError(msg)
-
+        self._ensure_connected()
         try:
             return await self._client.get_prompt_mcp(name, arguments)
         except Exception as e:
             msg = f"Failed to get prompt {name!r}: {e}"
             raise RuntimeError(msg) from e
 
-    def convert_tool(self, tool: MCPTool) -> Tool:
+    def convert_tool(self, tool: MCPTool) -> FunctionTool:
         """Create a properly typed callable from MCP tool schema."""
 
         async def tool_callable(
@@ -310,7 +352,6 @@ class MCPClient:
         schema = mcp_tool_to_fn_schema(tool)
         fn_schema = FunctionSchema.from_dict(schema)
         sig = fn_schema.to_python_signature()
-
         tool_callable.__signature__ = create_modified_signature(  # type: ignore[attr-defined]
             sig, inject={"ctx": RunContext, "agent_ctx": AgentContext}
         )
@@ -322,7 +363,7 @@ class MCPClient:
         tool_callable.__annotations__ = annotations
         tool_callable.__name__ = tool.name
         tool_callable.__doc__ = tool.description or "No description provided."
-        return Tool.from_callable(tool_callable, source="mcp")
+        return FunctionTool.from_callable(tool_callable, source="mcp")
 
     async def call_tool(
         self,
@@ -332,10 +373,7 @@ class MCPClient:
         agent_ctx: AgentContext[Any] | None = None,
     ) -> ToolReturn | str | Any:
         """Call an MCP tool with full PydanticAI return type support."""
-        if not self.connected:
-            msg = "Not connected to MCP server"
-            raise RuntimeError(msg)
-
+        self._ensure_connected()
         # Create progress handler that bridges to AgentContext if available
         progress_handler = None
         if agent_ctx:
@@ -376,9 +414,18 @@ class MCPClient:
 
             self._current_elicitation_handler = elicitation_handler
 
+        # Prepare metadata to pass tool_call_id to the MCP server
+        meta = None
+        if agent_ctx and agent_ctx.tool_call_id:
+            # Use the same key that tool_bridge expects: "claudecode/toolUseId"
+            # Ensure it's a string (handles both real values and mocks)
+            tool_call_id = str(agent_ctx.tool_call_id) if agent_ctx.tool_call_id else None
+            if tool_call_id:
+                meta = {"claudecode/toolUseId": tool_call_id}
+
         try:
             result = await self._client.call_tool(
-                name, arguments, progress_handler=progress_handler
+                name, arguments, progress_handler=progress_handler, meta=meta
             )
             content = await self._from_mcp_content(result.content)
             # Decision logic for return type
@@ -415,10 +462,7 @@ class MCPClient:
 if __name__ == "__main__":
     path = "/home/phil65/dev/oss/agentpool/tests/mcp_server/server.py"
     # path = Path(__file__).parent / "test_mcp_server.py"
-    config = StdioMCPServerConfig(
-        command="uv",
-        args=["run", str(path)],
-    )
+    config = StdioMCPServerConfig(command="uv", args=["run", str(path)])
 
     async def main() -> None:
         async with MCPClient(config=config) as mcp_client:

agentpool/mcp_server/conversions.py

@@ -5,16 +5,6 @@ from __future__ import annotations
 import base64
 from typing import TYPE_CHECKING, Any, assert_never
 
-from mcp.types import (
-    AudioContent,
-    BlobResourceContents,
-    EmbeddedResource,
-    ImageContent,
-    PromptMessage,
-    ResourceLink,
-    TextContent,
-    TextResourceContents,
-)
 from pydantic_ai import (
     AudioUrl,
     BinaryContent,
@@ -35,9 +25,14 @@ if TYPE_CHECKING:
     from collections.abc import Sequence
 
     from fastmcp import Client
-    from mcp.types import ContentBlock
-    from pydantic_ai import ModelRequestPart, ModelResponsePart
-
+    from mcp.types import (
+        BlobResourceContents,
+        ContentBlock,
+        PromptMessage,
+        SamplingMessage,
+        TextResourceContents,
+    )
+    from pydantic_ai import ModelRequestPart, ModelResponsePart, UserContent
 
 logger = get_logger(__name__)
 
@@ -46,6 +41,13 @@ def to_mcp_messages(
     part: ModelRequestPart | ModelResponsePart,
 ) -> list[PromptMessage]:
     """Convert internal PromptMessage to MCP PromptMessage."""
+    from mcp.types import (
+        AudioContent,
+        ImageContent,
+        PromptMessage,
+        TextContent,
+    )
+
     messages = []
     match part:
         case UserPromptPart(content=str() as c):
@@ -94,6 +96,24 @@ def _url_from_mime_type(uri: str, mime_type: str | None) -> FileUrl:
     return DocumentUrl(url=uri)
 
 
+def sampling_messages_to_user_content(msgs: list[SamplingMessage]) -> list[UserContent]:
+    from mcp import types
+
+    # Convert messages to prompts for the agent
+    prompts: list[UserContent] = []
+    for mcp_msg in msgs:
+        match mcp_msg.content:
+            case types.TextContent(text=text):
+                prompts.append(text)
+            case types.ImageContent(data=data, mimeType=mime_type):
+                binary_data = base64.b64decode(data)
+                prompts.append(BinaryImage(data=binary_data, media_type=mime_type))
+            case types.AudioContent(data=data, mimeType=mime_type):
+                binary_data = base64.b64decode(data)
+                prompts.append(BinaryContent(data=binary_data, media_type=mime_type))
+    return prompts
+
+
 async def from_mcp_content(
     mcp_content: Sequence[ContentBlock | TextResourceContents | BlobResourceContents],
     client: Client[Any] | None = None,
@@ -103,6 +123,16 @@ async def from_mcp_content(
     If a FastMCP client is given, this function will try to resolve the ResourceLinks.
 
     """
+    from mcp.types import (
+        AudioContent,
+        BlobResourceContents,
+        EmbeddedResource,
+        ImageContent,
+        ResourceLink,
+        TextContent,
+        TextResourceContents,
+    )
+
     contents: list[Any] = []
 
     for block in mcp_content:
@@ -151,6 +181,17 @@ async def from_mcp_content(
 
 
 def content_block_as_text(content: ContentBlock) -> str:
+
+    from mcp.types import (
+        AudioContent,
+        BlobResourceContents,
+        EmbeddedResource,
+        ImageContent,
+        ResourceLink,
+        TextContent,
+        TextResourceContents,
+    )
+
     match content:
         case TextContent(text=text):
             return text

agentpool/mcp_server/manager.py

@@ -3,12 +3,10 @@
 from __future__ import annotations
 
 import asyncio
-import base64
 from contextlib import AsyncExitStack
 from typing import TYPE_CHECKING, Any, Self, cast
 
 import anyio
-from pydantic_ai import BinaryContent, BinaryImage, UsageLimits
 
 from agentpool.log import get_logger
 from agentpool.resource_providers import AggregatingResourceProvider, ResourceProvider
@@ -23,7 +21,6 @@ if TYPE_CHECKING:
     from mcp import types
     from mcp.shared.context import RequestContext
     from mcp.types import SamplingMessage
-    from pydantic_ai import UserContent
 
     from agentpool_config.mcp_server import MCPServerConfig
 
@@ -38,6 +35,7 @@ class MCPManager:
         self,
         name: str = "mcp",
         owner: str | None = None,
+        sampling_model: str = "openai:gpt-5-nano",
         servers: Sequence[MCPServerConfig | str] | None = None,
         accessible_roots: list[str] | None = None,
     ) -> None:
@@ -47,6 +45,7 @@ class MCPManager:
         for server in servers or []:
             self.add_server_config(server)
         self.providers: list[MCPResourceProvider] = []
+        self.sampling_model = sampling_model
         self.aggregating_provider = AggregatingResourceProvider(
             providers=cast(list[ResourceProvider], self.providers),
             name=f"{name}_aggregated",
@@ -64,7 +63,7 @@ class MCPManager:
 
     async def __aenter__(self) -> Self:
         try:
-            if tasks := [self._setup_server(server) for server in self.servers]:
+            if tasks := [self.setup_server(server) for server in self.servers]:
                 await asyncio.gather(*tasks)
         except Exception as e:
             await self.__aexit__(type(e), e, e.__traceback__)
@@ -88,45 +87,52 @@ class MCPManager:
         context: RequestContext[Any, Any, Any],
     ) -> str:
         """Handle MCP sampling by creating a new agent with specified preferences."""
-        from mcp import types
-
         from agentpool.agents import Agent
+        from agentpool.mcp_server.conversions import sampling_messages_to_user_content
 
-        # Convert messages to prompts for the agent
-        prompts: list[UserContent] = []
-        for mcp_msg in messages:
-            match mcp_msg.content:
-                case types.TextContent(text=text):
-                    prompts.append(text)
-                case types.ImageContent(data=data, mimeType=mime_type):
-                    binary_data = base64.b64decode(data)
-                    prompts.append(BinaryImage(data=binary_data, media_type=mime_type))
-                case types.AudioContent(data=data, mimeType=mime_type):
-                    binary_data = base64.b64decode(data)
-                    prompts.append(BinaryContent(data=binary_data, media_type=mime_type))
-
-        # Extract model from preferences
-        model = None
+        prompts = sampling_messages_to_user_content(messages)
+        model = self.sampling_model
         if (prefs := params.modelPreferences) and prefs.hints and prefs.hints[0].name:
-            model = prefs.hints[0].name
+            model = prefs.hints[0].name  # Extract model from preferences
         # Create usage limits from sampling parameters
-        limits = UsageLimits(output_tokens_limit=params.maxTokens, request_limit=1)
+        # limits = UsageLimits(output_tokens_limit=params.maxTokens, request_limit=1)
+        # TODO: Re-add per-turn usage_limits once implemented for all agents
         # TODO: Apply temperature from params.temperature
         sys_prompt = params.systemPrompt or ""
         agent = Agent(name="sampling-agent", model=model, system_prompt=sys_prompt, session=False)
         try:
             async with agent:
-                result = await agent.run(*prompts, store_history=False, usage_limits=limits)
+                result = await agent.run(*prompts, store_history=False)
                 return result.content
 
         except Exception as e:
             logger.exception("Sampling failed")
             return f"Sampling failed: {e!s}"
 
-    async def _setup_server(self, config: MCPServerConfig) -> None:
-        """Set up a single MCP server resource provider."""
+    async def setup_server(
+        self, config: MCPServerConfig, *, add_to_config: bool = False
+    ) -> MCPResourceProvider | None:
+        """Set up a single MCP server resource provider.
+
+        Args:
+            config: MCP server configuration
+            add_to_config: If True, also add config to self.servers list and
+                          raise ValueError if config is disabled
+
+        Returns:
+            The provider if created, None if config is disabled (only when add_to_config=False)
+
+        Raises:
+            ValueError: If add_to_config=True and config is disabled
+        """
         if not config.enabled:
-            return
+            if add_to_config:
+                msg = f"Server config {config.client_id} is disabled"
+                raise ValueError(msg)
+            return None
+
+        if add_to_config:
+            self.add_server_config(config)
 
         provider = MCPResourceProvider(
             server=config,
@@ -138,6 +144,7 @@ class MCPManager:
         )
         provider = await self.exit_stack.enter_async_context(provider)
         self.providers.append(provider)
+        return provider
 
     def get_mcp_providers(self) -> list[MCPResourceProvider]:
         """Get all MCP resource providers managed by this manager."""
@@ -147,33 +154,6 @@ class MCPManager:
         """Get the aggregating provider that contains all MCP providers."""
         return self.aggregating_provider
 
-    async def setup_server_runtime(self, config: MCPServerConfig) -> MCPResourceProvider:
-        """Set up a single MCP server at runtime while manager is running.
-
-        Returns:
-            The newly created and initialized MCPResourceProvider
-        """
-        if not config.enabled:
-            msg = f"Server config {config.client_id} is disabled"
-            raise ValueError(msg)
-
-        # Add the config first
-        self.add_server_config(config)
-        provider = MCPResourceProvider(
-            server=config,
-            name=f"{self.name}_{config.client_id}",
-            owner=self.owner,
-            source="pool" if self.owner == "pool" else "node",
-            sampling_callback=self._sampling_callback,
-            accessible_roots=self._accessible_roots,
-        )
-        provider = await self.exit_stack.enter_async_context(provider)
-        self.providers.append(provider)
-        # Note: AggregatingResourceProvider automatically sees the new provider
-        # since it references self.providers list
-
-        return provider
-
     async def cleanup(self) -> None:
         """Clean up all MCP connections and providers."""
         try:

agentpool/mcp_server/registries/official_registry_client.py

@@ -51,6 +51,9 @@ class RegistryTransport(Schema):
     url: str | None = None
     """URL for HTTP transports."""
 
+    headers: list[dict[str, Any]] = Field(default_factory=list)
+    """Request headers."""
+
 
 class RegistryPackage(Schema):
     """Package information for installing an MCP server."""
@@ -75,6 +78,9 @@ class RegistryPackage(Schema):
     package_arguments: list[dict[str, Any]] = Field(default_factory=list, alias="packageArguments")
     """Package arguments."""
 
+    runtime_arguments: list[dict[str, Any]] = Field(default_factory=list, alias="runtimeArguments")
+    """Runtime arguments."""
+
     runtime_hint: str | None = Field(None, alias="runtimeHint")
     """Runtime hint."""
 
@@ -97,6 +103,22 @@ class RegistryRemote(Schema):
     headers: list[dict[str, Any]] = Field(default_factory=list)
     """Request headers."""
 
+    variables: dict[str, Any] = Field(default_factory=dict)
+    """URL template variables."""
+
+
+class RegistryIcon(Schema):
+    """Icon configuration for a server."""
+
+    src: str
+    """Icon source URL."""
+
+    theme: str | None = None
+    """Theme variant (light, dark)."""
+
+    mime_type: str | None = Field(None, alias="mimeType")
+    """MIME type of the icon (e.g., image/png)."""
+
 
 class RegistryServer(Schema):
     """MCP server entry from the registry."""
@@ -110,7 +132,7 @@ class RegistryServer(Schema):
     version: str
     """Server version."""
 
-    repository: RegistryRepository
+    repository: RegistryRepository | None = None
     """Repository information."""
 
     packages: list[RegistryPackage] = Field(default_factory=list)
@@ -122,6 +144,18 @@ class RegistryServer(Schema):
     schema_: str | None = Field(None, alias="$schema")
     """JSON schema URL."""
 
+    title: str | None = None
+    """Human-readable display title."""
+
+    website_url: str | None = Field(None, alias="websiteUrl")
+    """Website URL for documentation."""
+
+    icons: list[RegistryIcon] = Field(default_factory=list)
+    """Server icons for different themes."""
+
+    meta: dict[str, Any] = Field(default_factory=dict, alias="_meta")
+    """Internal metadata (can appear at server level too)."""
+
     def get_preferred_transport(self) -> TransportType:
         """Select optimal transport method based on availability and performance."""
         # Prefer local packages for better performance/security