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

agentpool/mcp_server/tool_bridge.py

@@ -15,18 +15,15 @@ import asyncio
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, field, replace
 import inspect
-from typing import TYPE_CHECKING, Any, Literal, Self, get_args, get_origin
+from typing import TYPE_CHECKING, Any, Self, get_args, get_origin
 from uuid import uuid4
 
 import anyio
-from fastmcp import FastMCP
-from fastmcp.tools import Tool as FastMCPTool
-from llmling_models.models.helpers import infer_model
 from pydantic import BaseModel, HttpUrl
 
-from agentpool.agents import Agent, ClaudeCodeAgent
-from agentpool.agents.acp_agent.acp_agent import ACPAgent
+from agentpool.agents import Agent
 from agentpool.log import get_logger
+from agentpool.resource_providers import ResourceChangeEvent
 from agentpool.utils.signatures import filter_schema_params, get_params_matching_predicate
 
 
@@ -34,16 +31,18 @@ if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Callable
 
     from claude_agent_sdk.types import McpServerConfig
-    from fastmcp import Context
+    from fastmcp import Context, FastMCP
     from fastmcp.tools.tool import ToolResult
     from pydantic_ai import RunContext
     from uvicorn import Server
 
-    from acp.schema.mcp import HttpMcpServer, SseMcpServer
+    from acp.schema.mcp import HttpMcpServer
     from agentpool.agents import AgentContext
     from agentpool.agents.base_agent import BaseAgent
     from agentpool.tools.base import Tool
 
+_ = ResourceChangeEvent  # Used at runtime in method signature
+
 
 logger = get_logger(__name__)
 
@@ -130,11 +129,11 @@ def _create_stub_run_context(ctx: AgentContext[Any]) -> RunContext[Any]:
     match ctx.agent:
         case Agent():
             model = ctx.agent._model or TestModel()
-        case ACPAgent() | ClaudeCodeAgent():
-            try:
-                model = infer_model(ctx.agent.model_name or "test")
-            except Exception:  # noqa: BLE001
-                model = TestModel()
+        # case ACPAgent() | ClaudeCodeAgent():
+        #     try:
+        #         model = infer_model(ctx.agent.model_name or "test")
+        #     except Exception:
+        #         model = TestModel()
         case _:
             model = TestModel()
     # Create a minimal usage object
@@ -153,25 +152,35 @@ def _convert_to_tool_result(result: Any) -> ToolResult:
     """Convert a tool's return value to a FastMCP ToolResult.
 
     Handles different result types appropriately:
-    - ToolResult: Pass through unchanged
+    - FastMCP ToolResult: Pass through unchanged
+    - AgentPool ToolResult: Convert to FastMCP format
     - dict: Use as structured_content (enables programmatic access by clients)
     - Pydantic models: Serialize to dict for structured_content
     - Other types: Pass to ToolResult(content=...) which handles conversion internally
     """
-    from fastmcp.tools.tool import ToolResult
+    from fastmcp.tools.tool import ToolResult as FastMCPToolResult
+
+    from agentpool.tools.base import ToolResult as AgentPoolToolResult
 
-    # Already a ToolResult - pass through
-    if isinstance(result, ToolResult):
+    # Already a FastMCP ToolResult - pass through
+    if isinstance(result, FastMCPToolResult):
         return result
+    # AgentPool ToolResult - convert to FastMCP format
+    if isinstance(result, AgentPoolToolResult):
+        return FastMCPToolResult(
+            content=result.content,
+            structured_content=result.structured_content,
+            meta=result.metadata,
+        )
     # Dict - use as structured_content (FastMCP auto-populates content as JSON)
     if isinstance(result, dict):
-        return ToolResult(structured_content=result)
+        return FastMCPToolResult(structured_content=result)
     # Pydantic model - serialize to dict for structured_content
     if isinstance(result, BaseModel):
