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

agentpool_server/opencode_server/state.py

@@ -0,0 +1,151 @@
+"""Server state management."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass, field
+import time
+from typing import TYPE_CHECKING, Any
+
+
+if TYPE_CHECKING:
+    import asyncio
+
+    from agentpool import AgentPool
+    from agentpool.agents.base_agent import BaseAgent
+    from agentpool.diagnostics.lsp_manager import LSPManager
+    from agentpool_server.opencode_server.input_provider import OpenCodeInputProvider
+    from agentpool_server.opencode_server.models import (
+        Config,
+        Event,
+        MessageWithParts,
+        QuestionInfo,
+        Session,
+        SessionStatus,
+        Todo,
+    )
+
+# Type alias for async callback
+OnFirstSubscriberCallback = Callable[[], Coroutine[Any, Any, None]]
+
+
+@dataclass
+class PendingQuestion:
+    """Pending question awaiting user response."""
+
+    session_id: str
+    """Session that owns this question."""
+
+    questions: list[QuestionInfo]
+    """Questions to ask."""
+
+    future: asyncio.Future[list[list[str]]]
+    """Future that resolves when user answers."""
+
+    tool: dict[str, str] | None = None
+    """Optional tool context: {message_id, call_id}."""
+
+
+@dataclass
+class ServerState:
+    """Shared state for the OpenCode server.
+
+    Uses AgentPool for session persistence and storage.
+    In-memory state tracks active sessions and runtime data.
+    """
+
+    working_dir: str
+    pool: AgentPool[Any]
+    agent: BaseAgent[Any, Any]
+    start_time: float = field(default_factory=time.time)
+
+    # Configuration (mutable runtime config)
+    # Initialized after state creation
+    config: Config | None = None
+
+    # Active sessions cache (session_id -> OpenCode Session model)
+    # This is a cache of sessions loaded from pool.sessions
+    sessions: dict[str, Session] = field(default_factory=dict)
+    session_status: dict[str, SessionStatus] = field(default_factory=dict)
+
+    # Message storage (session_id -> messages)
+    # Runtime cache - messages are also persisted via pool.storage
+    messages: dict[str, list[MessageWithParts]] = field(default_factory=dict)
+
+    # Reverted messages storage (session_id -> removed messages)
+    # Stores messages removed during revert for unrevert operation
+    reverted_messages: dict[str, list[MessageWithParts]] = field(default_factory=dict)
+
+    # Todo storage (session_id -> todos)
+    # Uses pool.todos for persistence
+    todos: dict[str, list[Todo]] = field(default_factory=dict)
+
+    # Input providers for permission handling (session_id -> provider)
+    input_providers: dict[str, OpenCodeInputProvider] = field(default_factory=dict)
+
+    # Question storage (question_id -> pending question info)
+    pending_questions: dict[str, PendingQuestion] = field(default_factory=dict)
+
+    # SSE event subscribers
+    event_subscribers: list[asyncio.Queue[Event]] = field(default_factory=list)
+
+    # Callback for first subscriber connection (e.g., for update check)
+    on_first_subscriber: OnFirstSubscriberCallback | None = None
+    _first_subscriber_triggered: bool = field(default=False, repr=False)
+
+    # Background tasks (for cleanup on shutdown)
+    background_tasks: set[asyncio.Task[Any]] = field(default_factory=set)
+
+    # LSP manager for language server integration (initialized lazily)
+    lsp_manager: LSPManager | None = None
+
+    def create_background_task(self, coro: Any, *, name: str | None = None) -> asyncio.Task[Any]:
+        """Create and track a background task."""
+        import asyncio
+
+        task = asyncio.create_task(coro, name=name)
+        self.background_tasks.add(task)
+        task.add_done_callback(self.background_tasks.discard)
+        return task
+
+    async def cleanup_tasks(self) -> None:
+        """Cancel and wait for all background tasks."""
+        for task in self.background_tasks:
+            task.cancel()
+        if self.background_tasks:
+            import asyncio
+
+            await asyncio.gather(*self.background_tasks, return_exceptions=True)
+        self.background_tasks.clear()
+
+    async def broadcast_event(self, event: Event) -> None:
+        """Broadcast an event to all SSE subscribers."""
+        print(f"Broadcasting event: {event.type} to {len(self.event_subscribers)} subscribers")
+        for queue in self.event_subscribers:
+            await queue.put(event)
+
+    def get_or_create_lsp_manager(self) -> LSPManager:
+        """Get or create the LSP manager.
+
+        Creates the LSP manager lazily using the agent's execution environment.
+
+        Returns:
+            The LSP manager instance.
+
+        Raises:
+            RuntimeError: If the agent doesn't have an execution environment.
+        """
+        if self.lsp_manager is not None:
+            return self.lsp_manager
+
+        from agentpool.diagnostics.lsp_manager import LSPManager
+
+        # Get the execution environment from the agent
+        env = getattr(self.agent, "env", None)
+        if env is None:
+            msg = "Agent does not have an execution environment for LSP"
+            raise RuntimeError(msg)
+
+        self.lsp_manager = LSPManager(env=env)
+        self.lsp_manager.register_defaults()
+        return self.lsp_manager

agentpool_server/opencode_server/time_utils.py

@@ -0,0 +1,8 @@
+"""Time utilities for OpenCode compatibility."""
+
+import time
+
+
+def now_ms() -> int:
+    """Return current time in milliseconds as integer (OpenCode format)."""
+    return int(time.time() * 1000)

agentpool_storage/__init__.py

@@ -1,9 +1,21 @@
 """Storage provider package."""
 
 from agentpool_storage.base import StorageProvider
+from agentpool_storage.project_store import (
+    ProjectStore,
+    detect_project_root,
+    discover_config_path,
+    generate_project_id,
+    resolve_config,
+)
 from agentpool_storage.session_store import SQLSessionStore
 
 __all__ = [
+    "ProjectStore",
     "SQLSessionStore",
     "StorageProvider",
+    "detect_project_root",
+    "discover_config_path",
+    "generate_project_id",
+    "resolve_config",
 ]

agentpool_storage/base.py

@@ -19,6 +19,7 @@ if TYPE_CHECKING:
 
     from agentpool.common_types import JsonValue
     from agentpool.messaging import ChatMessage, TokenCost
+    from agentpool.sessions.models import ProjectData
     from agentpool_config.session import SessionQuery
     from agentpool_config.storage import BaseStorageProviderConfig
     from agentpool_storage.models import ConversationData, QueryFilters, StatsFilters
@@ -37,7 +38,6 @@ class StoredMessage:
     token_usage: dict[str, int] | None = None
     cost: float | None = None
     response_time: float | None = None
-    forwarded_from: list[str] | None = None
 
 
 class StoredConversation:
@@ -98,10 +98,10 @@ class StorageProvider:
         content: str,
         role: str,
         name: str | None = None,
+        parent_id: str | None = None,
         cost_info: TokenCost | None = None,
         model: str | None = None,
         response_time: float | None = None,
-        forwarded_from: list[str] | None = None,
         provider_name: str | None = None,
         provider_response_id: str | None = None,
         messages: str | None = None,
@@ -144,6 +144,87 @@ class StorageProvider:
         """
         return None
 
