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

agentpool/mcp_server/client.py

@@ -237,19 +237,28 @@ class MCPClient:
         )
 
     async def list_tools(self) -> list[MCPTool]:
-        """Get available tools directly from the server."""
+        """Get available tools directly from the server.
+
+        Tools are filtered based on the server config's enabled_tools/disabled_tools settings.
+        """
         if not self.connected:
             msg = "Not connected to MCP server"
             raise RuntimeError(msg)
 
         try:
             tools = await self._client.list_tools()
-            logger.debug("Listed tools from MCP server", num_tools=len(tools))
+            # Filter tools based on config
+            filtered_tools = [t for t in tools if self.config.is_tool_allowed(t.name)]
+            logger.debug(
+                "Listed tools from MCP server",
+                total_tools=len(tools),
+                filtered_tools=len(filtered_tools),
+            )
         except Exception as e:  # noqa: BLE001
             logger.warning("Failed to list tools", error=e)
             return []
         else:
-            return tools
+            return filtered_tools
 
     async def list_prompts(self) -> list[MCPPrompt]:
         """Get available prompts from the server."""

agentpool/mcp_server/manager.py

@@ -64,7 +64,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__)
@@ -123,10 +123,30 @@ class MCPManager:
             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 +158,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 +168,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

@@ -98,6 +98,19 @@ class RegistryRemote(Schema):
     """Request headers."""
 
 
+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."""
 
@@ -122,6 +135,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

agentpool/mcp_server/tool_bridge.py

@@ -21,12 +21,11 @@ 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
 
 
@@ -44,6 +43,8 @@ if TYPE_CHECKING:
     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 +131,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
@@ -244,6 +245,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."""
 
@@ -269,10 +273,14 @@ class ToolManagerBridge:
         """Start the HTTP MCP server in the background."""
         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 +296,60 @@ 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