-        return ToolResult(structured_content=result.model_dump(mode="json"))
+        return FastMCPToolResult(structured_content=result.model_dump(mode="json"))
     # All other types (str, list, ContentBlock, Image, None, primitives, etc.)
     # ToolResult's internal _convert_to_content handles these correctly
-    return ToolResult(content=result if result is not None else "")
+    return FastMCPToolResult(content=result if result is not None else "")
 
 
 def _extract_tool_call_id(context: Context | None) -> str:
@@ -209,9 +218,6 @@ class BridgeConfig:
     port: int = 0
     """Port to bind to (0 = auto-select available port)."""
 
-    transport: Literal["sse", "streamable-http"] = "sse"
-    """Transport protocol: 'sse' or 'streamable-http'."""
-
     server_name: str = "agentpool-toolmanager"
     """Name for the MCP server."""
 
@@ -244,6 +250,9 @@ class ToolManagerBridge:
     config: BridgeConfig = field(default_factory=BridgeConfig)
     """Bridge configuration."""
 
+    current_deps: Any = field(default=None, init=False, repr=False)
+    """Current dependencies for tool invocations (set by run_stream)."""
+
     _mcp: FastMCP | None = field(default=None, init=False, repr=False)
     """FastMCP server instance."""
 
@@ -267,12 +276,18 @@ class ToolManagerBridge:
 
     async def start(self) -> None:
         """Start the HTTP MCP server in the background."""
+        from fastmcp import FastMCP
+
         self._mcp = FastMCP(name=self.config.server_name)
         await self._register_tools()
+        self._subscribe_to_tool_changes()
         await self._start_server()
 
     async def stop(self) -> None:
         """Stop the HTTP MCP server."""
+        # Unsubscribe from tool changes
+        self._unsubscribe_from_tool_changes()
+
         if self._server:
             self._server.should_exit = True
             if self._server_task:
@@ -288,6 +303,75 @@ class ToolManagerBridge:
         self._actual_port = None
         logger.info("ToolManagerBridge stopped")
 
+    def _subscribe_to_tool_changes(self) -> None:
+        """Subscribe to tool changes from all providers via signals."""
+        for provider in self.node.tools.providers:
+            provider.tools_changed.connect(self._on_tools_changed)
+
+    def _unsubscribe_from_tool_changes(self) -> None:
+        """Disconnect from tool change signals on all providers."""
+        for provider in self.node.tools.providers:
+            provider.tools_changed.disconnect(self._on_tools_changed)
+
+    async def _on_tools_changed(self, event: ResourceChangeEvent) -> None:
+        """Handle tool changes from a provider."""
+        logger.info(
+            "Tools changed in provider, refreshing MCP tools",
+            provider=event.provider_name,
+            provider_kind=event.provider_kind,
+        )
+        if self._mcp:
+            await self._refresh_tools()
+
+    async def _refresh_tools(self) -> None:
+        """Refresh tools registered with the MCP server.
+
+        Uses FastMCP's add_tool/remove_tool API which automatically sends
+        ToolListChanged notifications when called within a request context.
+
+        Note: FastMCP only sends notifications when inside a request context
+        (ContextVar-based). Outside of requests, tools are updated but clients
+        won't receive a push notification - they'll see changes on next list_tools.
+
+        Future improvement: Access StreamableHTTPSessionManager._server_instances
+        to broadcast ToolListChanged to all connected sessions regardless of context.
+        """
+        if not self._mcp:
+            return
+
+        # Get current and new tool sets
+        # Support both old and new FastMCP API
+        if hasattr(self._mcp, "_tool_manager"):
+            # Old API (<=2.12.4): direct access to _tool_manager
+            current_names = set(self._mcp._tool_manager._tools.keys())
+        elif hasattr(self._mcp, "_local_provider"):
+            # New API (git): tools stored in _local_provider._components
+            # Keys are prefixed with 'tool:', e.g., 'tool:bash'
+            current_names = {
+                key.removeprefix("tool:")
+                for key in self._mcp._local_provider._components
+                if key.startswith("tool:")
+            }
+        else:
+            # Fallback: use async get_tools() method
+            current_tools = await self._mcp.get_tools()
+            current_names = {t.name for t in current_tools}  # type: ignore[attr-defined]
+        new_tools = await self.node.tools.get_tools(state="enabled")
+        new_names = {t.name for t in new_tools}
+
+        # Remove tools that are no longer present
+        for name in current_names - new_names:
+            with suppress(Exception):
+                self._mcp.remove_tool(name)
+
+        # Add/update tools
+        for tool in new_tools:
+            if tool.name in current_names:
+                # Remove and re-add to update
+                with suppress(Exception):
+                    self._mcp.remove_tool(tool.name)
+            self._register_single_tool(tool)
+
     @property
     def port(self) -> int:
         """Get the actual port the server is running on."""