+    async def get_conversation_messages(
+        self,
+        conversation_id: str,
+        *,
+        include_ancestors: bool = False,
+    ) -> list[ChatMessage[str]]:
+        """Get all messages for a conversation.
+
+        Args:
+            conversation_id: ID of the conversation
+            include_ancestors: If True, also include messages from ancestor
+                conversations (following parent_id chain). Useful for forked
+                conversations where you want the full history.
+
+        Returns:
+            List of messages ordered by timestamp.
+        """
+        msg = f"{self.__class__.__name__} does not support getting conversation messages"
+        raise NotImplementedError(msg)
+
+    async def get_message(
+        self,
+        message_id: str,
+    ) -> ChatMessage[str] | None:
+        """Get a single message by ID.
+
+        Args:
+            message_id: ID of the message
+
+        Returns:
+            The message if found, None otherwise.
+        """
+        return None
+
+    async def get_message_ancestry(
+        self,
+        message_id: str,
+    ) -> list[ChatMessage[str]]:
+        """Get the ancestry chain of a message.
+
+        Traverses the parent_id chain to build full history leading to this message.
+        Useful for forked conversations where you need context from the fork point.
+
+        Args:
+            message_id: ID of the message to get ancestry for
+
+        Returns:
+            List of messages from oldest ancestor to the specified message.
+        """
+        msg = f"{self.__class__.__name__} does not support message ancestry"
+        raise NotImplementedError(msg)
+
+    async def fork_conversation(
+        self,
+        *,
+        source_conversation_id: str,
+        new_conversation_id: str,
+        fork_from_message_id: str | None = None,
+        new_agent_name: str | None = None,
+    ) -> str | None:
+        """Fork a conversation at a specific point.
+
+        Creates a new conversation that branches from the source conversation.
+        The new conversation's first message will have parent_id pointing to
+        the fork point, allowing history traversal.
+
+        Args:
+            source_conversation_id: ID of the conversation to fork from
+            new_conversation_id: ID for the new forked conversation
+            fork_from_message_id: Message ID to fork from. If None, forks from
+                the last message in the source conversation.
+            new_agent_name: Agent name for the new conversation. If None,
+                inherits from source.
+
+        Returns:
+            The message_id of the fork point (the parent for new messages),
+            or None if the source conversation is empty.
+        """
+        msg = f"{self.__class__.__name__} does not support forking conversations"
+        raise NotImplementedError(msg)
+
     async def log_command(
         self,
         *,
@@ -308,3 +389,104 @@ class StorageProvider:
             Tuple of (conversation count, message count)
         """
         raise NotImplementedError
+
+    async def delete_conversation_messages(
+        self,
+        conversation_id: str,
+    ) -> int:
+        """Delete all messages for a conversation.
+
+        Used for compaction - removes existing messages so they can be
+        replaced with compacted versions.
+
+        Args:
+            conversation_id: ID of the conversation to clear
+
+        Returns:
+            Number of messages deleted
+        """
+        msg = f"{self.__class__.__name__} does not support deleting messages"
+        raise NotImplementedError(msg)
+
+    # Project methods
+
+    async def save_project(self, project: ProjectData) -> None:
+        """Save or update a project.
+
+        Args:
+            project: Project data to persist
+        """
+        msg = f"{self.__class__.__name__} does not support project storage"
+        raise NotImplementedError(msg)
+
+    async def get_project(self, project_id: str) -> ProjectData | None:
+        """Get a project by ID.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            Project data if found, None otherwise
+        """
+        msg = f"{self.__class__.__name__} does not support project storage"
+        raise NotImplementedError(msg)
+
+    async def get_project_by_worktree(self, worktree: str) -> ProjectData | None:
+        """Get a project by worktree path.
+
+        Args:
+            worktree: Absolute path to the project worktree
+
+        Returns:
+            Project data if found, None otherwise
+        """
+        msg = f"{self.__class__.__name__} does not support project storage"
+        raise NotImplementedError(msg)
+
+    async def get_project_by_name(self, name: str) -> ProjectData | None:
+        """Get a project by friendly name.
+
+        Args:
+            name: Project name
+
+        Returns:
+            Project data if found, None otherwise
+        """
+        msg = f"{self.__class__.__name__} does not support project storage"
+        raise NotImplementedError(msg)
+
+    async def list_projects(
+        self,
+        limit: int | None = None,
+    ) -> list[ProjectData]:
+        """List all projects, ordered by last_active descending.
+
+        Args:
+            limit: Maximum number of projects to return
+
+        Returns:
+            List of project data objects
+        """
+        msg = f"{self.__class__.__name__} does not support project storage"
+        raise NotImplementedError(msg)
+
+    async def delete_project(self, project_id: str) -> bool:
+        """Delete a project.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            True if project was deleted, False if not found
+        """
+        msg = f"{self.__class__.__name__} does not support project storage"
+        raise NotImplementedError(msg)
+
+    async def touch_project(self, project_id: str) -> None:
+        """Update project's last_active timestamp.
+
+        Args:
+            project_id: Project identifier
+        """
+        msg = f"{self.__class__.__name__} does not support project storage"
+        raise NotImplementedError(msg)