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

agentpool/resource_providers/mcp_provider.py

@@ -8,17 +8,19 @@ from typing import TYPE_CHECKING, Any, Self
 
 from agentpool.log import get_logger
 from agentpool.resource_providers import ResourceProvider
+from agentpool.resource_providers.resource_info import ResourceInfo
 from agentpool_config.mcp_server import BaseMCPServerConfig
-from agentpool_config.resources import ResourceInfo
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
     from typing import Literal
 
     from fastmcp.client.sampling import SamplingHandler
+    from mcp.types import ResourceTemplate
 
     from agentpool.prompts.prompts import MCPClientPrompt
-    from agentpool.tools.base import Tool
+    from agentpool.tools.base import FunctionTool, Tool
     from agentpool_config.mcp_server import MCPServerConfig
 
 
@@ -28,6 +30,8 @@ logger = get_logger(__name__)
 class MCPResourceProvider(ResourceProvider):
     """Resource provider for a single MCP server."""
 
+    kind = "mcp"
+
     def __init__(
         self,
         server: MCPServerConfig | str,
@@ -43,19 +47,14 @@ class MCPResourceProvider(ResourceProvider):
         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._tools_cache: list[FunctionTool] | None = None
         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,
@@ -104,23 +103,29 @@ class MCPResourceProvider(ResourceProvider):
         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
+        # Notify subscribers via signal
+        await self.tools_changed.emit(self.create_change_event("tools"))
 
     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
+        # Notify subscribers via signal
+        await self.prompts_changed.emit(self.create_change_event("prompts"))
 
     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
+        # Notify subscribers via signal
+        await self.resources_changed.emit(self.create_change_event("resources"))
 
     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] = []
+            all_tools: list[FunctionTool] = []
 
             for tool in mcp_tools:
                 try:
@@ -141,7 +146,7 @@ class MCPResourceProvider(ResourceProvider):
             logger.exception("Failed to refresh MCP tools cache")
             self._tools_cache = []
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get cached tools, refreshing if necessary."""
         if self._tools_cache is None:
             await self.refresh_tools_cache()
@@ -185,7 +190,11 @@ class MCPResourceProvider(ResourceProvider):
 
             for resource in result:
                 try:
-                    converted = await ResourceInfo.from_mcp_resource(resource)
+                    converted = await ResourceInfo.from_mcp_resource(
+                        resource,
+                        client_name=self.name,
+                        reader=self.read_resource,
+                    )
                     all_resources.append(converted)
                 except Exception:
                     logger.exception("Failed to convert resource", name=resource.name)
@@ -204,6 +213,74 @@ class MCPResourceProvider(ResourceProvider):
 
         return self._resources_cache or []
 
+    async def read_resource(self, uri: str) -> list[str]:
+        """Read resource content by URI.
+
+        Args:
+            uri: URI of the resource to read
+
+        Returns:
+            List of text contents from the resource
+
+        Raises:
+            RuntimeError: If resource cannot be read
+        """
+        contents = await self.client.read_resource(uri)
+        result: list[str] = []
+        for content in contents:
+            if hasattr(content, "text") and content.text is not None:
+                result.append(str(content.text))
+            elif hasattr(content, "blob") and content.blob is not None:
+                # Binary content - return placeholder or base64
+                import base64
+
+                blob_data = content.blob
+                if isinstance(blob_data, str):
+                    result.append(f"[Binary data: {len(blob_data)} bytes]")
+                elif isinstance(blob_data, bytes):
+                    encoded = base64.b64encode(blob_data).decode("utf-8")
+                    result.append(encoded)
+                else:
+                    result.append("[Binary data: unknown format]")
+        return result
+
+    async def list_resource_templates(self) -> list[ResourceTemplate]:
+        """Get available resource templates from the MCP server.
+
+        Resource templates define URI patterns with placeholders that can be
+        expanded into concrete resource URIs. For example:
+        - Template: "file:///{path}" with path="config.json"
+        - Expands to: "file:///config.json"
+
+        TODO: Decide on integration strategy:
+        - Option 1: Templates as separate concept with expand() -> ResourceInfo
+        - Option 2: Unified ResourceInfo with is_template flag and read(**kwargs)
+        - Option 3: ResourceTemplateInfo class that produces ResourceInfo
+
+        Returns:
+            List of ResourceTemplate objects from the server
+        """
+        try:
+            return await self.client.list_resource_templates()
+        except Exception:
+            logger.exception("Failed to list resource templates")
+            return []
+
+    def get_status(self) -> dict[str, str]:
+        """Get connection status for this MCP server.
+
+        Returns:
+            Status dict with 'status' key and optionally 'error' key.
+            Status can be: 'connected', 'disabled', or 'failed'.
+        """
+        try:
+            if self.client.connected:
+                return {"status": "connected"}
+        except Exception as e:  # noqa: BLE001
+            return {"status": "failed", "error": str(e)}
+        else:
+            return {"status": "disabled"}
+
 
 if __name__ == "__main__":
     import anyio

agentpool/resource_providers/plan_provider.py

@@ -3,19 +3,26 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool.agents.events import TextContentItem
 from agentpool.resource_providers import ResourceProvider
+from agentpool.tools.base import ToolResult
+from agentpool.utils.streams import TodoPriority, TodoStatus  # noqa: TC001
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from agentpool.tools.base import Tool
+    from agentpool.utils.streams import TodoTracker
 
 
-# Plan entry types - domain models independent of ACP
+# Keep PlanEntry for backward compatibility with event emitting
 PlanEntryPriority = Literal["high", "medium", "low"]
 PlanEntryStatus = Literal["pending", "in_progress", "completed"]
+PlanToolMode = Literal["granular", "declarative"]
 
 
 @dataclass(kw_only=True)
@@ -50,24 +57,46 @@ 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.
+    delegating storage to pool.todos and emitting domain events
+    that can be handled by protocol adapters.
     """
 
