agentpool 2.1.9__py3-none-any.whl

agentpool/resource_providers/filtering.py

@@ -0,0 +1,42 @@
+"""Filtering resource provider implementation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from agentpool.resource_providers import ResourceProvider
+
+
+if TYPE_CHECKING:
+    from agentpool.tools.base import Tool
+
+
+class FilteringResourceProvider(ResourceProvider):
+    """Wrapper that filters tools from a ResourceProvider based on tool name filter."""
+
+    def __init__(
+        self,
+        provider: ResourceProvider,
+        tool_filter: dict[str, bool],
+    ) -> None:
+        """Initialize filtering wrapper.
+
+        Args:
+            provider: The provider to wrap
+            tool_filter: Dict mapping tool names to enabled state (defaults to True)
+        """
+        self._provider = provider
+        self._tool_filter = tool_filter
+
+    def __getattr__(self, name: str) -> Any:
+        """Delegate attribute access to wrapped provider."""
+        return getattr(self._provider, name)
+
+    async def get_tools(self) -> list[Tool]:
+        """Get filtered tools from wrapped provider.
+
+        Returns only tools where the filter value is True. Tools not in the filter
+        default to enabled (True).
+        """
+        tools = await self._provider.get_tools()
+        return [t for t in tools if self._tool_filter.get(t.name, True)]

agentpool/resource_providers/mcp_provider.py

@@ -0,0 +1,246 @@
+"""Tool management for AgentPool."""
+
+from __future__ import annotations
+
+import asyncio
+from contextlib import AsyncExitStack
+from typing import TYPE_CHECKING, Any, Self
+
+from agentpool.log import get_logger
+from agentpool.resource_providers import ResourceProvider
+from agentpool_config.mcp_server import BaseMCPServerConfig
+from agentpool_config.resources import ResourceInfo
+
+
+if TYPE_CHECKING:
+    from typing import Literal
+
+    from fastmcp.client.sampling import SamplingHandler
+
+    from agentpool.prompts.prompts import MCPClientPrompt
+    from agentpool.tools.base import Tool
+    from agentpool_config.mcp_server import MCPServerConfig
+
+
+logger = get_logger(__name__)
+
+
+class MCPResourceProvider(ResourceProvider):
+    """Resource provider for a single MCP server."""
+
+    def __init__(
+        self,
+        server: MCPServerConfig | str,
+        name: str = "mcp",
+        owner: str | None = None,
+        source: Literal["pool", "node"] = "node",
+        sampling_callback: SamplingHandler[Any, Any] | None = None,
+        accessible_roots: list[str] | None = None,
+    ) -> None:
+        from agentpool.mcp_server import MCPClient
+
+        super().__init__(name, owner=owner)
+        self.server = BaseMCPServerConfig.from_string(server) if isinstance(server, str) else server
+        self.source = source
+        self.exit_stack = AsyncExitStack()
+        self._accessible_roots = accessible_roots
+        self._sampling_callback = sampling_callback
+
+        # Tool caching
+        self._tools_cache: list[Tool] | None = None
+        self._saved_enabled_states: dict[str, bool] = {}
+
+        # Prompt caching
+        self._prompts_cache: list[MCPClientPrompt] | None = None
+
+        # Resource caching
+        self._resources_cache: list[ResourceInfo] | None = None
+
+        self.client = MCPClient(
+            config=self.server,
+            sampling_callback=self._sampling_callback,
+            accessible_roots=self._accessible_roots,
+            tool_change_callback=self._on_tools_changed,
+            prompt_change_callback=self._on_prompts_changed,
+            resource_change_callback=self._on_resources_changed,
+        )
+
+    def __repr__(self) -> str:
+        return f"MCPResourceProvider({self.server!r}, source={self.source!r})"
+
+    async def __aenter__(self) -> Self:
+        try:
+            await self.exit_stack.enter_async_context(self.client)
+        except Exception as e:
+            # Clean up in case of error
+            await self.__aexit__(type(e), e, e.__traceback__)
+            msg = "Failed to initialize MCP manager"
+            raise RuntimeError(msg) from e
+
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        try:
+            try:
+                # Clean up exit stack (which includes MCP clients)
+                await self.exit_stack.aclose()
+            except RuntimeError as e:
+                if "different task" in str(e):
+                    # Handle task context mismatch
+                    current_task = asyncio.current_task()
+                    if current_task:
+                        loop = asyncio.get_running_loop()
+                        await loop.create_task(self.exit_stack.aclose())
+                else:
+                    raise
+
+        except Exception as e:
+            msg = "Error during MCP manager cleanup"
+            logger.exception(msg, exc_info=e)
+            raise RuntimeError(msg) from e
+
+    async def _on_tools_changed(self) -> None:
+        """Callback when tools change on the MCP server."""
+        logger.info("MCP tool list changed, refreshing provider cache")
+        self._saved_enabled_states = {t.name: t.enabled for t in self._tools_cache or []}
+        self._tools_cache = None
+
+    async def _on_prompts_changed(self) -> None:
+        """Callback when prompts change on the MCP server."""
+        logger.info("MCP prompt list changed, refreshing provider cache")
+        self._prompts_cache = None
+
+    async def _on_resources_changed(self) -> None:
+        """Callback when resources change on the MCP server."""
+        logger.info("MCP resource list changed, refreshing provider cache")
+        self._resources_cache = None
+
+    async def refresh_tools_cache(self) -> None:
+        """Refresh the tools cache by fetching from client."""
+        try:
+            # Get fresh tools from client
+            mcp_tools = await self.client.list_tools()
+            all_tools: list[Tool] = []
+
+            for tool in mcp_tools:
+                try:
+                    tool_info = self.client.convert_tool(tool)
+                    all_tools.append(tool_info)
+                except Exception:
+                    logger.exception("Failed to create MCP tool", name=tool.name)
+                    continue
+
+            # Restore enabled states from saved states
+            for tool_info in all_tools:
+                if tool_info.name in self._saved_enabled_states:
+                    tool_info.enabled = self._saved_enabled_states[tool_info.name]
+
+            self._tools_cache = all_tools
+            logger.debug("Refreshed MCP tools cache", num_tools=len(all_tools))
+        except Exception:
+            logger.exception("Failed to refresh MCP tools cache")
+            self._tools_cache = []
+
+    async def get_tools(self) -> list[Tool]:
+        """Get cached tools, refreshing if necessary."""
+        if self._tools_cache is None:
+            await self.refresh_tools_cache()
+
+        return self._tools_cache or []
+
+    async def refresh_prompts_cache(self) -> None:
+        """Refresh the prompts cache by fetching from client."""
+        from agentpool.prompts.prompts import MCPClientPrompt
+
+        try:
+            result = await self.client.list_prompts()
+            all_prompts: list[MCPClientPrompt] = []
+
+            for prompt in result:
+                try:
+                    converted = MCPClientPrompt.from_fastmcp(self.client, prompt)
+                    all_prompts.append(converted)
+                except Exception:
+                    logger.exception("Failed to convert prompt", name=prompt.name)
+                    continue
+
+            self._prompts_cache = all_prompts
+            logger.debug("Refreshed MCP prompts cache", num_prompts=len(all_prompts))
+        except Exception:
+            logger.exception("Failed to refresh MCP prompts cache")
+            self._prompts_cache = []
+
+    async def get_prompts(self) -> list[MCPClientPrompt]:  # type: ignore
+        """Get cached prompts, refreshing if necessary."""
+        if self._prompts_cache is None:
+            await self.refresh_prompts_cache()
+
+        return self._prompts_cache or []
+
+    async def refresh_resources_cache(self) -> None:
+        """Refresh the resources cache by fetching from client."""
+        try:
+            result = await self.client.list_resources()
+            all_resources: list[ResourceInfo] = []
+
+            for resource in result:
+                try:
+                    converted = await ResourceInfo.from_mcp_resource(resource)
+                    all_resources.append(converted)
+                except Exception:
+                    logger.exception("Failed to convert resource", name=resource.name)
+                    continue
+
+            self._resources_cache = all_resources
+            logger.debug("Refreshed MCP resources cache", num_resources=len(all_resources))
+        except Exception:
+            logger.exception("Failed to refresh MCP resources cache")
+            self._resources_cache = []
+
+    async def get_resources(self) -> list[ResourceInfo]:
+        """Get cached resources, refreshing if necessary."""
+        if self._resources_cache is None:
+            await self.refresh_resources_cache()
+
+        return self._resources_cache or []
+
+
+if __name__ == "__main__":
+    import anyio
+
+    from agentpool_config.mcp_server import StdioMCPServerConfig
+
+    cfg = StdioMCPServerConfig(
+        command="uv",
+        args=["run", "/home/phil65/dev/oss/agentpool/tests/mcp_server/server.py"],
+    )
+
+    async def main() -> None:
+        manager = MCPResourceProvider(cfg)
+        async with manager:
+            prompts = await manager.get_prompts()
+            print(f"Found prompts: {prompts}")
+
+            # Test static prompt (no arguments)
+            static_prompt = next(p for p in prompts if p.name == "static_prompt")
+            print(f"\n--- Testing static prompt: {static_prompt} ---")
+            components = await static_prompt.get_components()
+            assert components, "No prompt components found"
+            print(f"Found {len(components)} prompt components:")
+            for i, component in enumerate(components):
+                comp_type = type(component).__name__
+                print(f"  {i + 1}. {comp_type}: {component.content}")
+
+            # Test dynamic prompt (with arguments)
+            dynamic_prompt = next(p for p in prompts if p.name == "dynamic_prompt")
+            print(f"\n--- Testing dynamic prompt: {dynamic_prompt} ---")
+            components = await dynamic_prompt.get_components(
+                arguments={"some_arg": "Hello, world!"}
+            )
+            assert components, "No prompt components found"
+            print(f"Found {len(components)} prompt components:")
+            for i, component in enumerate(components):
+                comp_type = type(component).__name__
+                print(f"  {i + 1}. {comp_type}: {component.content}")
+
+    anyio.run(main)

agentpool/resource_providers/plan_provider.py

@@ -0,0 +1,196 @@
+"""Plan provider for agent planning and task management."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool.resource_providers import ResourceProvider
+
+
+if TYPE_CHECKING:
+    from agentpool.tools.base import Tool
+
+
+# Plan entry types - domain models independent of ACP
+PlanEntryPriority = Literal["high", "medium", "low"]
+PlanEntryStatus = Literal["pending", "in_progress", "completed"]
+
+
+@dataclass(kw_only=True)
+class PlanEntry:
+    """A single entry in the execution plan.
+
+    Represents a task or goal that the assistant intends to accomplish
+    as part of fulfilling the user's request.
+    """
+
+    content: str
+    """Human-readable description of what this task aims to accomplish."""
+
+    priority: PlanEntryPriority
+    """The relative importance of this task."""
+
+    status: PlanEntryStatus
+    """Current execution status of this task."""
+
+
+@dataclass(kw_only=True)
+class PlanUpdateEvent:
+    """Event indicating plan state has changed."""
+
+    entries: list[PlanEntry]
+    """Current plan entries."""
+    event_kind: Literal["plan_update"] = "plan_update"
+    """Event type identifier."""
+
+
+class PlanProvider(ResourceProvider):
+    """Provides plan-related tools for agent planning and task management.
+
+    This provider creates tools for managing agent plans and tasks,
+    emitting domain events that can be handled by protocol adapters.
+    """
+
+    def __init__(self) -> None:
+        """Initialize plan provider."""
+        super().__init__(name="plan")
+        self._current_plan: list[PlanEntry] = []
+
+    async def get_tools(self) -> list[Tool]:
+        """Get plan management tools."""
+        return [
+            self.create_tool(self.get_plan, category="read"),
+            self.create_tool(self.add_plan_entry, category="other"),
+            self.create_tool(self.update_plan_entry, category="edit"),
+            self.create_tool(self.remove_plan_entry, category="delete"),
+        ]
+
+    async def get_plan(self, agent_ctx: AgentContext) -> str:
+        """Get the current plan formatted as markdown.
+
+        Args:
+            agent_ctx: Agent execution context
+
+        Returns:
+            Markdown-formatted plan with all entries and their status
+        """
+        if not self._current_plan:
+            return "## Plan\n\n*No plan entries yet.*"
+
+        lines = ["## Plan", ""]
+        status_icons = {
+            "pending": "⬚",
+            "in_progress": "◐",
+            "completed": "✓",
+        }
+        priority_labels = {
+            "high": "🔴",
+            "medium": "🟡",
+            "low": "🟢",
+        }
+        for i, entry in enumerate(self._current_plan):
+            icon = status_icons.get(entry.status, "?")
+            priority = priority_labels.get(entry.priority, "")
+            lines.append(f"{i}. {icon} {priority} {entry.content} *({entry.status})*")
+
+        return "\n".join(lines)
+
+    async def add_plan_entry(
+        self,
+        agent_ctx: AgentContext,
+        content: str,
+        priority: PlanEntryPriority = "medium",
+        index: int | None = None,
+    ) -> str:
+        """Add a new plan entry.
+
+        Args:
+            agent_ctx: Agent execution context
+            content: Description of what this task aims to accomplish
+            priority: Relative importance (high/medium/low)
+            index: Optional position to insert at (default: append to end)
+
+        Returns:
+            Success message indicating entry was added
+        """
+        entry = PlanEntry(content=content, priority=priority, status="pending")
+        if index is None:
+            self._current_plan.append(entry)
+            entry_index = len(self._current_plan) - 1
+        else:
+            if index < 0 or index > len(self._current_plan):
+                return f"Error: Index {index} out of range (0-{len(self._current_plan)})"
+            self._current_plan.insert(index, entry)
+            entry_index = index
+
+        await self._emit_plan_update(agent_ctx)
+
+        return f"Added plan entry at index {entry_index}: {content!r} (priority={priority!r})"
+
+    async def update_plan_entry(
+        self,
+        agent_ctx: AgentContext,
+        index: int,
+        content: str | None = None,
+        status: PlanEntryStatus | None = None,
+        priority: PlanEntryPriority | None = None,
+    ) -> str:
+        """Update an existing plan entry.
+
+        Args:
+            agent_ctx: Agent execution context
+            index: Position of entry to update (0-based)
+            content: New task description
+            status: New execution status
+            priority: New priority level
+
+        Returns:
+            Success message indicating what was updated
+        """
+        if index < 0 or index >= len(self._current_plan):
+            return f"Error: Index {index} out of range (0-{len(self._current_plan) - 1})"
+
+        entry = self._current_plan[index]
+        updates = []
+
+        if content is not None:
+            entry.content = content
+            updates.append(f"content to {content!r}")
+
+        if status is not None:
+            entry.status = status
+            updates.append(f"status to {status!r}")
+
+        if priority is not None:
+            entry.priority = priority
+            updates.append(f"priority to {priority!r}")
+
+        if not updates:
+            return "No changes specified"
+
+        await self._emit_plan_update(agent_ctx)
+        return f"Updated entry {index}: {', '.join(updates)}"
+
+    async def remove_plan_entry(self, agent_ctx: AgentContext, index: int) -> str:
+        """Remove a plan entry.
+
+        Args:
+            agent_ctx: Agent execution context
+            index: Position of entry to remove (0-based)
+
+        Returns:
+            Success message indicating entry was removed
+        """
+        if index < 0 or index >= len(self._current_plan):
+            return f"Error: Index {index} out of range (0-{len(self._current_plan) - 1})"
+        removed_entry = self._current_plan.pop(index)
+        await self._emit_plan_update(agent_ctx)
+        if self._current_plan:
+            return f"Removed entry {index}: {removed_entry.content!r}, remaining entries reindexed"
+        return f"Removed entry {index}: {removed_entry.content!r}, plan is now empty"
+
+    async def _emit_plan_update(self, agent_ctx: AgentContext) -> None:
+        """Emit plan update event."""
+        await agent_ctx.events.plan_updated(self._current_plan)