@@ -299,19 +383,16 @@ class ToolManagerBridge:
     @property
     def url(self) -> str:
         """Get the server URL."""
-        path = "/sse" if self.config.transport == "sse" else "/mcp"
-        return f"http://{self.config.host}:{self.port}{path}"
+        return f"http://{self.config.host}:{self.port}/mcp"
 
-    def get_mcp_server_config(self) -> HttpMcpServer | SseMcpServer:
+    def get_mcp_server_config(self) -> HttpMcpServer:
         """Get ACP-compatible MCP server configuration.
 
         Returns config suitable for passing to ACP agent's NewSessionRequest.
         """
-        from acp.schema import HttpMcpServer, SseMcpServer
+        from acp.schema import HttpMcpServer
 
         url = HttpUrl(self.url)
-        if self.config.transport == "sse":
-            return SseMcpServer(name=self.config.server_name, url=url, headers=[])
         return HttpMcpServer(name=self.config.server_name, url=url, headers=[])
 
     def get_claude_mcp_server_config(self) -> dict[str, McpServerConfig]:
@@ -354,6 +435,75 @@ class ToolManagerBridge:
         """Register a single tool with the FastMCP server."""
         if not self._mcp:
             return
+        from fastmcp.tools import Tool as FastMCPTool
+
+        class _BridgeTool(FastMCPTool):
+            """Custom FastMCP Tool that wraps a agentpool Tool.
+
+            This allows us to use our own schema and invoke tools with AgentContext.
+            """
+
+            def __init__(self, tool: Tool, bridge: ToolManagerBridge) -> None:
+                # Get input schema from our tool
+                schema = tool.schema["function"]
+                input_schema = schema.get("parameters", {"type": "object", "properties": {}})
+                # Filter out context parameters - they're auto-injected by the bridge
+                context_params = _get_context_param_names(tool.get_callable())
+                run_context_params = _get_run_context_param_names(tool.get_callable())
+                all_context_params = context_params | run_context_params
+                filtered_schema = filter_schema_params(input_schema, all_context_params)
+                desc = tool.description or "No description"
+                super().__init__(name=tool.name, description=desc, parameters=filtered_schema)
+                # Set these AFTER super().__init__() to avoid being overwritten
+                self._tool = tool
+                self._bridge = bridge
+
+            async def run(self, arguments: dict[str, Any]) -> ToolResult:
+                """Execute the wrapped tool with context bridging."""
+                from fastmcp.server.dependencies import get_context
+
+                # Get FastMCP context from context variable (not passed as parameter)
+                try:
+                    mcp_context: Context | None = get_context()
+                except LookupError:
+                    mcp_context = None
+
+                # Try to get Claude's original tool_call_id from request metadata
+                tool_call_id = _extract_tool_call_id(mcp_context)
+                # Get deps from bridge (set by run_stream on the agent)
+                current_deps = self._bridge.current_deps
+                # Create context with tool-specific metadata from node's context.
+                ctx = replace(
+                    self._bridge.node.get_context(data=current_deps),
+                    tool_name=self._tool.name,
+                    tool_call_id=tool_call_id,
+                    tool_input=arguments,
+                )
+                # Invoke with context - copy arguments since invoke_tool_with_context
+                # modifies kwargs in-place to inject context parameters
+                result = await self._bridge.invoke_tool_with_context(
+                    self._tool, ctx, arguments.copy()
+                )
+
+                # Emit metadata event for ClaudeCodeAgent to correlate
+                # (works around Claude SDK stripping MCP _meta field)
+                from agentpool.agents.events import ToolResultMetadataEvent
+                from agentpool.tools.base import ToolResult as AgentPoolToolResult
+
+                if isinstance(result, AgentPoolToolResult) and result.metadata:
+                    logger.info(
+                        "Emitting ToolResultMetadataEvent",
+                        tool_call_id=tool_call_id,
+                        metadata_keys=list(result.metadata.keys()),
+                    )
+                    event = ToolResultMetadataEvent(
+                        tool_call_id=tool_call_id,
+                        metadata=result.metadata,
+                    )
+                    await ctx.events.emit_event(event)
+
+                return _convert_to_tool_result(result)
+
         # Create a custom FastMCP Tool that wraps our tool
         bridge_tool = _BridgeTool(tool=tool, bridge=self)
         self._mcp.add_tool(bridge_tool)