-    def __init__(self) -> None:
-        """Initialize plan provider."""
+    kind = "tools"
+
+    def __init__(self, mode: PlanToolMode = "declarative") -> None:
+        """Initialize plan provider.
+
+        Args:
+            mode: Tool mode - 'granular' for separate tools, 'declarative' for
+                  single set_plan tool.
+        """
         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"),
-        ]
+        self.mode = mode
+
+    def _get_tracker(self, agent_ctx: AgentContext) -> TodoTracker | None:
+        """Get the TodoTracker from the pool."""
+        if agent_ctx.pool is not None:
+            return agent_ctx.pool.todos
+        return None
 
-    async def get_plan(self, agent_ctx: AgentContext) -> str:
+    async def get_tools(self) -> Sequence[Tool]:
+        """Get plan management tools based on mode."""
+        tools: list[Tool] = [self.create_tool(self.get_plan, category="read")]
+
+        if self.mode == "declarative":
+            # Single bulk tool for capable models
+            tools.append(self.create_tool(self.set_plan, category="other"))
+        else:
+            # granular mode (default) - separate tools for simpler models
+            tools.extend([
+                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"),
+            ])
+
+        return tools
+
+    async def get_plan(self, agent_ctx: AgentContext) -> ToolResult:
         """Get the current plan formatted as markdown.
 
         Args:
@@ -76,8 +105,17 @@ class PlanProvider(ResourceProvider):
         Returns:
             Markdown-formatted plan with all entries and their status
         """
-        if not self._current_plan:
-            return "## Plan\n\n*No plan entries yet.*"
+        tracker = self._get_tracker(agent_ctx)
+        if tracker is None or not tracker.entries:
+            # Emit progress for empty plan
+            await agent_ctx.events.tool_call_progress(
+                title="Fetched plan (empty)",
+                items=[TextContentItem(text="*No tasks in plan yet.*")],
+            )
+            return ToolResult(
+                content="## Plan\n\n*No plan entries yet.",
+                metadata={"todos": []},
+            )
 
         lines = ["## Plan", ""]
         status_icons = {
@@ -90,18 +128,117 @@ class PlanProvider(ResourceProvider):
             "medium": "🟡",
             "low": "🟢",
         }
-        for i, entry in enumerate(self._current_plan):
+        for i, entry in enumerate(tracker.entries):
             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)
