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

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):
@@ -26,6 +26,8 @@ class StaticResourceProvider(ResourceProvider):
     to the common ResourceProvider interface.
     """
 
+    kind = "tools"
+
     def __init__(
         self,
         name: str = "static",
@@ -46,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

@@ -1,13 +1,16 @@
 """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
+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
@@ -17,6 +16,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 +37,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 +45,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 +97,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 +148,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]}",
+                conversation_id=conversation_id or session_id,
                 pool_id=self._pool_id,
+                project_id=project_id,
                 cwd=cwd,
                 metadata=metadata or {},
             )
@@ -280,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

@@ -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.
 
@@ -27,12 +68,18 @@ 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."""
 
+    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."""
 
@@ -66,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()

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