openhands-agent-server 1.49.0__tar.gz → 1.49.2__tar.gz

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.49.0
+Version: 1.49.2
 Summary: OpenHands Agent Server - REST/WebSocket interface for OpenHands AI Agent
 Project-URL: Source, https://github.com/OpenHands/software-agent-sdk
 Project-URL: Homepage, https://github.com/OpenHands/software-agent-sdk

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands/agent_server/conversation_registry.py

@@ -3,10 +3,15 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
+from uuid import UUID
 
 from fastapi import APIRouter
 
 from openhands.agent_server.config import Config
+from openhands.agent_server.models import (
+    ConversationRuntimeInfo,
+    ConversationRuntimeStatus,
+)
 
 
 if TYPE_CHECKING:
@@ -22,6 +27,18 @@ class ConversationRegistry:
     def configure_service(self, service: ConversationService) -> None:
         """Connect runtime-specific persistence to the shared catalog."""
 
+    def runtime_info(self, _conversation_id: UUID) -> ConversationRuntimeInfo:
+        """Describe whether a catalog conversation has an executable runtime."""
+        return ConversationRuntimeInfo(
+            runtime_status=ConversationRuntimeStatus.AVAILABLE,
+            can_resume=True,
+        )
+
+    @property
+    def serves_persisted_event_reads(self) -> bool:
+        """Whether read-only event routes should use shared persisted storage."""
+        return False
+
     async def start(self) -> None:
         """Start resources owned by this registry."""
 

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands/agent_server/conversation_router.py

@@ -19,6 +19,7 @@ from openhands.agent_server._secrets_exposure import (
     decrypt_incoming_llm_secrets,
     get_cipher,
 )
