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

agentpool/resource_providers/base.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Self
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal, Self
+
+from anyenv.signals import Signal
 
 from agentpool.log import get_logger
 from agentpool.tools.base import Tool
@@ -25,19 +28,72 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
+ResourceType = Literal["tools", "prompts", "resources", "skills"]
+ProviderKind = Literal[
+    "base", "mcp", "mcp_run", "tools", "prompts", "skills", "aggregating", "custom"
+]
+
+
+@dataclass(frozen=True, slots=True)
+class ResourceChangeEvent:
+    """Event emitted when resources change in a provider.
+
+    Attributes:
+        provider_name: Name of the provider instance
+        provider_kind: Kind/type of the provider (e.g., "mcp", "tools")
+        resource_type: Type of resource that changed
+        owner: Optional owner of the provider (e.g., agent name)
+    """
+
+    provider_name: str
+    provider_kind: ProviderKind
+    resource_type: ResourceType
+    owner: str | None = None
+
+
 class ResourceProvider:
     """Base class for resource providers.
 
     Provides tools, prompts, and other resources to agents.
     Default implementations return empty lists - override as needed.
+
+    Class Attributes:
+        kind: Short slug identifying the provider type (e.g., "mcp", "tools")
+
+    Change signals (using anyenv.signals.Signal):
+        - tools_changed: Emitted when tools change
+        - prompts_changed: Emitted when prompts change
+        - resources_changed: Emitted when resources change
+        - skills_changed: Emitted when skills change
+
+    Example:
+        provider.tools_changed.connect(my_handler)
+        await provider.tools_changed.emit(provider.create_change_event("tools"))
     """
 
+    kind: ProviderKind = "base"
+
+    # Change signals - emit ResourceChangeEvent when resources change
+    tools_changed: Signal[ResourceChangeEvent] = Signal()
+    prompts_changed: Signal[ResourceChangeEvent] = Signal()
+    resources_changed: Signal[ResourceChangeEvent] = Signal()
+    skills_changed: Signal[ResourceChangeEvent] = Signal()
+
     def __init__(self, name: str, owner: str | None = None) -> None:
         """Initialize the resource provider."""
         self.name = name
         self.owner = owner
         self.log = logger.bind(name=self.name, owner=self.owner)
 
+    def create_change_event(self, resource_type: ResourceType) -> ResourceChangeEvent:
+        """Create a ResourceChangeEvent for this provider."""
+        return ResourceChangeEvent(
+            provider_name=self.name,
+            provider_kind=self.kind,
+            resource_type=resource_type,
+            owner=self.owner,
+        )
+
     async def __aenter__(self) -> Self:
         """Async context entry if required."""
         return self

agentpool/resource_providers/mcp_provider.py

@@ -28,6 +28,8 @@ logger = get_logger(__name__)
 class MCPResourceProvider(ResourceProvider):
     """Resource provider for a single MCP server."""
 