+        # Count completed entries for summary
+        completed = sum(1 for e in tracker.entries if e.status == "completed")
+        total = len(tracker.entries)
+
+        # Build title with summary
+        title = "Fetched plan with 1 task" if total == 1 else f"Fetched plan with {total} tasks"
+        if completed > 0:
+            title += f" ({completed} completed)"
+
+        # Emit progress with plan preview
+        plan_text = "\n".join(lines)
+        await agent_ctx.events.tool_call_progress(
+            title=title,
+            items=[TextContentItem(text=plan_text)],
+        )
+
+        # Convert to OpenCode format for metadata
+        todos = [{"content": e.content, "status": e.status} for e in tracker.entries]
+
+        return ToolResult(
+            content=plan_text,
+            metadata={"todos": todos},
+        )
+
+    async def set_plan(
+        self,
+        agent_ctx: AgentContext,
+        entries: list[dict[str, Any]],
+    ) -> ToolResult:
+        """Replace the entire plan with new entries (declarative/bulk update).
+
+        This is more efficient than multiple add/update calls when setting
+        or significantly modifying the plan.
+
+        Args:
+            agent_ctx: Agent execution context
+            entries: List of plan entries, each with:
+                - content (str, required): Task description
+                - priority (str, optional): "high", "medium", or "low" (default: "medium")
+                - status (str, optional): "pending", "in_progress", or "completed"
+                  (default: "pending")
+
+        Returns:
+            Success message indicating plan was updated
+        """
+        tracker = self._get_tracker(agent_ctx)
+        if tracker is None:
+            return ToolResult(
+                content="Error: No pool available for plan tracking",
+                metadata={"todos": []},
+            )
+
+        # Clear existing entries
+        tracker.clear()
+
+        # Add all new entries
+        for entry in entries:
+            content = entry.get("content", "")
+            if not content:
+                continue
+            priority = entry.get("priority", "medium")
+            status = entry.get("status", "pending")
+            tracker.add(content, priority=priority, status=status)
+
+        await self._emit_plan_update(agent_ctx)
+
+        # Build summary for user feedback
+        entry_count = len(tracker.entries)
+        if entry_count == 0:
+            title = "Cleared plan"
+        elif entry_count == 1:
+            title = "Set plan with 1 task"
+        else:
+            title = f"Set plan with {entry_count} tasks"
+
+        # Format entries list for details
+        if tracker.entries:
+            lines = ["**New Plan:**"]
+            for i, e in enumerate(tracker.entries):
+                priority_emoji = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(e.priority, "")
+                status_emoji = {"pending": "⬚", "in_progress": "◐", "completed": "✓"}.get(
+                    e.status, ""
+                )
+                lines.append(f"{i + 1}. {priority_emoji} {status_emoji} {e.content}")
+            details = "\n".join(lines)
+        else:
+            details = "*Plan is empty*"
+
+        await agent_ctx.events.tool_call_progress(
+            title=title,
+            items=[TextContentItem(text=details)],
+        )
+
+        # Convert to OpenCode format for metadata
+        todos = [{"content": e.content, "status": e.status} for e in tracker.entries]
+
+        return ToolResult(
+            content=f"Plan updated with {entry_count} entries",
+            metadata={"todos": todos},
+        )
 
     async def add_plan_entry(
         self,
         agent_ctx: AgentContext,
         content: str,
-        priority: PlanEntryPriority = "medium",
+        priority: TodoPriority = "medium",
         index: int | None = None,
     ) -> str:
         """Add a new plan entry.
@@ -115,18 +252,24 @@ class PlanProvider(ResourceProvider):
         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
+        tracker = self._get_tracker(agent_ctx)
+        if tracker is None:
+            return "Error: No pool available for plan tracking"
+
+        entry = tracker.add(content, priority=priority, index=index)
+        entry_index = tracker.entries.index(entry)
 
         await self._emit_plan_update(agent_ctx)
 
+        # User feedback
+        priority_emoji = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(priority, "")
+        title = f"Added task {entry_index + 1} {priority_emoji}"
+        details = f"**Task {entry_index + 1}**: {content}"
+        await agent_ctx.events.tool_call_progress(
+            title=title,
+            items=[TextContentItem(text=details)],
+        )
+
         return f"Added plan entry at index {entry_index}: {content!r} (priority={priority!r})"
 
     async def update_plan_entry(
@@ -134,8 +277,8 @@ class PlanProvider(ResourceProvider):
         agent_ctx: AgentContext,
         index: int,
         content: str | None = None,
-        status: PlanEntryStatus | None = None,
-        priority: PlanEntryPriority | None = None,
+        status: TodoStatus | None = None,
+        priority: TodoPriority | None = None,
     ) -> str:
         """Update an existing plan entry.
 
