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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.47.0
+Version: 1.49.0
 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
@@ -15,7 +15,7 @@ Requires-Dist: openhands-sdk
 Requires-Dist: openai<3,>=2.33.0
 Requires-Dist: pydantic>=2
 Requires-Dist: sqlalchemy>=2
-Requires-Dist: uvicorn>=0.31.1
+Requires-Dist: uvicorn>=0.52.4
 Requires-Dist: websockets>=12
 Requires-Dist: wsproto>=1.2.0
 Provides-Extra: posthog

{openhands_agent_server-1.47.0 → openhands_agent_server-1.49.0}/openhands/agent_server/api.py

@@ -26,7 +26,13 @@ from openhands.agent_server.config import (
     Config,
     get_default_config,
 )
-from openhands.agent_server.conversation_router import conversation_router
+from openhands.agent_server.conversation_registry import (
+    create_conversation_registry,
+)
+from openhands.agent_server.conversation_router import (
+    conversation_catalog_router,
+    conversation_router,
+)
 from openhands.agent_server.conversation_service import (
     CredentialBindingActivationRequired,
     get_default_conversation_service,
@@ -38,9 +44,7 @@ from openhands.agent_server.dependencies import (
     check_session_api_key,
     check_workspace_session,
 )
-from openhands.agent_server.desktop_router import desktop_router
-from openhands.agent_server.event_router import event_router
-from openhands.agent_server.file_router import file_router
+from openhands.agent_server.file_router import file_discovery_router, file_router
 from openhands.agent_server.git_router import git_router
 from openhands.agent_server.hooks_router import hooks_router
 from openhands.agent_server.init_router import (
@@ -65,10 +69,8 @@ from openhands.agent_server.server_details_router import (
     mark_initialization_complete,
     server_details_router,
 )
-from openhands.agent_server.session_socket import session_router
 from openhands.agent_server.settings_router import settings_router
 from openhands.agent_server.skills_router import skills_router
-from openhands.agent_server.sockets import sockets_router
 from openhands.agent_server.sub_agents_router import sub_agents_router
 from openhands.agent_server.telemetry import (
     build_telemetry_sink,
@@ -91,7 +93,6 @@ from openhands.agent_server.tool_preload_service import get_tool_preload_service
 from openhands.agent_server.tool_router import tool_router
 from openhands.agent_server.vscode_router import vscode_router
 from openhands.agent_server.vscode_service import get_vscode_service
-from openhands.agent_server.workspace_router import workspace_router
 from openhands.agent_server.workspaces_router import workspaces_router
 from openhands.sdk.logger import DEBUG, get_logger
 from openhands.sdk.utils.redact import sanitize_dict
@@ -159,6 +160,10 @@ async def api_lifespan(api: FastAPI) -> AsyncIterator[None]:
 
         config: Config = api.state.config
         deferred = config.deferred_init
+        conversation_registry = getattr(
+            api.state, "conversation_registry", None
+        ) or create_conversation_registry(config)
+        api.state.conversation_registry = conversation_registry
 
         # Deferred pods boot with telemetry disabled and are rebuilt by
         # InitService, so they emit `server_started` there instead.
@@ -253,6 +258,11 @@ async def api_lifespan(api: FastAPI) -> AsyncIterator[None]:
         bash_svc = get_default_bash_event_service()
         api.state.bash_event_service = bash_svc
 
+        conversation_registry.configure_service(service)
+        # Runtime cleanup must precede external-catalog recovery so stale
+        # runtime owners cannot lose their expired leases to the outer service.
+        await conversation_registry.start()
+
         async with service:
             api.state.conversation_service = service
 
@@ -272,6 +282,7 @@ async def api_lifespan(api: FastAPI) -> AsyncIterator[None]:
             try:
                 yield
             finally:
+                await conversation_registry.shutdown()
                 if retention_task is not None:
                     retention_task.cancel()
                     with suppress(asyncio.CancelledError):
@@ -387,6 +398,7 @@ def _find_http_exception(exc: BaseExceptionGroup) -> HTTPException | None:
 
 def _add_api_routes(app: FastAPI) -> None:
     """Add all API routes to the FastAPI application."""
+    conversation_registry = app.state.conversation_registry
     app.include_router(server_details_router)
 
     # The /api/init endpoint bypasses both the session-key auth and the
@@ -411,7 +423,11 @@ def _add_api_routes(app: FastAPI) -> None:
     ]
 
     api_router = APIRouter(prefix="/api", dependencies=dependencies)
-    api_router.include_router(event_router)
+    api_router.include_router(file_discovery_router)
+    # Collection routes must precede runtime catch-alls such as
+    # ``/conversations/{conversation_id}``.
+    api_router.include_router(conversation_catalog_router)
+    conversation_registry.add_execution_routes(api_router)
     api_router.include_router(conversation_router)
     api_router.include_router(credential_binding_router)
     api_router.include_router(tool_router)
@@ -419,7 +435,6 @@ def _add_api_routes(app: FastAPI) -> None:
     api_router.include_router(git_router)
     api_router.include_router(file_router)
     api_router.include_router(vscode_router)
-    api_router.include_router(desktop_router)
     api_router.include_router(skills_router)
     api_router.include_router(sub_agents_router)
     api_router.include_router(plugins_router)
@@ -435,8 +450,6 @@ def _add_api_routes(app: FastAPI) -> None:
     # /api/auth/* mints workspace cookies and requires the header to bootstrap,
     # so it lives under the header-only auth group.
     api_router.include_router(auth_router)
-    app.include_router(api_router)
-
     app.include_router(openai_router, dependencies=[Depends(check_openai_api_key)])
 
     # Workspace static-file routes get their own auth group that accepts
@@ -447,12 +460,11 @@ def _add_api_routes(app: FastAPI) -> None:
     workspace_api_router = APIRouter(
         prefix="/api", dependencies=[Depends(check_workspace_session)]
     )
-    workspace_api_router.include_router(workspace_router)
+    workspace_api_router.include_router(conversation_registry.workspace_router)
     app.include_router(workspace_api_router)
+    app.include_router(api_router)
 
-    app.include_router(sockets_router)
-
-    app.include_router(session_router)
+    app.include_router(conversation_registry.sockets_router)
 
 
 def _setup_static_files(app: FastAPI, config: Config) -> None:
@@ -680,6 +692,7 @@ def create_app(config: Config | None = None) -> FastAPI:
         config = get_default_config()
     app = _create_fastapi_instance(config)
     app.state.config = config
+    app.state.conversation_registry = create_conversation_registry(config)
 
     _add_api_routes(app)
     _setup_static_files(app, config)

{openhands_agent_server-1.47.0 → openhands_agent_server-1.49.0}/openhands/agent_server/bash_router.py

@@ -2,6 +2,7 @@
 
 import logging
 from datetime import datetime
+from pathlib import Path
 from typing import Annotated, Literal, cast
 from uuid import UUID
 
@@ -52,13 +53,11 @@ async def search_bash_events(
     ] = None,
     limit: Annotated[
         int,
-        Query(title="The max number of results in the page", gt=0, lte=100),
+        Query(title="The max number of results in the page", gt=0, le=100),
     ] = 100,
     bash_event_service: BashEventService = Depends(get_bash_event_service),
 ) -> BashEventPage:
     """Search / List bash event events"""
-    assert limit > 0
-    assert limit <= 100
 
     return await bash_event_service.search_bash_events(
         kind__eq=kind__eq,
@@ -104,6 +103,7 @@ async def start_bash_command(
 ) -> BashCommand:
     """Execute a bash command in the background"""
     update_last_execution_time()
+    _validate_cwd(request, bash_event_service)
     command, _ = await bash_event_service.start_bash_command(request)
     return command
 
@@ -115,6 +115,7 @@ async def execute_bash_command(
 ) -> BashOutput:
     """Execute a bash command and wait for a result"""
     update_last_execution_time()
+    _validate_cwd(request, bash_event_service)
     command, task = await bash_event_service.start_bash_command(request)
     await task
     page = await bash_event_service.search_bash_events(command_id__eq=command.id)
@@ -129,3 +130,13 @@ async def clear_all_bash_events(
     """Clear all bash events from storage"""
     count = await bash_event_service.clear_all_events()
     return {"cleared_count": count}
+
+
+def _validate_cwd(request: ExecuteBashRequest, service: BashEventService) -> None:
+    if service.default_cwd is not None and request.cwd is not None:
+        if (
+            not Path(request.cwd)
+            .resolve()
+            .is_relative_to(Path(service.default_cwd).resolve())
+        ):
+            raise HTTPException(422, "cwd must be inside the conversation workspace")

{openhands_agent_server-1.47.0 → openhands_agent_server-1.49.0}/openhands/agent_server/bash_service.py

@@ -31,6 +31,9 @@ class BashEventService:
     will not be visible to the agent."""
 
     bash_events_dir: Path = field()
+    default_cwd: str | None = None
+    _tasks: set[asyncio.Task] = field(default_factory=set, init=False)
+    _closed: bool = field(default=False, init=False)
     _pub_sub: PubSub[BashEventBase] = field(
         default_factory=lambda: PubSub[BashEventBase](max_subscribers=50),
         init=False,
@@ -255,13 +258,17 @@ class BashEventService:
         self, request: ExecuteBashRequest
     ) -> tuple[BashCommand, asyncio.Task]:
         """Execute a bash command. The output will be published separately."""
-        command = BashCommand(**request.model_dump())
+        if self._closed:
+            raise RuntimeError("Bash event service is closed")
+        cwd = request.cwd or self.default_cwd
+        command = BashCommand(**{**request.model_dump(), "cwd": cwd})
         self._save_event_to_file(command)
         await self._pub_sub(command)
 
         # Execute the bash command in a background task
         task = asyncio.create_task(self._execute_bash_command(command))
-
+        self._tasks.add(task)
+        task.add_done_callback(self._tasks.discard)
         return command, task
 
     async def _execute_bash_command(self, command: BashCommand) -> None:
@@ -347,6 +354,10 @@ class BashEventService:
                     timeout=command.timeout,
                 )
                 exit_code = process.returncode
+            except asyncio.CancelledError:
+                self._signal_process_group(process, signal.SIGKILL)
+                await process.wait()
+                raise
             except TimeoutError:
                 # Send SIGTERM to the whole process group so user-installed
                 # cleanup traps can run, then escalate to SIGKILL if needed.
@@ -509,6 +520,11 @@ class BashEventService:
 
     async def close(self):
         """Close the bash event service and clean up resources."""
+        self._closed = True
+        tasks = list(self._tasks)
+        for task in tasks:
+            task.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
         await self._pub_sub.close()
 
     async def __aenter__(self):

{openhands_agent_server-1.47.0 → openhands_agent_server-1.49.0}/openhands/agent_server/config.py

@@ -346,6 +346,13 @@ class Config(BaseModel):
             "The URL where this agent server instance is available externally"
         ),
     )
+    conversation_runtime: Literal["local", "docker"] = "local"
+    conversation_image: str = "ghcr.io/openhands/agent-server:latest-python"
+    conversation_container_memory: str | None = "4g"
+    conversation_container_cpus: float | None = Field(default=2.0, gt=0)
+    conversation_container_pids_limit: int | None = Field(default=512, gt=0)
+    conversation_container_startup_timeout: float = Field(default=120, gt=0)
+
     acp_skill_sourcing: ACPSkillSourcing = Field(
         default="native",
         description=(

openhands_agent_server-1.49.0/openhands/agent_server/conversation_registry.py

@@ -0,0 +1,74 @@
+"""Select and manage the configured conversation runtime."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from fastapi import APIRouter
+
+from openhands.agent_server.config import Config
+
+
+if TYPE_CHECKING:
+    from openhands.agent_server.conversation_service import ConversationService
+
+
+class ConversationRegistry:
+    """Route and lifecycle adapter for host-local conversations."""
+
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def configure_service(self, service: ConversationService) -> None:
+        """Connect runtime-specific persistence to the shared catalog."""
+
+    async def start(self) -> None:
+        """Start resources owned by this registry."""
+
+    async def shutdown(self) -> None:
+        """Stop resources owned by this registry."""
+
+    def add_execution_routes(self, router: APIRouter) -> None:
+        from openhands.agent_server.event_router import event_router
+        from openhands.agent_server.runtime_router import create_runtime_router
+
+        router.include_router(create_runtime_router())
+        router.include_router(event_router)
+
+    @property
+    def workspace_router(self) -> APIRouter:
+        from openhands.agent_server.workspace_router import workspace_router
+
+        return workspace_router
+
+    @property
+    def conversation_sockets_router(self) -> APIRouter:
+        from openhands.agent_server.sockets import conversation_sockets_router
+
+        return conversation_sockets_router
+
+    @property
+    def session_sockets_router(self) -> APIRouter:
+        from openhands.agent_server.session_socket import session_router
+
+        return session_router
+
+    @property
+    def sockets_router(self) -> APIRouter:
+        from openhands.agent_server.sockets import bash_sockets_router
+
+        router = APIRouter()
+        router.include_router(self.conversation_sockets_router)
+        router.include_router(self.session_sockets_router)
+        router.include_router(bash_sockets_router)
+        return router
+
+
+def create_conversation_registry(config: Config) -> ConversationRegistry:
+    if config.conversation_runtime == "docker":
+        from openhands.agent_server.docker_runtime.registry import (
+            DockerConversationRegistry,
+        )
+
+        return DockerConversationRegistry(config)
+    return ConversationRegistry(config)

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

@@ -31,6 +31,8 @@ from openhands.agent_server.models import (
     AskAgentResponse,
     ConversationInfo,
     ConversationPage,
+    ConversationRuntimeInfo,
+    ConversationRuntimeStatus,
     ConversationSortOrder,
     ForkConversationRequest,
     NavigateConversationRequest,
@@ -61,6 +63,7 @@ from openhands.sdk.workspace import LocalWorkspace
 from openhands.tools.preset.default import get_default_tools
 
 
+conversation_catalog_router = APIRouter(prefix="/conversations", tags=["Conversations"])
 conversation_router = APIRouter(prefix="/conversations", tags=["Conversations"])
 
 # Examples
@@ -86,6 +89,7 @@ START_CONVERSATION_EXAMPLES = [
 # Read methods
 
 
+@conversation_catalog_router.get("/search", include_in_schema=False)
 @conversation_router.get("/search")
 async def search_conversations(
     page_id: Annotated[
@@ -94,7 +98,7 @@ async def search_conversations(
     ] = None,
     limit: Annotated[
         int,
-        Query(title="The max number of results in the page", gt=0, lte=100),
+        Query(title="The max number of results in the page", gt=0, le=100),
     ] = 100,
     status: Annotated[
         ConversationExecutionStatus | None,
@@ -108,8 +112,6 @@ async def search_conversations(
     conversation_service: ConversationService = Depends(get_conversation_service),
 ) -> ConversationPage:
     """Search / List conversations"""
-    assert limit > 0
-    assert limit <= 100
     page = await conversation_service.search_conversations(
         page_id, limit, status, sort_order
     )
@@ -128,6 +130,7 @@ async def search_conversations(
     return page
 
 
+@conversation_catalog_router.get("/count", include_in_schema=False)
 @conversation_router.get("/count")
 async def count_conversations(
     status: Annotated[
@@ -158,6 +161,29 @@ async def get_conversation(
     return conversation
 
 
+@conversation_router.get("/{conversation_id}/runtime")
+async def get_local_conversation_runtime(
+    conversation_id: UUID,
+    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)
+    return ConversationRuntimeInfo(
+        runtime_status=ConversationRuntimeStatus.AVAILABLE,
+        can_resume=True,
+    )
+
+
+@conversation_router.post("/{conversation_id}/runtime/reprovision")
+async def reprovision_local_conversation_runtime(
+    conversation_id: UUID,
+    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)
+
+
 @conversation_router.get(
     "/{conversation_id}/agent_final_response",
     responses={404: {"description": "Conversation not found"}},