+        current_names = set(self._mcp._tool_manager._tools.keys())
+        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."""
@@ -410,7 +472,9 @@ class ToolManagerBridge:
         # Create the ASGI app
         app = self._mcp.http_app(transport=self.config.transport)
         # 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}"
@@ -453,9 +517,13 @@ class _BridgeTool(FastMCPTool):
 
         # 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(),
+            self._bridge.node.get_context(data=current_deps),
             tool_name=self._tool.name,
             tool_call_id=tool_call_id,
             tool_input=arguments,
@@ -490,59 +558,3 @@ async def create_tool_bridge(
     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",

agentpool/messaging/compaction.py

@@ -22,7 +22,7 @@ Example:
     compacted = await pipeline.apply(messages)
 
     # Or via config (for YAML)
-    config = CompactionPipelineConfig(steps=[
+    config = CompactionConfig(steps=[
         FilterThinkingConfig(),
         TruncateToolOutputsConfig(max_length=1000),
         KeepLastMessagesConfig(count=10),
@@ -50,9 +50,8 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from dataclasses import dataclass, field, replace
-from typing import TYPE_CHECKING, Annotated, Any, Literal, Self, cast
+from typing import TYPE_CHECKING, Any, Self, cast
 
-from pydantic import BaseModel, Field
 from pydantic_ai import (
     Agent,
     BinaryContent,
@@ -73,6 +72,8 @@ if TYPE_CHECKING:
     from pydantic_ai import ModelRequestPart, ModelResponsePart
     from tokonomics.model_names import ModelId
 
+    from agentpool.messaging.message_history import MessageHistory
+
 # Type aliases
 ModelMessage = ModelRequest | ModelResponse
 MessageSequence = Sequence[ModelMessage]
@@ -629,200 +630,6 @@ class WhenMessageCountExceeds(CompactionStep):
         return list(messages)
 
 
-# =============================================================================
-# Configuration Models - For YAML/JSON configuration
-# =============================================================================
-
-
-class FilterThinkingConfig(BaseModel):
-    """Configuration for FilterThinking step."""
-
-    type: Literal["filter_thinking"] = "filter_thinking"
-
-    def build(self) -> FilterThinking:
-        return FilterThinking()
-
-
-class FilterRetryPromptsConfig(BaseModel):
-    """Configuration for FilterRetryPrompts step."""
-
-    type: Literal["filter_retry_prompts"] = "filter_retry_prompts"
-
-    def build(self) -> FilterRetryPrompts:
-        return FilterRetryPrompts()
-
-
-class FilterBinaryContentConfig(BaseModel):
-    """Configuration for FilterBinaryContent step."""
-
-    type: Literal["filter_binary"] = "filter_binary"
-    keep_references: bool = False
-
-    def build(self) -> FilterBinaryContent:
-        return FilterBinaryContent(keep_references=self.keep_references)
-
-
-class FilterToolCallsConfig(BaseModel):
-    """Configuration for FilterToolCalls step."""
-
-    type: Literal["filter_tools"] = "filter_tools"
-    exclude_tools: list[str] = Field(default_factory=list)
-    include_only: list[str] | None = None
-
-    def build(self) -> FilterToolCalls:
-        return FilterToolCalls(exclude_tools=self.exclude_tools, include_only=self.include_only)
-
-
-class FilterEmptyMessagesConfig(BaseModel):
-    """Configuration for FilterEmptyMessages step."""
-
-    type: Literal["filter_empty"] = "filter_empty"
-
-    def build(self) -> FilterEmptyMessages:
-        return FilterEmptyMessages()
-
-
-class TruncateToolOutputsConfig(BaseModel):
-    """Configuration for TruncateToolOutputs step."""
-
-    type: Literal["truncate_tool_outputs"] = "truncate_tool_outputs"
-    max_length: int = 2000
-    suffix: str = "\n... [truncated]"
-
-    def build(self) -> TruncateToolOutputs:
-        return TruncateToolOutputs(max_length=self.max_length, suffix=self.suffix)
-
-
-class TruncateTextPartsConfig(BaseModel):
-    """Configuration for TruncateTextParts step."""
-
-    type: Literal["truncate_text"] = "truncate_text"
-    max_length: int = 5000
-    suffix: str = "\n... [truncated]"
-
-    def build(self) -> TruncateTextParts:
-        return TruncateTextParts(max_length=self.max_length, suffix=self.suffix)
-
-
-class KeepLastMessagesConfig(BaseModel):
-    """Configuration for KeepLastMessages step."""
-
-    type: Literal["keep_last"] = "keep_last"
-    count: int = 10
-    count_pairs: bool = True
-
-    def build(self) -> KeepLastMessages:
-        return KeepLastMessages(count=self.count, count_pairs=self.count_pairs)
-
-
-class KeepFirstMessagesConfig(BaseModel):
-    """Configuration for KeepFirstMessages step."""
-
-    type: Literal["keep_first"] = "keep_first"
-    count: int = 2
-
-    def build(self) -> KeepFirstMessages:
-        return KeepFirstMessages(count=self.count)
-
-
-class KeepFirstAndLastConfig(BaseModel):
-    """Configuration for KeepFirstAndLast step."""
-
-    type: Literal["keep_first_last"] = "keep_first_last"
-    first_count: int = 2
-    last_count: int = 5
-
-    def build(self) -> KeepFirstAndLast:
-        return KeepFirstAndLast(first_count=self.first_count, last_count=self.last_count)
-
-
-class TokenBudgetConfig(BaseModel):
-    """Configuration for TokenBudget step."""
-
-    type: Literal["token_budget"] = "token_budget"
-    max_tokens: int = 4000
-    model: str = "gpt-4o"
-
-    def build(self) -> TokenBudget:
-        return TokenBudget(max_tokens=self.max_tokens, model=self.model)
-
-
-class SummarizeConfig(BaseModel):
-    """Configuration for Summarize step."""
-
-    type: Literal["summarize"] = "summarize"
-    model: str = "openai:gpt-4o-mini"
-    threshold: int = 15
-    keep_recent: int = 5
-    summary_prompt: str | None = None
-
-    def build(self) -> Summarize:
-        kwargs: dict[str, Any] = {
-            "model": self.model,
-            "threshold": self.threshold,
-            "keep_recent": self.keep_recent,
-        }
-        if self.summary_prompt:
-            kwargs["summary_prompt"] = self.summary_prompt
-        return Summarize(**kwargs)
-
-
-class WhenMessageCountExceedsConfig(BaseModel):
-    """Configuration for WhenMessageCountExceeds wrapper."""
-
-    type: Literal["when_count_exceeds"] = "when_count_exceeds"
-    threshold: int = 20
-    step: "CompactionStepConfig"
-
-    def build(self) -> WhenMessageCountExceeds:
-        return WhenMessageCountExceeds(step=self.step.build(), threshold=self.threshold)
-
-
-# Union of all config types with discriminator
-CompactionStepConfig = Annotated[
-    FilterThinkingConfig
-    | FilterRetryPromptsConfig
-    | FilterBinaryContentConfig
-    | FilterToolCallsConfig
-    | FilterEmptyMessagesConfig
-    | TruncateToolOutputsConfig
-    | TruncateTextPartsConfig
-    | KeepLastMessagesConfig
-    | KeepFirstMessagesConfig
-    | KeepFirstAndLastConfig
-    | TokenBudgetConfig
-    | SummarizeConfig
-    | WhenMessageCountExceedsConfig,
-    Field(discriminator="type"),
-]
-
-# Update forward reference
-WhenMessageCountExceedsConfig.model_rebuild()
-
-
-class CompactionPipelineConfig(BaseModel):
-    """Configuration for a complete compaction pipeline.
-
-    Example YAML:
-        ```yaml
-        compaction:
-          steps:
-            - type: filter_thinking
-            - type: truncate_tool_outputs
-              max_length: 1000
-            - type: keep_last
-              count: 10
-        ```
-    """
-
-    steps: list[CompactionStepConfig] = Field(default_factory=list)
-    """Ordered list of compaction steps to apply."""
-
-    def build(self) -> CompactionPipeline:
-        """Build a CompactionPipeline from this configuration."""
-        return CompactionPipeline(steps=[step.build() for step in self.steps])
-
-
 # =============================================================================
 # Preset Pipelines - Common configurations
 # =============================================================================
@@ -877,6 +684,74 @@ def summarizing_context(model: ModelId | str = "openai:gpt-4o-mini") -> Compacti
 # =============================================================================
 
 
+async def compact_conversation(
+    pipeline: CompactionPipeline,
+    conversation: MessageHistory,
+) -> tuple[int, int]:
+    """Apply a compaction pipeline to a conversation's message history.
+
+    Extracts model messages from ChatMessages, applies the pipeline,
+    and rebuilds the conversation history with compacted messages.
+
+    Args:
+        pipeline: The compaction pipeline to apply
+        conversation: The MessageHistory to compact
+
+    Returns:
+        Tuple of (original_count, compacted_count) of model messages
+    """
+    from agentpool.messaging.messages import ChatMessage
+
+    chat_messages = conversation.get_history()
+    if not chat_messages:
+        return 0, 0
+
+    # Extract ModelRequest/ModelResponse from ChatMessage.messages
+    model_messages: list[ModelMessage] = []
+    for chat_msg in chat_messages:
+        if chat_msg.messages:
+            model_messages.extend(chat_msg.messages)
+
+    if not model_messages:
+        return 0, 0
+
+    original_count = len(model_messages)
+
+    # Apply the compaction pipeline
+    compacted = await pipeline.apply(model_messages)
+
+    # Rebuild ChatMessages from compacted model messages
+    new_chat_messages: list[ChatMessage[Any]] = []
+    current_msgs: list[ModelMessage] = []
+
+    for msg in compacted:
+        current_msgs.append(msg)
+        if isinstance(msg, ModelResponse):
+            new_chat_messages.append(
+                ChatMessage(
+                    content="[compacted]",
+                    role="assistant",
+                    messages=list(current_msgs),
+                )
+            )
+            current_msgs = []
+
+    # Handle any remaining messages (incomplete pair)
+    if current_msgs:
+        new_chat_messages.append(
+            ChatMessage(
+                content="[compacted]",
+                role="user",
+                messages=list(current_msgs),
+            )
+        )
+
+    # Update the conversation history
+    conversation.set_history(new_chat_messages)
+
+    return original_count, len(compacted)
+
+
 def _extract_text_content(msg: ModelMessage) -> str:
     """Extract text content from a message for token counting."""
     parts_text: list[str] = []