@@ -368,7 +518,7 @@ class ToolManagerBridge:
 
         Handles tools that expect AgentContext, RunContext, or neither.
         """
-        fn = tool.callable
+        fn = tool.get_callable()
 
         # Inject AgentContext parameters
         context_param_names = _get_context_param_names(fn)
@@ -408,63 +558,18 @@ class ToolManagerBridge:
                 port = s.getsockname()[1]
         self._actual_port = port
         # Create the ASGI app
-        app = self._mcp.http_app(transport=self.config.transport)
+        app = self._mcp.http_app(transport="http")
         # Configure uvicorn
-        cfg = uvicorn.Config(app=app, host=self.config.host, port=port, log_level="warning")
+        cfg = uvicorn.Config(
+            app=app, host=self.config.host, port=port, log_level="warning", ws="websockets-sansio"
+        )
         self._server = uvicorn.Server(cfg)
         # Start server in background task
         name = f"mcp-bridge-{self.config.server_name}"
         self._server_task = asyncio.create_task(self._server.serve(), name=name)
         await anyio.sleep(0.1)  # Wait briefly for server to start
         msg = "ToolManagerBridge started"
-        logger.info(msg, url=self.url, transport=self.config.transport)
-
-
-class _BridgeTool(FastMCPTool):
-    """Custom FastMCP Tool that wraps a agentpool Tool.
-
-    This allows us to use our own schema and invoke tools with AgentContext.
-    """
-
-    def __init__(self, tool: Tool, bridge: ToolManagerBridge) -> None:
-        # Get input schema from our tool
-        schema = tool.schema["function"]
-        input_schema = schema.get("parameters", {"type": "object", "properties": {}})
-        # Filter out context parameters - they're auto-injected by the bridge
-        context_params = _get_context_param_names(tool.callable)
-        run_context_params = _get_run_context_param_names(tool.callable)
-        all_context_params = context_params | run_context_params
-        filtered_schema = filter_schema_params(input_schema, all_context_params)
-        desc = tool.description or "No description"
-        super().__init__(name=tool.name, description=desc, parameters=filtered_schema)
-        # Set these AFTER super().__init__() to avoid being overwritten
-        self._tool = tool
-        self._bridge = bridge
-
-    async def run(self, arguments: dict[str, Any]) -> ToolResult:
-        """Execute the wrapped tool with context bridging."""
-        from fastmcp.server.dependencies import get_context
-
-        # Get FastMCP context from context variable (not passed as parameter)
-        try:
-            mcp_context: Context | None = get_context()
-        except LookupError:
-            mcp_context = None
-
-        # Try to get Claude's original tool_call_id from request metadata
-        tool_call_id = _extract_tool_call_id(mcp_context)
-        # Create context with tool-specific metadata from node's context.
-        ctx = replace(
-            self._bridge.node.get_context(),
-            tool_name=self._tool.name,
-            tool_call_id=tool_call_id,
-            tool_input=arguments,
-        )
-
-        # Invoke with context - copy arguments since invoke_tool_with_context
-        # modifies kwargs in-place to inject context parameters
-        result = await self._bridge.invoke_tool_with_context(self._tool, ctx, arguments.copy())
-        return _convert_to_tool_result(result)
+        logger.info(msg, url=self.url)
 
 
 @asynccontextmanager
@@ -473,7 +578,6 @@ async def create_tool_bridge(
     *,
     host: str = "127.0.0.1",
     port: int = 0,
-    transport: Literal["sse", "streamable-http"] = "sse",
 ) -> AsyncIterator[ToolManagerBridge]:
     """Create and start a ToolManagerBridge as a context manager.
 