+    kind = "mcp"
+
     def __init__(
         self,
         server: MCPServerConfig | str,
@@ -104,16 +106,22 @@ 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."""
@@ -204,6 +212,21 @@ class MCPResourceProvider(ResourceProvider):
 
         return self._resources_cache or []
 
+    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,22 @@
 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.resource_providers import ResourceProvider
+from agentpool.utils.streams import TodoPriority, TodoStatus  # noqa: TC001
 
 
 if TYPE_CHECKING:
     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", "hybrid"]
 
 
 @dataclass(kw_only=True)
@@ -50,22 +53,52 @@ 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 = "granular") -> None:
+        """Initialize plan provider.
+
+        Args:
+            mode: Tool mode - 'granular' for separate tools, 'declarative' for
+                  single set_plan tool, 'hybrid' for both approaches.
+        """
         super().__init__(name="plan")
-        self._current_plan: list[PlanEntry] = []
+        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_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"),
-        ]
+        """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([
+                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) -> str:
         """Get the current plan formatted as markdown.
@@ -76,7 +109,8 @@ class PlanProvider(ResourceProvider):
         Returns:
             Markdown-formatted plan with all entries and their status
         """
-        if not self._current_plan:
+        tracker = self._get_tracker(agent_ctx)
+        if tracker is None or not tracker.entries:
             return "## Plan\n\n*No plan entries yet.*"
 
         lines = ["## Plan", ""]
@@ -90,18 +124,59 @@ 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)
 
+    async def set_plan(
+        self,
+        agent_ctx: AgentContext,
+        entries: list[dict[str, Any]],
+    ) -> str:
+        """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 "Error: No pool available for plan tracking"
+
+        # 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)
+
+        return f"Plan updated with {len(tracker.entries)} entries"
+
     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,15 +190,12 @@ 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)
 
@@ -134,8 +206,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,27 +221,26 @@ 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)
         return f"Updated entry {index}: {', '.join(updates)}"
 
@@ -183,14 +254,32 @@ 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}"
+
+        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

@@ -20,6 +20,8 @@ logger = get_logger(__name__)
 class PoolResourceProvider(ResourceProvider):
     """Provider that exposes an AgentPool's resources."""
 
+    kind = "tools"
+
     def __init__(
         self,
         pool: AgentPool[Any],

agentpool/resource_providers/static.py

@@ -26,6 +26,8 @@ class StaticResourceProvider(ResourceProvider):
     to the common ResourceProvider interface.
     """
 
+    kind = "tools"
+
     def __init__(
         self,
         name: str = "static",

agentpool/sessions/__init__.py

@@ -1,12 +1,13 @@
 """Session management package."""
 
-from agentpool.sessions.models import SessionData
+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
 
 __all__ = [
     "ClientSession",
+    "ProjectData",
     "SessionData",
     "SessionManager",
     "SessionStore",

agentpool/sessions/manager.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
 
     from agentpool.delegation.pool import AgentPool
     from agentpool.sessions.store import SessionStore
+    from agentpool.storage.manager import StorageManager
 
 logger = get_logger(__name__)
 
@@ -37,6 +38,7 @@ class SessionManager:
         pool: AgentPool[Any],
         store: SessionStore | None = None,
         pool_id: str | None = None,
+        storage: StorageManager | None = None,
     ) -> None:
         """Initialize session manager.
 
@@ -44,10 +46,12 @@ class SessionManager:
             pool: Agent pool for agent access
             store: Session persistence backend (defaults to MemorySessionStore)
             pool_id: Optional identifier for this pool (for multi-pool setups)
+            storage: Optional storage manager for project tracking
         """
         self._pool = pool
         self._store = store or MemorySessionStore()
         self._pool_id = pool_id
+        self._storage = storage
         self._active: dict[str, ClientSession] = {}
         self._lock = asyncio.Lock()
         logger.debug("Initialized session manager", pool_id=pool_id)
@@ -94,8 +98,14 @@ class SessionManager:
         logger.debug("Session manager closed", session_count=len(sessions))
 
     def generate_session_id(self) -> str:
-        """Generate a unique session ID."""
-        return f"sess_{uuid4().hex[:12]}"
+        """Generate a unique, chronologically sortable session ID.
+
+        Uses OpenCode-compatible format: ses_{hex_timestamp}{random_base62}
+        IDs are lexicographically sortable by creation time.
+        """
+        from agentpool.utils.identifiers import generate_session_id
+
+        return generate_session_id()
 
     async def create(
         self,
@@ -139,12 +149,31 @@ class SessionManager:
                 msg = f"Session '{session_id}' already exists"
                 raise ValueError(msg)
 
+            # Get or create project if cwd provided and storage available
+            project_id: str | None = None
+            if cwd and self._storage:
+                try:
+                    from agentpool_storage.project_store import ProjectStore
+
+                    project_store = ProjectStore(self._storage)
+                    project = await project_store.get_or_create(cwd)
+                    project_id = project.project_id
+                    logger.debug(
+                        "Associated session with project",
+                        session_id=session_id,
+                        project_id=project_id,
+                        worktree=project.worktree,
+                    )
+                except Exception:
+                    logger.exception("Failed to create/get project for session")
+
             # Create session data
             data = SessionData(
                 session_id=session_id,
                 agent_name=agent_name,
                 conversation_id=conversation_id or f"conv_{uuid4().hex[:12]}",
                 pool_id=self._pool_id,
+                project_id=project_id,
                 cwd=cwd,
                 metadata=metadata or {},
             )

agentpool/sessions/models.py

@@ -11,6 +11,47 @@ from schemez import Schema
 from agentpool.utils.now import get_now
 
 
+class ProjectData(Schema):
+    """Persistable project/worktree state.
+
+    Represents a codebase/worktree that agentpool operates on.
+    Sessions are associated with projects.
+    """
+
+    project_id: str
+    """Unique identifier (hash of canonical worktree path)."""
+
+    worktree: str
+    """Absolute path to the project root/worktree."""
+
+    name: str | None = None
+    """Optional friendly name for the project."""
+
+    vcs: str | None = None
+    """Version control system type ('git', 'hg', or None)."""
+
+    config_path: str | None = None
+    """Path to the project's config file, or None for auto-discovery."""
+
+    created_at: datetime = Field(default_factory=get_now)
+    """When the project was first registered."""
+
+    last_active: datetime = Field(default_factory=get_now)
+    """Last activity timestamp."""
+
+    settings: dict[str, Any] = Field(default_factory=dict)
+    """Project-specific settings overrides."""
+
+    def touch(self) -> ProjectData:
+        """Return copy with updated last_active timestamp."""
+        return self.model_copy(update={"last_active": get_now()})
+
+    def with_settings(self, **kwargs: Any) -> ProjectData:
+        """Return copy with updated settings."""
+        new_settings = {**self.settings, **kwargs}
+        return self.model_copy(update={"settings": new_settings, "last_active": get_now()})
+
+
 class SessionData(Schema):
     """Persistable session state.
 
@@ -33,6 +74,15 @@ class SessionData(Schema):
     pool_id: str | None = None
     """Optional pool/manifest identifier for multi-pool setups."""
 
+    project_id: str | None = None
+    """Project identifier (e.g., for OpenCode compatibility)."""
+
+    parent_id: str | None = None
+    """Parent session ID for forked sessions."""
+
+    version: str = "1"
+    """Session version string."""
+
     cwd: str | None = None
     """Working directory for the session."""
 

agentpool/skills/registry.py

@@ -72,7 +72,9 @@ class SkillsRegistry(BaseRegistry[str, Skill]):
             if not isinstance(fs, AsyncFileSystem):
                 fs = AsyncFileSystemWrapper(fs)
             search_path = base_path if base_path is not None else fs.root_marker
+            original_skills_dir: UPath | None = None
         else:
+            original_skills_dir = to_upath(skills_dir)
             fs = upath_to_fs(skills_dir, **storage_options)
             search_path = fs.root_marker
 
@@ -93,16 +95,19 @@ class SkillsRegistry(BaseRegistry[str, Skill]):
             return
         logger.info("Found skills", skills=skill_dirs, skills_dir=search_path)
         for skill_entry in skill_dirs:
-            skill_name = skill_entry["name"].lstrip("./")
-            # Construct full path for skill directory
-            if search_path and search_path != fs.root_marker:
-                skill_dir_path = to_upath(f"{search_path}/{skill_name}")
-                skill_md_path = f"{search_path}/{skill_name}/SKILL.md"
+            # entry["name"] is relative to the filesystem root
+            # We need to construct the full path for _parse_skill
+            entry_name = skill_entry["name"]
+            if original_skills_dir is not None:
+                # When we created fs from a path, entry names are relative to that path
+                skill_dir_path = original_skills_dir / entry_name
             else:
-                skill_dir_path = to_upath(skill_name)
-                skill_md_path = f"{skill_name}/SKILL.md"
+                # When fs was provided directly, entry names should be usable as-is
+                skill_dir_path = to_upath(entry_name)
+            # For fs._cat_file, use the path relative to the filesystem
+            fs_skill_md_path = f"{entry_name}/SKILL.md"
             try:
-                await fs._cat_file(skill_md_path)
+                await fs._cat_file(fs_skill_md_path)
             except FileNotFoundError:
                 continue