@@ -149,28 +292,40 @@ class PlanProvider(ResourceProvider):
         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})"
+        tracker = self._get_tracker(agent_ctx)
+        if tracker is None:
+            return "Error: No pool available for plan tracking"
 
-        entry = self._current_plan[index]
-        updates = []
+        if index < 0 or index >= len(tracker.entries):
+            return f"Error: Index {index} out of range (0-{len(tracker.entries) - 1})"
 
+        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"
 
+        tracker.update_by_index(index, content=content, status=status, priority=priority)
+
         await self._emit_plan_update(agent_ctx)
+
+        # Build title with key info
+        entry = tracker.entries[index]
+        status_emoji = {"pending": "⬚", "in_progress": "◐", "completed": "✓"}.get(entry.status, "")
+        title = f"Updated task {index + 1} {status_emoji}"
+
+        # Send detailed content
+        details = f"**Task {index + 1}**: {entry.content}\n\nChanges: {', '.join(updates)}"
+        await agent_ctx.events.tool_call_progress(
+            title=title,
+            items=[TextContentItem(text=details)],
+        )
+
         return f"Updated entry {index}: {', '.join(updates)}"
 
     async def remove_plan_entry(self, agent_ctx: AgentContext, index: int) -> str:
@@ -183,14 +338,41 @@ class PlanProvider(ResourceProvider):
         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)
+        tracker = self._get_tracker(agent_ctx)
+        if tracker is None:
+            return "Error: No pool available for plan tracking"
+
+        if index < 0 or index >= len(tracker.entries):
+            return f"Error: Index {index} out of range (0-{len(tracker.entries) - 1})"
+
+        removed_entry = tracker.remove_by_index(index)
         await self._emit_plan_update(agent_ctx)
-        if self._current_plan:
+
+        if removed_entry is None:
+            return f"Error: Could not remove entry at index {index}"
+
+        # User feedback
+        remaining = len(tracker.entries)
+        title = f"Removed task {index + 1}"
+        details = f"**Removed**: {removed_entry.content}\n\nRemaining tasks: {remaining}"
+        await agent_ctx.events.tool_call_progress(
+            title=title,
+            items=[TextContentItem(text=details)],
+        )
+
+        if tracker.entries:
             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)
+        tracker = self._get_tracker(agent_ctx)
+        if tracker is None:
+            return
+
+        # Convert TodoEntry to PlanEntry for event compatibility
+        entries = [
+            PlanEntry(content=e.content, priority=e.priority, status=e.status)
+            for e in tracker.entries
+        ]
+        await agent_ctx.events.plan_updated(entries)

agentpool/resource_providers/pool.py

@@ -9,10 +9,12 @@ from agentpool.resource_providers import ResourceProvider
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from agentpool import AgentPool
     from agentpool.prompts.prompts import BasePrompt
-    from agentpool.tools.base import Tool
-    from agentpool_config.resources import ResourceInfo
+    from agentpool.resource_providers.resource_info import ResourceInfo
+    from agentpool.tools import Tool
 
 logger = get_logger(__name__)
 
@@ -20,6 +22,8 @@ logger = get_logger(__name__)
 class PoolResourceProvider(ResourceProvider):
     """Provider that exposes an AgentPool's resources."""
 
+    kind = "tools"
+
     def __init__(
         self,
         pool: AgentPool[Any],
@@ -41,7 +45,7 @@ class PoolResourceProvider(ResourceProvider):
         self.zed_mode = zed_mode
         self.include_team_members = include_team_members
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[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())