agentpool/resource_providers/pool.py

@@ -0,0 +1,69 @@
+"""Resource provider exposing Nodes as tools."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from agentpool.log import get_logger
+from agentpool.resource_providers import ResourceProvider
+
+
+if TYPE_CHECKING:
+    from agentpool import AgentPool
+    from agentpool.prompts.prompts import BasePrompt
+    from agentpool.tools.base import Tool
+    from agentpool_config.resources import ResourceInfo
+
+logger = get_logger(__name__)
+
+
+class PoolResourceProvider(ResourceProvider):
+    """Provider that exposes an AgentPool's resources."""
+
+    def __init__(
+        self,
+        pool: AgentPool[Any],
+        name: str | None = None,
+        zed_mode: bool = False,
+        include_team_members: bool = False,
+    ) -> None:
+        """Initialize provider with agent pool.
+
+        Args:
+            pool: Agent pool to expose resources from
+            name: Optional name override (defaults to pool name)
+            zed_mode: Whether to enable Zed mode
+            include_team_members: Whether to include team members in the pool
+                                  in addition to the team itself.
+        """
+        super().__init__(name=name or repr(pool))
+        self.pool = pool
+        self.zed_mode = zed_mode
+        self.include_team_members = include_team_members
+
+    async def get_tools(self) -> list[Tool]:
+        """Get tools from all agents in pool."""
+        team_tools = [team.to_tool() for team in self.pool.teams.values()]
+        agents = list(self.pool.agents.values())
+        team_members = {member for t in self.pool.teams.values() for member in t.nodes}
+        if self.include_team_members:
+            agent_tools = [agent.to_tool() for agent in agents]
+        else:
+            agent_tools = [agent.to_tool() for agent in agents if agent not in team_members]
+        return team_tools + agent_tools
+
+    async def get_prompts(self) -> list[BasePrompt]:
+        """Get prompts from pool's manifest."""
+        prompts: list[Any] = []
+        # if self.pool.manifest.prompts:
+        #     prompts.extend(self.pool.manifest.prompts.system_prompts.values())
+
+        # if self.zed_mode:
+        #     prompts = prepare_prompts_for_zed(prompts)
+
+        return prompts
+
+    async def get_resources(self) -> list[ResourceInfo]:
+        """Get resources from pool's manifest."""
+        # Here we could expose knowledge bases or other resources from manifest
+        return []