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

agentpool/resource_providers/plan_provider.py

@@ -6,11 +6,15 @@ from dataclasses import dataclass
 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
 
@@ -18,7 +22,7 @@ if TYPE_CHECKING:
 # Keep PlanEntry for backward compatibility with event emitting
 PlanEntryPriority = Literal["high", "medium", "low"]
 PlanEntryStatus = Literal["pending", "in_progress", "completed"]
-PlanToolMode = Literal["granular", "declarative", "hybrid"]
+PlanToolMode = Literal["granular", "declarative"]
 
 
 @dataclass(kw_only=True)
@@ -59,12 +63,12 @@ class PlanProvider(ResourceProvider):
 
     kind = "tools"
 
-    def __init__(self, mode: PlanToolMode = "granular") -> None:
+    def __init__(self, mode: PlanToolMode = "declarative") -> None:
         """Initialize plan provider.
 
         Args:
             mode: Tool mode - 'granular' for separate tools, 'declarative' for
-                  single set_plan tool, 'hybrid' for both approaches.
+                  single set_plan tool.
         """
         super().__init__(name="plan")
         self.mode = mode
@@ -75,21 +79,13 @@ class PlanProvider(ResourceProvider):
             return agent_ctx.pool.todos
         return None
 
-    async def get_tools(self) -> list[Tool]:
+    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"))
-        elif self.mode == "hybrid":
-            # Both approaches - model chooses
-            tools.extend([
-                self.create_tool(self.set_plan, category="other"),
-                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"),
-            ])
         else:
             # granular mode (default) - separate tools for simpler models
             tools.extend([
@@ -100,7 +96,7 @@ class PlanProvider(ResourceProvider):
 
         return tools
 
-    async def get_plan(self, agent_ctx: AgentContext) -> str:
+    async def get_plan(self, agent_ctx: AgentContext) -> ToolResult:
         """Get the current plan formatted as markdown.
 
         Args:
@@ -111,7 +107,15 @@ class PlanProvider(ResourceProvider):
         """
         tracker = self._get_tracker(agent_ctx)
         if tracker is None or not tracker.entries:
-            return "## Plan\n\n*No plan entries yet.*"
+            # 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 = {
@@ -129,13 +133,35 @@ class PlanProvider(ResourceProvider):
             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]],
-    ) -> str:
+    ) -> ToolResult:
         """Replace the entire plan with new entries (declarative/bulk update).
 
         This is more efficient than multiple add/update calls when setting
@@ -154,7 +180,10 @@ class PlanProvider(ResourceProvider):
         """
         tracker = self._get_tracker(agent_ctx)
         if tracker is None:
-            return "Error: No pool available for plan tracking"
+            return ToolResult(
+                content="Error: No pool available for plan tracking",
+                metadata={"todos": []},
+            )
 
         # Clear existing entries
         tracker.clear()
@@ -170,7 +199,40 @@ class PlanProvider(ResourceProvider):
 
         await self._emit_plan_update(agent_ctx)
 
-        return f"Plan updated with {len(tracker.entries)} entries"
+        # 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,
@@ -199,6 +261,15 @@ class PlanProvider(ResourceProvider):
 
         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(
@@ -242,6 +313,19 @@ class PlanProvider(ResourceProvider):
         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:
@@ -267,6 +351,15 @@ class PlanProvider(ResourceProvider):
         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"

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__)
 
@@ -43,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())

agentpool/resource_providers/resource_info.py

