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

agentpool_server/opencode_server/routes/session_routes.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import contextlib
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Any, Literal
@@ -16,9 +17,9 @@ from agentpool.utils import identifiers as identifier
 from agentpool_config.session import SessionQuery
 from agentpool_server.opencode_server.command_validation import validate_command
 from agentpool_server.opencode_server.converters import chat_message_to_opencode
-from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
+from agentpool_server.opencode_server.dependencies import StateDep
 from agentpool_server.opencode_server.input_provider import OpenCodeInputProvider
-from agentpool_server.opencode_server.models import (  # noqa: TC001
+from agentpool_server.opencode_server.models import (
     AssistantMessage,
     CommandRequest,
     MessagePath,
@@ -63,8 +64,16 @@ if TYPE_CHECKING:
 # =============================================================================
 
 
-def session_data_to_opencode(data: SessionData) -> Session:
-    """Convert SessionData to OpenCode Session model."""
+def session_data_to_opencode(
+    data: SessionData,
+    title: str | None = None,
+) -> Session:
+    """Convert SessionData to OpenCode Session model.
+
+    Args:
+        data: SessionData to convert
+        title: Optional title (fetched from storage by caller)
+    """
     # Convert datetime to milliseconds timestamp
     created_ms = int(data.created_at.timestamp() * 1000)
     updated_ms = int(data.last_active.timestamp() * 1000)
@@ -81,7 +90,7 @@ def session_data_to_opencode(data: SessionData) -> Session:
         id=data.session_id,
         project_id=data.project_id or "default",
         directory=data.cwd or "",
-        title=data.title or "New Session",
+        title=title or "New Session",
         version=data.version,
         time=TimeCreatedUpdated(created=created_ms, updated=updated_ms),
         parent_id=data.parent_id,
@@ -110,7 +119,6 @@ def opencode_to_session_data(
         session_id=session.id,
         agent_name=agent_name,
         conversation_id=session.id,  # Use session_id as conversation_id
-        title=session.title,
         pool_id=pool_id,
         project_id=session.project_id,
         parent_id=session.parent_id,
@@ -173,7 +181,11 @@ async def get_or_load_session(state: ServerState, session_id: str) -> Session |
     # Try to load from storage
     data = await state.pool.sessions.store.load(session_id)
     if data is not None:
-        session = session_data_to_opencode(data)
+        # Fetch title from conversation storage
+        title = None
+        if state.pool.storage:
+            title = await state.pool.storage.get_conversation_title(data.conversation_id)
+        session = session_data_to_opencode(data, title=title)
         # Cache it
         state.sessions[session_id] = session
         # Initialize runtime state
@@ -311,12 +323,23 @@ async def delete_session(session_id: str, state: StateDep) -> bool:
 
 @router.post("/{session_id}/abort")
 async def abort_session(session_id: str, state: StateDep) -> bool:
-    """Abort a running session."""
+    """Abort a running session by interrupting the agent."""
     session = await get_or_load_session(state, session_id)
     if session is None:
         raise HTTPException(status_code=404, detail="Session not found")
-    # TODO: Actually abort running operations
+
+    # Interrupt the agent to cancel any ongoing stream
+    try:
+        await state.agent.interrupt()
+        # Give a moment for the cancellation to propagate
+        await asyncio.sleep(0.1)
+    except Exception:  # noqa: BLE001
+        pass
+
+    # Update and broadcast session status to notify clients
     state.session_status[session_id] = SessionStatus(type="idle")
+    await state.broadcast_event(SessionStatusEvent.create(session_id, SessionStatus(type="idle")))
+
     return True
 
 
@@ -650,7 +673,7 @@ async def run_shell_command(
 class PermissionResponse(OpenCodeBaseModel):
     """Request body for responding to a permission request."""
 
-    response: Literal["once", "always", "reject"]
+    reply: Literal["once", "always", "reject"]
 
 
 @router.get("/{session_id}/permissions")
@@ -675,7 +698,7 @@ async def get_pending_permissions(session_id: str, state: StateDep) -> list[dict
 async def respond_to_permission(
     session_id: str,
     permission_id: str,
-    request: PermissionResponse,
+    body: PermissionResponse,
     state: StateDep,
 ) -> bool:
     """Respond to a pending permission request.
@@ -695,7 +718,7 @@ async def respond_to_permission(
         raise HTTPException(status_code=404, detail="No input provider for session")
 
     # Resolve the permission
-    resolved = input_provider.resolve_permission(permission_id, request.response)
+    resolved = input_provider.resolve_permission(permission_id, body.reply)
     if not resolved:
         raise HTTPException(status_code=404, detail="Permission not found or already resolved")
 
@@ -703,7 +726,7 @@ async def respond_to_permission(
         PermissionResolvedEvent.create(
             session_id=session_id,
             request_id=permission_id,
-            reply=request.response,
+            reply=body.reply,
         )
     )
 
@@ -982,49 +1005,78 @@ class RevertRequest(OpenCodeBaseModel):
 
 @router.post("/{session_id}/revert")
 async def revert_session(session_id: str, request: RevertRequest, state: StateDep) -> Session:
-    """Revert file changes from a specific message.
+    """Revert file changes and messages from a specific message.
 
-    Restores files to their state before the specified message's changes.
+    Removes messages from the revert point onwards and restores files to their
+    state before the specified message's changes.
     """
+    from agentpool_server.opencode_server.models import MessageRemovedEvent, PartRemovedEvent
+
     session = await get_or_load_session(state, session_id)
     if session is None:
         raise HTTPException(status_code=404, detail="Session not found")
+
+    # Get messages for this session
+    messages = state.messages.get(session_id, [])
+    if not messages:
+        raise HTTPException(status_code=400, detail="No messages to revert")
+
+    # Find the revert message index
+    revert_index = None
+    for i, msg in enumerate(messages):
+        if msg.info.id == request.message_id:
+            revert_index = i
+            break
+
+    if revert_index is None:
+        raise HTTPException(status_code=404, detail=f"Message {request.message_id} not found")
+
+    # Split messages: keep messages before revert point, remove from revert point onwards
+    messages_to_keep = messages[:revert_index]
+    messages_to_remove = messages[revert_index:]
+
+    if not messages_to_remove:
+        raise HTTPException(status_code=400, detail="No messages to revert")
+
+    # Store removed messages for unrevert
+    state.reverted_messages[session_id] = messages_to_remove
+
+    # Update message list - keep only messages before revert point
+    state.messages[session_id] = messages_to_keep
+
+    # Emit message.removed and part.removed events for all removed messages
+    for msg in messages_to_remove:
+        # Emit message.removed event
+        await state.broadcast_event(MessageRemovedEvent.create(session_id, msg.info.id))
+
+        # Emit part.removed events for all parts
+        for part in msg.parts:
+            await state.broadcast_event(PartRemovedEvent.create(session_id, msg.info.id, part.id))
+
+    # Also revert file changes if any
     file_ops = state.pool.file_ops
-    if not file_ops.changes:
-        raise HTTPException(status_code=400, detail="No file changes to revert")
-    # Get revert operations for changes since this message
-    revert_ops = file_ops.get_revert_operations(since_message_id=request.message_id)
+    if file_ops.changes:
+        revert_ops = file_ops.get_revert_operations(since_message_id=request.message_id)
+        if revert_ops:
+            fs = state.agent.env.get_fs()
+            for path, content in revert_ops:
+                try:
+                    if content is None:
+                        await fs._rm_file(path)
+                    else:
+                        content_bytes = content.encode("utf-8")
+                        await fs._pipe_file(path, content_bytes)
+                except Exception as e:
+                    detail = f"Failed to revert {path}: {e}"
+                    raise HTTPException(status_code=500, detail=detail) from e
+            file_ops.remove_changes_since_message(request.message_id)
 
-    if not revert_ops:
-        detail = f"No changes found for message {request.message_id}"
-        raise HTTPException(status_code=404, detail=detail)
-    # Get filesystem from the agent's environment
-    fs = state.agent.env.get_fs()
-    # Apply reverts using the filesystem
-    # TODO: Currently write operations only track "existed vs created", not full old content.
-    # Files that existed before a write will be restored as empty, not their original content.
-    reverted_paths = []
-    for path, content in revert_ops:
-        try:
-            if content is None:
-                # File was created (old_text=None), delete it
-                await fs._rm_file(path)
-            else:
-                # Restore original content
-                content_bytes = content.encode("utf-8")
-                await fs._pipe_file(path, content_bytes)
-            reverted_paths.append(path)
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=f"Failed to revert {path}: {e}") from e
-
-    # Remove the reverted changes from the tracker
-    file_ops.remove_changes_since_message(request.message_id)
     # Update session with revert info
     session = state.sessions[session_id]
-    # TODO: include the diff?
     revert_info = SessionRevert(message_id=request.message_id, part_id=request.part_id)
     updated_session = session.model_copy(update={"revert": revert_info})
     state.sessions[session_id] = updated_session
+
     # Broadcast session update
     await state.broadcast_event(SessionUpdatedEvent.create(updated_session))
     return updated_session
@@ -1032,36 +1084,55 @@ async def revert_session(session_id: str, request: RevertRequest, state: StateDe
 
 @router.post("/{session_id}/unrevert")
 async def unrevert_session(session_id: str, state: StateDep) -> Session:
-    """Restore all reverted file changes.
+    """Restore all reverted messages and file changes.
 
-    Re-applies the changes that were previously reverted.
+    Re-applies the messages and changes that were previously reverted.
     """
+    from agentpool_server.opencode_server.models import MessageUpdatedEvent, PartUpdatedEvent
+
     session = await get_or_load_session(state, session_id)
     if session is None:
         raise HTTPException(status_code=404, detail="Session not found")
+
+    # Restore reverted messages
+    reverted_messages = state.reverted_messages.get(session_id, [])
+    if not reverted_messages:
+        raise HTTPException(status_code=400, detail="No reverted messages to restore")
+
+    # Restore messages to conversation
+    if session_id not in state.messages:
+        state.messages[session_id] = []
+    state.messages[session_id].extend(reverted_messages)
+
+    # Emit message.updated and part.updated events for restored messages
+    for msg in reverted_messages:
+        # Emit message.updated event
+        await state.broadcast_event(MessageUpdatedEvent.create(msg.info))
+
+        # Emit part.updated events for all parts
+        for part in msg.parts:
+            await state.broadcast_event(PartUpdatedEvent.create(part))
+
+    # Clear reverted messages
+    state.reverted_messages.pop(session_id, None)
+
+    # Also unrevert file changes if any
     file_ops = state.pool.file_ops
-    if not file_ops.reverted_changes:
-        raise HTTPException(status_code=400, detail="No reverted changes to restore")
-    # Get unrevert operations
-    unrevert_ops = file_ops.get_unrevert_operations()
-    # Get filesystem from the agent's environment
-    fs = state.agent.env.get_fs()
-    # Apply unrevert - write back the new_content
-    for path, content in unrevert_ops:
-        try:
-            if content is None:
-                # File was deleted in the original change, delete it again
-                await fs._rm_file(path)
-            else:
-                # Restore the changed content
-                content_bytes = content.encode("utf-8")
-                await fs._pipe_file(path, content_bytes)
-        except Exception as e:
-            detail = f"Failed to unrevert {path}: {e}"
-            raise HTTPException(status_code=500, detail=detail) from e
-
-    # Restore the changes to the tracker
-    file_ops.restore_reverted_changes()
+    if file_ops.reverted_changes:
+        unrevert_ops = file_ops.get_unrevert_operations()
+        fs = state.agent.env.get_fs()
+        for path, content in unrevert_ops:
+            try:
+                if content is None:
+                    await fs._rm_file(path)
+                else:
+                    content_bytes = content.encode("utf-8")
+                    await fs._pipe_file(path, content_bytes)
+            except Exception as e:
+                detail = f"Failed to unrevert {path}: {e}"
+                raise HTTPException(status_code=500, detail=detail) from e
+        file_ops.restore_reverted_changes()
+
     # Clear revert info from session
     updated_session = session.model_copy(update={"revert": None})
     state.sessions[session_id] = updated_session

agentpool_server/opencode_server/routes/tui_routes.py

@@ -11,7 +11,7 @@ from typing import Literal
 from fastapi import APIRouter
 from pydantic import BaseModel, Field
 
-from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
+from agentpool_server.opencode_server.dependencies import StateDep
 from agentpool_server.opencode_server.models.events import (
     TuiCommandExecuteEvent,
     TuiPromptAppendEvent,

agentpool_server/opencode_server/server.py

@@ -11,7 +11,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from fastapi import FastAPI, Request  # noqa: TC002
-from fastapi.encoders import jsonable_encoder
 from fastapi.exceptions import RequestValidationError
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse, RedirectResponse, Response
@@ -25,7 +24,9 @@ from agentpool_server.opencode_server.routes import (
     global_router,
     lsp_router,
     message_router,
+    permission_router,
     pty_router,
+    question_router,
     session_router,
     tui_router,
 )
@@ -36,12 +37,16 @@ class OpenCodeJSONResponse(JSONResponse):
     """Custom JSON response that excludes None values (like OpenCode does)."""
 
     def render(self, content: Any) -> bytes:
+        from fastapi.encoders import jsonable_encoder
+
         return super().render(jsonable_encoder(content, exclude_none=True))
 
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Set as AbstractSet
 
+    from agentpool.storage.manager import TitleGeneratedEvent
+
 
 VERSION = "0.1.0"
 
@@ -146,6 +151,42 @@ def create_app(  # noqa: PLR0915
 
     pool.todos.on_change = on_todo_change
 
+    # Set up title generation callback to update OpenCode sessions
+
+    async def on_title_generated(event: TitleGeneratedEvent) -> None:
+        """Update session when title is generated by StorageManager."""
+        import logging
+
+        from agentpool_server.opencode_server.models.events import SessionUpdatedEvent
+        from agentpool_server.opencode_server.routes.session_routes import opencode_to_session_data
+
+        log = logging.getLogger(__name__)
+        log.info("on_title_generated called: %s, title=%s", event.conversation_id, event.title)
+
+        session_id = event.conversation_id
+        if session_id in state.sessions:
+            # Update in-memory session
+            session = state.sessions[session_id]
+            updated_session = session.model_copy(update={"title": event.title})
+            state.sessions[session_id] = updated_session
+
+            # Persist to storage
+            session_data = opencode_to_session_data(
+                updated_session,
+                agent_name=state.agent.name,
+                pool_id=state.pool.manifest.config_file_path,
+            )
+            await state.pool.sessions.store.save(session_data)
+
+            # Broadcast session update to UI
+            await state.broadcast_event(SessionUpdatedEvent.create(updated_session))
+        else:
+            log.warning("Session %s not found in state.sessions", session_id)
+
+    # Connect to storage manager's title_generated signal
+    if pool.storage:
+        pool.storage.title_generated.connect(on_title_generated)
+
     # Watchers for VCS and file events
     git_branch_watcher: Any = None
     project_file_watcher: Any = None
@@ -228,7 +269,9 @@ def create_app(  # noqa: PLR0915
         # Register callback to run when first SSE client connects
         state.on_first_subscriber = check_for_updates
 
-        yield
+        # Enter pool context to initialize session store and other components
+        async with pool:
+            yield
 
         # Shutdown - clean up
         pool.todos.on_change = None
@@ -281,6 +324,8 @@ def create_app(  # noqa: PLR0915
     app.include_router(message_router)
     app.include_router(file_router)
     app.include_router(agent_router)
+    app.include_router(permission_router)
+    app.include_router(question_router)
     app.include_router(pty_router)
     app.include_router(tui_router)
     app.include_router(lsp_router)

agentpool_server/opencode_server/state.py

@@ -16,8 +16,10 @@ if TYPE_CHECKING:
     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,
@@ -27,6 +29,23 @@ if TYPE_CHECKING:
 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.
@@ -40,6 +59,10 @@ class ServerState:
     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)
@@ -49,6 +72,10 @@ class ServerState:
     # 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)
@@ -56,6 +83,9 @@ class ServerState:
     # 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)
 

agentpool_storage/__init__.py

@@ -1,8 +1,6 @@
 """Storage provider package."""
 
 from agentpool_storage.base import StorageProvider
-from agentpool_storage.claude_provider import ClaudeStorageProvider
-from agentpool_storage.opencode_provider import OpenCodeStorageProvider
 from agentpool_storage.project_store import (
     ProjectStore,
     detect_project_root,
@@ -13,8 +11,6 @@ from agentpool_storage.project_store import (
 from agentpool_storage.session_store import SQLSessionStore
 
 __all__ = [
-    "ClaudeStorageProvider",
-    "OpenCodeStorageProvider",
     "ProjectStore",
     "SQLSessionStore",
     "StorageProvider",

agentpool_storage/base.py

@@ -38,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:
@@ -103,7 +102,6 @@ class StorageProvider:
         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,
@@ -146,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,
         *,