@@ -481,68 +585,11 @@ async def create_tool_bridge(
         node: The node whose tools to expose
         host: Host to bind to
         port: Port to bind to (0 = auto-select)
-        transport: Transport protocol ('sse' or 'streamable-http')
 
     Yields:
         Running ToolManagerBridge instance
     """
-    config = BridgeConfig(host=host, port=port, transport=transport)
+    config = BridgeConfig(host=host, port=port)
     bridge = ToolManagerBridge(node=node, config=config)
     async with bridge:
         yield bridge
-
-
-class ToolBridgeRegistry:
-    """Registry for managing multiple tool bridges.
-
-    Useful when multiple ACP agents need access to different toolsets.
-    """
-
-    def __init__(self) -> None:
-        self._bridges: dict[str, ToolManagerBridge] = {}
-        self._port_counter = 18000  # Start port range for auto-allocation
-
-    async def create_bridge(self, name: str, node: BaseAgent[Any, Any]) -> ToolManagerBridge:
-        """Create and register a new bridge.
-
-        Args:
-            name: Unique name for this bridge
-            node: The node whose tools to expose
-
-        Returns:
-            Started ToolManagerBridge
-        """
-        if name in self._bridges:
-            msg = f"Bridge {name!r} already exists"
-            raise ValueError(msg)
-
-        config = BridgeConfig(port=self._port_counter, server_name=f"agentpool-{name}")
-        self._port_counter += 1
-
-        bridge = ToolManagerBridge(node=node, config=config)
-        await bridge.start()
-        self._bridges[name] = bridge
-        return bridge
-
-    async def get_bridge(self, name: str) -> ToolManagerBridge:
-        """Get a bridge by name."""
-        if name not in self._bridges:
-            msg = f"Bridge {name!r} not found"
-            raise KeyError(msg)
-        return self._bridges[name]
-
-    async def remove_bridge(self, name: str) -> None:
-        """Stop and remove a bridge."""
-        if name in self._bridges:
-            await self._bridges[name].stop()
-            del self._bridges[name]
-
-    async def close_all(self) -> None:
-        """Stop all bridges."""
-        for bridge in list(self._bridges.values()):
-            await bridge.stop()
-        self._bridges.clear()
-
-    def get_all_mcp_configs(self) -> list[HttpMcpServer | SseMcpServer]:
-        """Get MCP server configs for all active bridges."""
-        return [bridge.get_mcp_server_config() for bridge in self._bridges.values()]

agentpool/messaging/__init__.py

@@ -7,7 +7,6 @@ from agentpool.messaging.messagenode import MessageNode
 from agentpool.messaging.message_history import MessageHistory
 from agentpool.messaging.compaction import (
     CompactionPipeline,
-    CompactionPipelineConfig,
     CompactionStep,
     FilterBinaryContent,
     FilterEmptyMessages,
@@ -32,7 +31,6 @@ __all__ = [
     "ChatMessage",
     "ChatMessageList",
     "CompactionPipeline",
-    "CompactionPipelineConfig",
     "CompactionStep",
     "EventManager",
     "FilterBinaryContent",