@@ -0,0 +1,111 @@
+"""Resource information model with read capability."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Self
+
+
+if TYPE_CHECKING:
+    from mcp.types import Resource as MCPResource
+
+
+# Type alias for the reader function
+ResourceReader = Callable[[str], Awaitable[list[str]]]
+
+
+@dataclass
+class ResourceInfo:
+    """Information about an available resource with read capability.
+
+    This class provides essential information about a resource and can read
+    its content when a reader is available.
+
+    Example:
+        ```python
+        # List resources from tool manager
+        resources = await agent.tools.list_resources()
+
+        # Read a specific resource
+        for resource in resources:
+            if resource.name == "config.json":
+                content = await resource.read()
+                print(content)
+        ```
+    """
+
+    name: str
+    """Name of the resource"""
+
+    uri: str
+    """URI identifying the resource location"""
+
+    description: str | None = None
+    """Optional description of the resource's content or purpose"""
+
+    mime_type: str | None = None
+    """MIME type of the resource content"""
+
+    client: str | None = None
+    """Name of the MCP client/server providing this resource"""
+
+    annotations: dict[str, Any] = field(default_factory=dict)
+    """Additional annotations/metadata for the resource"""
+
+    _reader: ResourceReader | None = field(default=None, repr=False, compare=False)
+    """Internal reader function for fetching content"""
+
+    async def read(self) -> list[str]:
+        """Read the resource content.
+
+        Returns:
+            List of text contents from the resource
+
+        Raises:
+            RuntimeError: If no reader is available or read fails
+        """
+        if self._reader is None:
+            msg = f"No reader available for resource: {self.uri}"
+            raise RuntimeError(msg)
+        return await self._reader(self.uri)
+
+    @property
+    def can_read(self) -> bool:
+        """Check if this resource can be read."""
+        return self._reader is not None
+
+    @classmethod
+    async def from_mcp_resource(
+        cls,
+        resource: MCPResource,
+        client_name: str | None = None,
+        reader: ResourceReader | None = None,
+    ) -> Self:
+        """Create ResourceInfo from MCP resource.
+
+        Args:
+            resource: MCP resource object
+            client_name: Name of the MCP client providing this resource
+            reader: Optional reader function for fetching content
+
+        Returns:
+            ResourceInfo instance
+        """
+        annotations: dict[str, Any] = {}
+        if resource.annotations:
+            # Convert annotations to simple dict
+            if hasattr(resource.annotations, "model_dump"):
+                annotations = resource.annotations.model_dump(exclude_none=True)
+            elif isinstance(resource.annotations, dict):
+                annotations = resource.annotations
+
+        return cls(
+            name=resource.name,
+            uri=str(resource.uri),
+            description=resource.description,
+            mime_type=resource.mimeType,
+            client=client_name,
+            annotations=annotations,
+            _reader=reader,
+        )

agentpool/resource_providers/static.py

@@ -14,8 +14,8 @@ if TYPE_CHECKING:
     from agentpool import Agent, MessageNode
     from agentpool.common_types import ToolSource, ToolType
     from agentpool.prompts.prompts import BasePrompt
+    from agentpool.resource_providers.resource_info import ResourceInfo
     from agentpool.tools.base import Tool
-    from agentpool_config.resources import ResourceInfo
 
 
 class StaticResourceProvider(ResourceProvider):
@@ -48,7 +48,7 @@ class StaticResourceProvider(ResourceProvider):
         self._prompts = list(prompts) if prompts else []
         self._resources = list(resources) if resources else []
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get pre-configured tools."""
         return self._tools
 

agentpool/sessions/__init__.py

@@ -4,11 +4,13 @@ from agentpool.sessions.models import ProjectData, SessionData
 from agentpool.sessions.store import SessionStore
 from agentpool.sessions.manager import SessionManager
 from agentpool.sessions.session import ClientSession
+from agentpool.sessions.protocol import SessionInfo
 
 __all__ = [
     "ClientSession",
     "ProjectData",
     "SessionData",
+    "SessionInfo",
     "SessionManager",
     "SessionStore",
 ]

agentpool/sessions/manager.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import asyncio
 from typing import TYPE_CHECKING, Any, Self
-from uuid import uuid4
 
 from agentpool.log import get_logger
 from agentpool.sessions.models import SessionData
@@ -171,7 +170,7 @@ class SessionManager:
             data = SessionData(
                 session_id=session_id,
                 agent_name=agent_name,
-                conversation_id=conversation_id or f"conv_{uuid4().hex[:12]}",
+                conversation_id=conversation_id or session_id,
                 pool_id=self._pool_id,
                 project_id=project_id,
                 cwd=cwd,
@@ -309,7 +308,7 @@ class SessionManager:
         if active_only:
             sessions = list(self._active.keys())
             if agent_name:
-                sessions = [sid for sid, s in self._active.items() if s.agent_name == agent_name]
+                sessions = [sid for sid, s in self._active.items() if s.agent.name == agent_name]
             return sessions
 
         return await self._store.list_sessions(

agentpool/sessions/models.py

@@ -68,9 +68,6 @@ class SessionData(Schema):
     conversation_id: str
     """Links to conversation in StorageManager."""
 
-    title: str | None = None
-    """AI-generated or user-provided title for the conversation."""
-
     pool_id: str | None = None
     """Optional pool/manifest identifier for multi-pool setups."""
 
@@ -116,6 +113,12 @@ class SessionData(Schema):
         new_metadata = {**self.metadata, **kwargs}
         return self.model_copy(update={"metadata": new_metadata, "last_active": get_now()})
 
-    def with_title(self, title: str) -> SessionData:
-        """Return copy with updated title."""
-        return self.model_copy(update={"title": title, "last_active": get_now()})
+    @property
+    def title(self) -> str | None:
+        """Human-readable title (from metadata, for protocol compatibility)."""
+        return self.metadata.get("title")
+
+    @property
+    def updated_at(self) -> str | None:
+        """ISO timestamp of last activity (for protocol compatibility)."""
+        return self.last_active.isoformat() if self.last_active else None

agentpool/sessions/protocol.py

@@ -0,0 +1,28 @@
+"""Session protocol for unified session management across agent types."""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class SessionInfo(Protocol):
+    """Protocol for session information.
+
+    This protocol provides a unified interface for session metadata across
+    different agent implementations (ACP, ClaudeCode, native agents).
+
+    Both ACP's SessionInfo and our SessionData can fulfill this protocol.
+    """
+
+    session_id: str
+    """Unique identifier for the session."""
+
+    cwd: str | None
+    """Working directory for the session (absolute path)."""
+
+    title: str | None
+    """Human-readable title for the session."""
+
+    updated_at: str | None
+    """ISO 8601 timestamp of last activity."""

agentpool/sessions/session.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 from typing import TYPE_CHECKING, Any, Self
 
 from agentpool.log import get_logger
@@ -57,16 +56,9 @@ class ClientSession:
         self._manager = manager
         self._agent: Agent[Any, Any] | None = None
         self._closed = False
-        self._title_generation_triggered = False
-        self._title_task: asyncio.Task[None] | None = None
         # Session owns conversation history - agent is stateless
         self._history = MessageHistory()
-
-        logger.debug(
-            "Created client session",
-            session_id=data.session_id,
-            agent=data.agent_name,
-        )
+        logger.debug("Created client session", session_id=data.session_id, agent=data.agent_name)
 
     @property
     def session_id(self) -> str:
@@ -90,16 +82,16 @@ class ClientSession:
             self._agent = self._pool.get_agent(self._data.agent_name)
         return self._agent
 
-    @property
-    def agent_name(self) -> str:
-        """Get current agent name."""
-        return self._data.agent_name
-
     @property
     def conversation_id(self) -> str:
         """Get conversation ID for message storage."""
         return self._data.conversation_id
 
+    @property
+    def title(self) -> str | None:
+        """Get conversation title (delegated to agent)."""
+        return self._agent.conversation_title if self._agent is not None else None
+
     @property
     def history(self) -> MessageHistory:
         """Get the session's conversation history."""