+from openhands.agent_server.conversation_registry import ConversationRegistry
 from openhands.agent_server.conversation_service import (
     ConversationService,
     InvalidParentConversation,
@@ -89,9 +90,21 @@ START_CONVERSATION_EXAMPLES = [
 # Read methods
 
 
+def _with_runtime_info(
+    request: Request, conversation: ConversationInfo
+) -> ConversationInfo:
+    registry = getattr(request.app.state, "conversation_registry", None)
+    if not isinstance(registry, ConversationRegistry):
+        return conversation
+    return conversation.model_copy(
+        update={"runtime_info": registry.runtime_info(conversation.id)}
+    )
+
+
 @conversation_catalog_router.get("/search", include_in_schema=False)
 @conversation_router.get("/search")
 async def search_conversations(
+    request: Request,
     page_id: Annotated[
         str | None,
         Query(title="Optional next_page_id from the previously returned page"),
@@ -127,6 +140,9 @@ async def search_conversations(
                 ]
             }
         )
+    page = page.model_copy(
+        update={"items": [_with_runtime_info(request, item) for item in page.items]}
+    )
     return page
 
 
@@ -149,6 +165,7 @@ async def count_conversations(
 )
 async def get_conversation(
     conversation_id: UUID,
+    request: Request,
     include_skills: Annotated[bool, Query(title=INCLUDE_SKILLS_PARAM_TITLE)] = False,
     conversation_service: ConversationService = Depends(get_conversation_service),
 ) -> ConversationInfo:
@@ -158,30 +175,36 @@ async def get_conversation(
         raise HTTPException(status.HTTP_404_NOT_FOUND)
     if not include_skills:
         conversation = trim_conversation_response_skills(conversation)
-    return conversation
+    return _with_runtime_info(request, conversation)
 
 
 @conversation_router.get("/{conversation_id}/runtime")
 async def get_local_conversation_runtime(
     conversation_id: UUID,
+    request: Request,
     conversation_service: ConversationService = Depends(get_conversation_service),
 ) -> ConversationRuntimeInfo:
     """Inspect the always-available in-process runtime."""
     if await conversation_service.get_conversation(conversation_id) is None:
         raise HTTPException(status.HTTP_404_NOT_FOUND)
+    registry = getattr(request.app.state, "conversation_registry", None)
+    if isinstance(registry, ConversationRegistry):
+        return registry.runtime_info(conversation_id)
     return ConversationRuntimeInfo(
-        runtime_status=ConversationRuntimeStatus.AVAILABLE,
-        can_resume=True,
+        runtime_status=ConversationRuntimeStatus.AVAILABLE, can_resume=True
     )
 
 
 @conversation_router.post("/{conversation_id}/runtime/reprovision")
 async def reprovision_local_conversation_runtime(
     conversation_id: UUID,
+    request: Request,
     conversation_service: ConversationService = Depends(get_conversation_service),
 ) -> ConversationRuntimeInfo:
     """Return local runtime state; local mode has no infrastructure to provision."""
-    return await get_local_conversation_runtime(conversation_id, conversation_service)
+    return await get_local_conversation_runtime(
+        conversation_id, request, conversation_service
+    )
 
 
 @conversation_router.get(
@@ -207,6 +230,7 @@ async def get_conversation_agent_final_response(
 
 @conversation_router.get("")
 async def batch_get_conversations(
+    request: Request,
     ids: Annotated[list[UUID], Query()],
     include_skills: Annotated[bool, Query(title=INCLUDE_SKILLS_PARAM_TITLE)] = False,
     conversation_service: ConversationService = Depends(get_conversation_service),
@@ -215,6 +239,10 @@ async def batch_get_conversations(
     any missing item"""
     assert len(ids) < 100
     conversations = await conversation_service.batch_get_conversations(ids)
+    conversations = [
+        _with_runtime_info(request, conversation) if conversation is not None else None
+        for conversation in conversations
+    ]
     if not include_skills:
         return [
             trim_conversation_response_skills(c) if c is not None else None

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands/agent_server/conversation_service.py

@@ -704,7 +704,6 @@ class ConversationService:
         default=Path("/tmp/conversation-worktrees")
     )
     acp_skill_sourcing: ACPSkillSourcing = "native"
-    sync_external_catalog: bool = False
     _event_services: dict[UUID, EventService] | None = field(default=None, init=False)
     _conversation_records: dict[UUID, _ConversationRecord] = field(
         default_factory=dict, init=False
@@ -1108,34 +1107,31 @@ class ConversationService:
             record.cached_info = None
             record.state_signature = signature
 
-    async def _reconcile_active_records(
-        self, conversation_id: UUID | None = None
-    ) -> None:
-        """Discover externally persisted records and injected live services."""
+    async def refresh_persisted_conversation(self, conversation_id: UUID) -> None:
+        """Refresh one catalog record changed by an external runtime."""
+        event_services = self._event_services
+        if event_services is None:
+            raise ValueError("inactive_service")
+        disk_records = await asyncio.to_thread(self._load_catalog_sync, conversation_id)
+        if conversation_id not in disk_records:
+            event_service = event_services.get(conversation_id)
+            if event_service is None or not event_service.is_open():
+                self._conversation_records.pop(conversation_id, None)
+            return
+        record = disk_records[conversation_id]
+        event_service = event_services.get(conversation_id)
+        if event_service is not None and event_service.is_open():
+            return
+        existing = self._conversation_records.setdefault(conversation_id, record)
+        if existing.stored != record.stored:
+            existing.stored = record.stored
+            existing.cached_info = None
+
+    async def _reconcile_active_records(self) -> None:
+        """Add injected live services to the in-memory catalog."""
         event_services = self._event_services
         if event_services is None:
             raise ValueError("inactive_service")
-        if self.sync_external_catalog:
-            disk_records = await asyncio.to_thread(
-                self._load_catalog_sync, conversation_id
-            )
-            stale_ids = (
-                {conversation_id}
-                if conversation_id is not None
-                else set(self._conversation_records)
-            ) - set(disk_records)
-            for record_id in stale_ids:
-                event_service = event_services.get(record_id)
-                if event_service is None or not event_service.is_open():
-                    self._conversation_records.pop(record_id, None)
-            for record_id, record in disk_records.items():
-                event_service = event_services.get(record_id)
-                if event_service is not None and event_service.is_open():
-                    continue
-                existing = self._conversation_records.setdefault(record_id, record)
-                if existing.stored != record.stored:
-                    existing.stored = record.stored
-                    existing.cached_info = None
         for conversation_id, event_service in event_services.items():
             if conversation_id in self._conversation_records:
                 continue
@@ -1270,8 +1266,6 @@ class ConversationService:
     async def get_conversation(self, conversation_id: UUID) -> ConversationInfo | None:
         if self._event_services is None:
             raise ValueError("inactive_service")
-        if self.sync_external_catalog:
-            await self._reconcile_active_records(conversation_id)
         record = self._conversation_records.get(conversation_id)
         if record is None:
             event_service = self._event_services.get(conversation_id)
@@ -2041,6 +2035,17 @@ class ConversationService:
     async def get_event_service(self, conversation_id: UUID) -> EventService | None:
         return await self._get_or_load_event_service(conversation_id)
 
+    async def get_persisted_event_service(
+        self, conversation_id: UUID
+    ) -> EventService | None:
+        """Open append-only event history without acquiring a runtime lease."""
+        if self._event_services is None:
+            raise ValueError("inactive_service")
+        record = self._conversation_records.get(conversation_id)
+        if record is None:
+            return None
+        return EventService.for_persisted_events(record.stored, self.conversations_dir)
+
     async def generate_conversation_title(
         self, conversation_id: UUID, max_length: int = 50, llm: LLM | None = None
     ) -> str | None:
@@ -2426,7 +2431,6 @@ class ConversationService:
             conversation_idle_ttl_seconds=config.conversation_idle_ttl_seconds,
             conversation_worktree_root=config.conversation_worktree_root,
             acp_skill_sourcing=config.acp_skill_sourcing,
-            sync_external_catalog=False,
         )
 
     async def _start_event_service(
@@ -2450,7 +2454,7 @@ class ConversationService:
             stored=stored,
             conversations_dir=self.conversations_dir,
             agent=agent,
-            cipher=self.cipher,
+            cipher=self._cipher_for(stored.id),
             mcp_tool_provider=self.mcp_tool_provider,
             credential_bindings=credential_bindings,
             owner_instance_id=self.owner_instance_id,

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands/agent_server/dependencies.py

@@ -5,6 +5,7 @@ from fastapi.security import APIKeyCookie, APIKeyHeader
 
 from openhands.agent_server.bash_service import BashEventService
 from openhands.agent_server.config import Config
+from openhands.agent_server.conversation_registry import ConversationRegistry
 from openhands.agent_server.conversation_service import ConversationService
 from openhands.agent_server.event_service import EventService
 
@@ -90,9 +91,19 @@ async def get_bash_event_service(request: Request) -> BashEventService:
 
 async def get_event_service(
     conversation_id: UUID,
+    request: Request,
     conversation_service: ConversationService = Depends(get_conversation_service),
 ) -> EventService:
-    event_service = await conversation_service.get_event_service(conversation_id)
+    registry = getattr(request.app.state, "conversation_registry", None)
+    if (
+        isinstance(registry, ConversationRegistry)
+        and registry.serves_persisted_event_reads
+    ):
+        event_service = await conversation_service.get_persisted_event_service(
+            conversation_id
+        )
+    else:
+        event_service = await conversation_service.get_event_service(conversation_id)
     if event_service is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands/agent_server/docker_runtime/provisioning.py

@@ -77,10 +77,14 @@ class RuntimeProvisioningStore:
             raise ValueError("Runtime mount must not follow a symlink")
         return resolved
 
-    def load(self, conversation_id: UUID) -> RuntimeIdentity:
+    def load_optional(self, conversation_id: UUID) -> RuntimeIdentity | None:
+        """Load an identity, returning ``None`` only when it does not exist."""
         path = self.manifest_path(conversation_id)
         try:
             manifest_stat = path.lstat()
+        except FileNotFoundError:
+            self._identities.pop(conversation_id, None)
+            return None
         except OSError:
             self._identities.pop(conversation_id, None)
             raise ValueError("Conversation runtime identity is unavailable") from None
@@ -103,6 +107,12 @@ class RuntimeProvisioningStore:
         self._identities[conversation_id] = (signature, identity)
         return identity
 
+    def load(self, conversation_id: UUID) -> RuntimeIdentity:
+        identity = self.load_optional(conversation_id)
+        if identity is None:
+            raise ValueError("Conversation runtime identity is unavailable")
+        return identity
+
     def create(
         self, conversation_id: UUID, workspace_path: Path | None = None
     ) -> RuntimeIdentity:
@@ -133,6 +143,14 @@ class RuntimeProvisioningStore:
             else:
                 if not workspace_path.is_absolute():
                     raise ValueError("Conversation workspace must be absolute")
+                if workspace_path.is_symlink():
+                    raise ValueError("Conversation workspace must be a real directory")
+                try:
+                    workspace_path.mkdir(parents=True, mode=0o700, exist_ok=True)
+                except OSError as exc:
+                    raise ValueError(
+                        "Conversation workspace must be a real directory"
+                    ) from exc
                 if workspace_path.is_symlink() or not workspace_path.is_dir():
                     raise ValueError("Conversation workspace must be a real directory")
                 workspace_path = workspace_path.resolve()

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands/agent_server/docker_runtime/registry.py

@@ -17,8 +17,13 @@ from uuid import UUID, uuid4
 from openhands.agent_server.config import V1_SESSION_API_KEY_ENV, Config
 from openhands.agent_server.conversation_registry import ConversationRegistry
 from openhands.agent_server.docker_runtime.provisioning import RuntimeProvisioningStore
+from openhands.agent_server.models import (
+    ConversationRuntimeInfo,
+    ConversationRuntimeStatus,
+)
 from openhands.agent_server.persistence.store import _get_persistence_dir
 from openhands.sdk.logger import get_logger
+from openhands.sdk.utils.cipher import Cipher
 from openhands.sdk.utils.command import execute_command, sanitized_env
 
 
@@ -67,14 +72,44 @@ class DockerConversationRegistry(ConversationRegistry):
         self.provisioning = RuntimeProvisioningStore(config)
         self._containers: dict[UUID, ConversationContainer] = {}
         self._starts: dict[UUID, asyncio.Task[ConversationContainer]] = {}
+        self._deleting: set[UUID] = set()
         self._lock = asyncio.Lock()
 
     def configure_service(self, service: ConversationService) -> None:
-        service.sync_external_catalog = True
-        service.runtime_cipher_resolver = (
-            lambda conversation_id: self.provisioning.load(conversation_id).cipher
+        service.runtime_cipher_resolver = self.resolve_persisted_cipher
+
+    def resolve_persisted_cipher(self, conversation_id: UUID) -> Cipher:
+        """Resolve persisted state without weakening per-runtime isolation.
+
+        Conversations created before Docker mode have no provisioning identity and
+        were encrypted with the host key. A present but invalid identity still
+        raises rather than falling back to that key.
+        """
+        identity = self.provisioning.load_optional(conversation_id)
+        return identity.cipher if identity is not None else self.provisioning.cipher
+
+    def runtime_info(self, conversation_id: UUID) -> ConversationRuntimeInfo:
+        identity = self.provisioning.load_optional(conversation_id)
+        if identity is None:
+            return ConversationRuntimeInfo(
+                runtime_status=ConversationRuntimeStatus.MISSING,
+                can_resume=False,
+            )
+        return ConversationRuntimeInfo(
+            runtime_status=(
+                ConversationRuntimeStatus.AVAILABLE
+                if self.get(conversation_id)
+                else ConversationRuntimeStatus.STARTING
+                if self.is_starting(conversation_id)
+                else ConversationRuntimeStatus.MISSING
+            ),
+            can_resume=True,
         )
 
+    @property
+    def serves_persisted_event_reads(self) -> bool:
+        return True
+
     async def start(self) -> None:
         await asyncio.to_thread(self.cleanup_stale_containers)
 
@@ -82,7 +117,12 @@ class DockerConversationRegistry(ConversationRegistry):
         from openhands.agent_server.docker_runtime.routers import (
             docker_conversation_router,
         )
+        from openhands.agent_server.event_router import event_read_router
 
+        # Persisted event history is safe to read from the outer catalog for
+        # both Docker-backed and historical host-local conversations. Writes
+        # continue through the runtime proxy below.
+        router.include_router(event_read_router)
         router.include_router(docker_conversation_router)
 
     @property
@@ -137,6 +177,8 @@ class DockerConversationRegistry(ConversationRegistry):
 
     async def get_or_create(self, conversation_id: UUID) -> ConversationContainer:
         async with self._lock:
+            if conversation_id in self._deleting:
+                raise RuntimeError("Conversation is being deleted")
             container = self._containers.get(conversation_id)
 
         if container is not None:
@@ -147,6 +189,8 @@ class DockerConversationRegistry(ConversationRegistry):
                     self._containers.pop(conversation_id)
 
         async with self._lock:
+            if conversation_id in self._deleting:
+                raise RuntimeError("Conversation is being deleted")
             task = self._starts.get(conversation_id)
             if task is None:
                 task = asyncio.create_task(
@@ -175,6 +219,17 @@ class DockerConversationRegistry(ConversationRegistry):
             self._containers[conversation_id] = container
             return container
 
+    async def begin_delete(self, conversation_id: UUID) -> bool:
+        async with self._lock:
+            if conversation_id in self._deleting:
+                return False
+            self._deleting.add(conversation_id)
+            return True
+
+    async def finish_delete(self, conversation_id: UUID) -> None:
+        async with self._lock:
+            self._deleting.discard(conversation_id)
+
     async def stop(self, conversation_id: UUID) -> None:
         async with self._lock:
             task = self._starts.pop(conversation_id, None)

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands/agent_server/docker_runtime/routers.py

@@ -12,6 +12,7 @@ import httpx
 from fastapi import APIRouter, HTTPException, Query, Request, WebSocket
 from starlette.responses import JSONResponse, Response, StreamingResponse
 
+from openhands.agent_server.dependencies import get_conversation_service
 from openhands.agent_server.docker_runtime.mediation import (
     materialize_secrets,
     prepare_start,
@@ -137,6 +138,10 @@ async def start_conversation(
     if response.is_error:
         await registry.stop(conversation_id)
         content = {"detail": "Conversation runtime rejected the request"}
+    else:
+        await get_conversation_service(request).refresh_persisted_conversation(
+            conversation_id
+        )
     return JSONResponse(content=content, status_code=response.status_code)
 
 
@@ -147,18 +152,9 @@ async def runtime_info(
     conversation_id: UUID, request: Request
 ) -> ConversationRuntimeInfo:
     registry = get_registry(request)
-    if not registry.provisioning.manifest_path(conversation_id).is_file():
+    if not registry.conversation_dir(conversation_id).joinpath("meta.json").is_file():
         raise HTTPException(404, "Conversation not found")
-    return ConversationRuntimeInfo(
-        runtime_status=(
-            ConversationRuntimeStatus.AVAILABLE
-            if registry.get(conversation_id)
-            else ConversationRuntimeStatus.STARTING
-            if registry.is_starting(conversation_id)
-            else ConversationRuntimeStatus.MISSING
-        ),
-        can_resume=True,
-    )
+    return registry.runtime_info(conversation_id)
 
 
 @docker_conversation_router.post("/{conversation_id}/runtime/credentials")
@@ -179,6 +175,9 @@ async def release_runtime(conversation_id: UUID, request: Request) -> Response:
         raise HTTPException(404, "Conversation not found")
     try:
         await registry.stop(conversation_id)
+        await get_conversation_service(request).refresh_persisted_conversation(
+            conversation_id
+        )
     except Exception as exc:
         logger.exception("Could not release conversation runtime %s", conversation_id)
         raise HTTPException(502, "Could not release conversation runtime") from exc
@@ -204,22 +203,31 @@ async def delete_conversation(conversation_id: UUID, request: Request) -> Respon
     if not registry.provisioning.manifest_path(conversation_id).is_file():
         raise HTTPException(404, "Conversation not found")
 
+    if not await registry.begin_delete(conversation_id):
+        raise HTTPException(409, "Conversation deletion is already in progress")
+
     # Stopping the container closes its conversation service. The outer server
     # owns the bind-mounted state and removes it after Docker has unmounted it;
     # asking the inner server to remove the mount root leaves that root in a
     # partially deleted state.
-    await registry.stop(conversation_id)
-    registry.provisioning.manifest_path(conversation_id).unlink(missing_ok=True)
-    await asyncio.to_thread(
-        safe_rmtree, registry.provisioning.runtime_dir(conversation_id)
-    )
-    await asyncio.to_thread(safe_rmtree, registry.conversation_dir(conversation_id))
+    try:
+        await registry.stop(conversation_id)
+        registry.provisioning.manifest_path(conversation_id).unlink(missing_ok=True)
+        await asyncio.to_thread(
+            safe_rmtree, registry.provisioning.runtime_dir(conversation_id)
+        )
+        await asyncio.to_thread(safe_rmtree, registry.conversation_dir(conversation_id))
+        await get_conversation_service(request).refresh_persisted_conversation(
+            conversation_id
+        )
+    finally:
+        await registry.finish_delete(conversation_id)
     return Response(status_code=200)
 
 
 @docker_conversation_router.api_route(
     "/{conversation_id}",
-    methods=["GET", "POST", "PUT", "PATCH", "OPTIONS", "HEAD"],
+    methods=["POST", "PUT", "PATCH", "OPTIONS"],
 )
 async def proxy_conversation_root(
     conversation_id: UUID, request: Request
@@ -243,6 +251,7 @@ async def proxy_conversation(
         raise HTTPException(501, "This operation is unavailable in Docker runtime mode")
     registry = get_registry(request)
     container = await _container(registry, conversation_id)
+    upstream_path = _upstream_path(request, request.url.path)
     if tail == "secrets" and request.method == "POST":
         try:
             update = UpdateSecretsRequest.model_validate_json(await request.body())
@@ -260,21 +269,23 @@ async def proxy_conversation(
         body = UpdateSecretsRequest(secrets=materialized).model_dump(
             mode="json", context={"expose_secrets": "plaintext"}
         )
-        return await proxy_http(
+        response = await proxy_http(
             request,
             container,
-            upstream_path=_upstream_path(
-                request, f"/api/conversations/{conversation_id}/{tail}"
-            ),
+            upstream_path=upstream_path,
             body=json.dumps(body).encode(),
         )
-    return await proxy_http(
-        request,
-        container,
-        upstream_path=_upstream_path(
-            request, f"/api/conversations/{conversation_id}/{tail}"
-        ),
-    )
+    else:
+        response = await proxy_http(
+            request,
+            container,
+            upstream_path=upstream_path,
+        )
+    if request.method not in {"GET", "HEAD", "OPTIONS"} and response.status_code < 400:
+        await get_conversation_service(request).refresh_persisted_conversation(
+            conversation_id
+        )
+    return response
 
 
 docker_workspace_router = APIRouter(prefix="/conversations", tags=["Docker Workspace"])
@@ -320,11 +331,16 @@ async def _proxy_socket(
         return
     query = strip_auth_query("?" + websocket.url.query).lstrip("?")
     path = f"/sockets/{socket_name}/{conversation_id}"
-    await bridge_websocket(
-        websocket,
-        container,
-        upstream_path=f"{path}?{query}" if query else path,
-    )
+    try:
+        await bridge_websocket(
+            websocket,
+            container,
+            upstream_path=f"{path}?{query}" if query else path,
+        )
+    finally:
+        await websocket.app.state.conversation_service.refresh_persisted_conversation(
+            conversation_id
+        )
 
 
 @docker_sockets_router.websocket("/events/{conversation_id}")

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands/agent_server/event_router.py

@@ -27,7 +27,10 @@ from openhands.sdk import Message
 from openhands.sdk.event import Event
 
 
-event_router = APIRouter(
+event_read_router = APIRouter(
+    prefix="/conversations/{conversation_id}/events", tags=["Events"]
+)
+event_write_router = APIRouter(
     prefix="/conversations/{conversation_id}/events", tags=["Events"]
 )
 logger = logging.getLogger(__name__)
@@ -62,7 +65,9 @@ def normalize_datetime_to_server_timezone(dt: datetime) -> datetime:
         return dt
 
 
-@event_router.get("/search", responses={404: {"description": "Conversation not found"}})
+@event_read_router.get(
+    "/search", responses={404: {"description": "Conversation not found"}}
+)
 async def search_conversation_events(
     page_id: Annotated[
         str | None,
@@ -134,7 +139,9 @@ async def search_conversation_events(
     )
 
 
-@event_router.get("/count", responses={404: {"description": "Conversation not found"}})
+@event_read_router.get(
+    "/count", responses={404: {"description": "Conversation not found"}}
+)
 async def count_conversation_events(
     kind: Annotated[
         str | None,
@@ -178,7 +185,9 @@ async def count_conversation_events(
     return count
 
 
-@event_router.get("/{event_id}", responses={404: {"description": "Item not found"}})
+@event_read_router.get(
+    "/{event_id}", responses={404: {"description": "Item not found"}}
+)
 async def get_conversation_event(
     event_id: str,
     event_service: EventService = Depends(get_event_service),
@@ -190,7 +199,7 @@ async def get_conversation_event(
     return event
 
 
-@event_router.get("")
+@event_read_router.get("")
 async def batch_get_conversation_events(
     event_ids: list[str],
     event_service: EventService = Depends(get_event_service),
@@ -201,7 +210,7 @@ async def batch_get_conversation_events(
     return events
 
 
-@event_router.post("")
+@event_write_router.post("")
 async def send_message(
     request: SendMessageRequest,
     event_service: EventService = Depends(get_event_service),
@@ -212,7 +221,7 @@ async def send_message(
     return Success()
 
 
-@event_router.post(
+@event_write_router.post(
     "/respond_to_confirmation", responses={404: {"description": "Item not found"}}
 )
 async def respond_to_confirmation(
@@ -222,3 +231,8 @@ async def respond_to_confirmation(
     """Accept or reject a pending action in confirmation mode."""
     await event_service.respond_to_confirmation(request)
     return Success()
+
+
+event_router = APIRouter()
+event_router.include_router(event_read_router)
+event_router.include_router(event_write_router)

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands/agent_server/event_service.py

@@ -34,6 +34,7 @@ from openhands.sdk.agent.acp_file_credentials import (
 )
 from openhands.sdk.agent.stream_context import StreamProgress
 from openhands.sdk.conversation.base import BaseConversation
+from openhands.sdk.conversation.event_store import EventLog
 from openhands.sdk.conversation.events_list_base import EventsListBase
 from openhands.sdk.conversation.exceptions import ConversationRunError
 from openhands.sdk.conversation.goal import (
@@ -51,7 +52,7 @@ from openhands.sdk.conversation.impl.local_conversation import (
     ACP_SUPERSEDE_INFLIGHT_PROMPT,
     LocalConversation,
 )
-from openhands.sdk.conversation.persistence_const import BASE_STATE
+from openhands.sdk.conversation.persistence_const import BASE_STATE, EVENTS_DIR
 from openhands.sdk.conversation.response_utils import get_agent_final_response
 from openhands.sdk.conversation.secret_registry import SecretValue
 from openhands.sdk.conversation.state import (
@@ -75,6 +76,7 @@ from openhands.sdk.event.error_classification import ErrorClassification, Failur
 from openhands.sdk.event.llm_completion_log import LLMCompletionLogEvent
 from openhands.sdk.git.exceptions import GitCommandError, GitRepositoryError
 from openhands.sdk.git.utils import run_git_command, validate_git_repository
+from openhands.sdk.io import LocalFileStore
 from openhands.sdk.llm.streaming import LLMStreamChunk
 from openhands.sdk.mcp.utils import MCPToolProvider
 from openhands.sdk.security.analyzer import SecurityAnalyzerBase
@@ -135,6 +137,7 @@ class EventService:
     owner_instance_id: str = field(default_factory=lambda: uuid4().hex)
     lease_ttl_seconds: float = DEFAULT_LEASE_TTL_SECONDS
     _conversation: LocalConversation | None = field(default=None, init=False)
+    _persisted_events: EventLog | None = field(default=None, init=False)
     _pub_sub: PubSub[Event] = field(
         default_factory=lambda: PubSub[Event](max_subscribers=50), init=False
     )
@@ -407,6 +410,25 @@ class EventService:
             raise ValueError("inactive_service")
         return self._conversation
 
+    @classmethod
+    def for_persisted_events(
+        cls, stored: StoredConversation, conversations_dir: Path
+    ) -> "EventService":
+        """Open append-only history without starting a conversation runtime."""
+        service = cls(stored=stored, conversations_dir=conversations_dir)
+        conversation_dir = conversations_dir / stored.id.hex
+        service._persisted_events = EventLog(
+            LocalFileStore(str(conversation_dir)), dir_path=EVENTS_DIR
+        )
+        return service
+
+    def _events_for_read(self) -> EventLog:
+        if self._persisted_events is not None:
+            return self._persisted_events
+        if self._conversation is None:
+            raise ValueError("inactive_service")
+        return self._conversation._state.events
+
     def _get_event_sync(self, event_id: str) -> Event | None:
         """Private sync function to get a single event.
 
@@ -414,15 +436,11 @@ class EventService:
         EventLog reads are safe without the FIFOLock because events are
         append-only and immutable once written.
         """
-        if not self._conversation:
-            raise ValueError("inactive_service")
-        events = self._conversation._state.events
+        events = self._events_for_read()
         index = events.get_index(event_id)
         return events[index]
 
     async def get_event(self, event_id: str) -> Event | None:
-        if not self._conversation:
-            raise ValueError("inactive_service")
         loop = asyncio.get_running_loop()
         return await loop.run_in_executor(None, self._get_event_sync, event_id)
 
@@ -494,10 +512,7 @@ class EventService:
             difference between "loads instantly" and "blocks for seconds"
             for long conversations.
         """
-        if not self._conversation:
-            raise ValueError("inactive_service")
-
-        events = self._conversation._state.events
+        events = self._events_for_read()
         total = len(events)
 
         # Convert datetime to ISO string for comparison (ISO strings are comparable)
@@ -560,8 +575,6 @@ class EventService:
         timestamp__gte: datetime | None = None,
         timestamp__lt: datetime | None = None,
     ) -> EventPage:
-        if not self._conversation:
-            raise ValueError("inactive_service")
         loop = asyncio.get_running_loop()
         return await loop.run_in_executor(
             None,
@@ -590,10 +603,7 @@ class EventService:
         EventLog reads are safe without the FIFOLock because events are
         append-only and immutable once written.
         """
-        if not self._conversation:
-            raise ValueError("inactive_service")
-
-        events = self._conversation._state.events
+        events = self._events_for_read()
 
         # Fast path: with no filters, the count is just the sequence length
         # and we can avoid reading any event payloads from disk.
@@ -630,8 +640,6 @@ class EventService:
         timestamp__lt: datetime | None = None,
     ) -> int:
         """Count events matching the given filters."""
-        if not self._conversation:
-            raise ValueError("inactive_service")
         loop = asyncio.get_running_loop()
         return await loop.run_in_executor(
             None,

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands/agent_server/models.py

@@ -360,6 +360,13 @@ class ConversationInfo(_ConversationInfoBase):
             "persisted events, avoiding 'Unknown kind' deserialization errors."
         ),
     )
+    runtime_info: ConversationRuntimeInfo | None = Field(
+        default=None,
+        description=(
+            "Availability of the execution runtime. Catalog responses populate "
+            "this when the hosting server manages runtime lifecycle."
+        ),
+    )
 
 
 class ConversationPage(BaseModel):

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands/agent_server/runtime_router.py

@@ -33,8 +33,10 @@ async def bind_local_conversation_runtime(
 ) -> None:
     conversation_service = get_conversation_service(request)
     event_service = await get_event_service(
-        runtime_conversation_id, conversation_service
+        runtime_conversation_id, request, conversation_service
     )
+    if event_service is None:
+        raise HTTPException(404, "Conversation not found")
     request.state.runtime_event_service = event_service
     workspace_root = Path(
         event_service.get_conversation().workspace.working_dir

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/openhands_agent_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.49.0
+Version: 1.49.2
 Summary: OpenHands Agent Server - REST/WebSocket interface for OpenHands AI Agent
 Project-URL: Source, https://github.com/OpenHands/software-agent-sdk
 Project-URL: Homepage, https://github.com/OpenHands/software-agent-sdk

{openhands_agent_server-1.49.0 → openhands_agent_server-1.49.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openhands-agent-server"
-version = "1.49.0"
+version = "1.49.2"
 description = "OpenHands Agent Server - REST/WebSocket interface for OpenHands AI Agent"
 
 requires-python = ">=3.12"