@@ -130,6 +122,9 @@ class ClientSession:
         the agent stateless from the session's perspective. Messages
         are automatically added to the session's history.
 
+        Title generation is handled automatically by the agent's log_conversation
+        call when the conversation is first created.
+
         Args:
             prompt: User prompt to send to the agent
             **kwargs: Additional arguments passed to agent.run()
@@ -137,42 +132,13 @@ class ClientSession:
         Returns:
             The agent's response message
         """
-        result = await self.agent.run(
+        return await self.agent.run(
             prompt,
             message_history=self._history,
             conversation_id=self.conversation_id,
             **kwargs,
         )
 
-        # Trigger title generation after first exchange (fire-and-forget)
-        # Note: Message logging is handled by the agent itself via MessageNode.log_message
-        if not self._title_generation_triggered and self._pool.storage:
-            self._title_generation_triggered = True
-            self._title_task = asyncio.create_task(self._generate_title())
-
-        return result
-
-    async def _generate_title(self) -> None:
-        """Generate conversation title in the background."""
-        if not self._pool.storage:
-            return
-        try:
-            messages = self._history.get_history()
-            if messages:
-                title = await self._pool.storage.generate_conversation_title(
-                    self.conversation_id,
-                    messages,
-                )
-                # Also update SessionData so title is available when listing sessions
-                if title and self._manager:
-                    self._data = self._data.with_title(title)
-                    await self._manager.save(self._data)
-        except Exception:
-            logger.exception(
-                "Failed to generate conversation title",
-                conversation_id=self.conversation_id,
-            )
-
     async def switch_agent(self, agent_name: str) -> None:
         """Switch to a different agent.
 
@@ -190,16 +156,10 @@ class ClientSession:
 
         self._agent = self._pool.get_agent(agent_name)
         self._data = self._data.with_agent(agent_name)
-
         # Persist the change
         if self._manager:
             await self._manager.save(self._data)
-
-        logger.info(
-            "Switched agent",
-            session_id=self.session_id,
-            agent=agent_name,
-        )
+        logger.info("Switched agent", session_id=self.session_id, agent=agent_name)
 
     async def touch(self) -> None:
         """Update last_active timestamp and persist."""
@@ -230,10 +190,6 @@ class ClientSession:
         """
         self._data = self._data.with_metadata(**kwargs)
 
-    def clear_history(self) -> None:
-        """Clear the session's conversation history."""
-        self._history.clear()
-
     def get_history_messages(self) -> list[ChatMessage[Any]]:
         """Get all messages in the session's history."""
         return self._history.get_history()