openhands-agent-server 1.43.0__tar.gz → 1.44.0__tar.gz

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.43.0
+Version: 1.44.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

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/openhands/agent_server/api.py

@@ -21,6 +21,7 @@ from openhands.agent_server.agent_profiles_router import agent_profiles_router
 from openhands.agent_server.auth_router import auth_router
 from openhands.agent_server.bash_router import bash_router
 from openhands.agent_server.bash_service import get_default_bash_event_service
+from openhands.agent_server.canvas_extensions_router import canvas_extensions_router
 from openhands.agent_server.config import (
     Config,
     get_default_config,
@@ -441,6 +442,7 @@ def _add_api_routes(app: FastAPI) -> None:
     api_router.include_router(skills_router)
     api_router.include_router(sub_agents_router)
     api_router.include_router(plugins_router)
+    api_router.include_router(canvas_extensions_router)
     api_router.include_router(hooks_router)
     api_router.include_router(llm_router)
     api_router.include_router(provider_connections_router)

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/openhands/agent_server/canvas_extensions/__init__.py

@@ -7,7 +7,9 @@ from openhands.agent_server.canvas_extensions.installed import (
     check_canvas_extension_update,
     disable_canvas_extension,
     enable_canvas_extension,
+    get_canvas_extension_bundle_path,
     get_installed_canvas_extension,
+    get_installed_canvas_extension_manifest,
     get_installed_canvas_extensions_dir,
     install_canvas_extension,
     list_installed_canvas_extensions,
@@ -37,7 +39,9 @@ __all__ = [
     "list_installed_canvas_extensions",
     "load_installed_canvas_extensions",
     "get_installed_canvas_extension",
+    "get_installed_canvas_extension_manifest",
     "get_installed_canvas_extensions_dir",
+    "get_canvas_extension_bundle_path",
     "CanvasExtensionUpdateCheck",
     "check_canvas_extension_update",
     "apply_canvas_extension_update",

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/openhands/agent_server/canvas_extensions/installed.py

@@ -206,6 +206,47 @@ def get_installed_canvas_extension(
     return _manager(_resolve_installed_dir(installed_dir)).get(name)
 
 
+def get_installed_canvas_extension_manifest(
+    name: str, installed_dir: Path | None = None
+) -> CanvasExtensionManifest | None:
+    """Load the validated manifest for an installed extension.
+
+    Re-reads and re-validates the stored manifest against the live install
+    path -- the copy validated at install time may have changed on disk
+    since.
+
+    Returns:
+        None if not installed, or if the install no longer validates.
+    """
+    installed_dir = _resolve_installed_dir(installed_dir)
+    if get_installed_canvas_extension(name, installed_dir) is None:
+        return None
+    try:
+        return CanvasExtensionInstallationInterface.load_from_dir(installed_dir / name)
+    except (ValidationError, ValueError, OSError):
+        return None
+
+
+def get_canvas_extension_bundle_path(
+    name: str, installed_dir: Path | None = None
+) -> Path | None:
+    """Resolve the on-disk path to *name*'s entrypoint bundle file.
+
+    Re-validates the manifest and entrypoint containment against the live
+    install path on every call -- this backs a bundle serve, so the check
+    done at install time isn't enough on its own (a symlink could change
+    between requests).
+
+    Returns:
+        None if not installed, or if the install no longer validates.
+    """
+    installed_dir = _resolve_installed_dir(installed_dir)
+    manifest = get_installed_canvas_extension_manifest(name, installed_dir)
+    if manifest is None:
+        return None
+    return resolve_entrypoint(manifest, installed_dir / name)
+
+
 class CanvasExtensionUpdateCheck(BaseModel):
     """Result of ``check_canvas_extension_update``.
 

openhands_agent_server-1.44.0/openhands/agent_server/canvas_extensions_router.py

@@ -0,0 +1,291 @@
+"""Canvas Extensions router for OpenHands Agent Server.
+
+HTTP API endpoints for canvas extension operations. Business logic is
+delegated to ``canvas_extensions/installed.py``; this module mirrors
+``plugins_router.py`` / ``skills_router.py`` and stays focused on HTTP
+concerns: install / list / get / enable-disable / uninstall, plus serving
+an installed extension's entrypoint bundle to the Canvas frontend.
+"""
+
+from typing import Annotated, Final
+
+from fastapi import APIRouter, HTTPException, Path
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field, ValidationError
+
+from openhands.agent_server.canvas_extensions.installed import (
+    InstalledCanvasExtensionInfo,
+    disable_canvas_extension,
+    enable_canvas_extension,
+    get_canvas_extension_bundle_path,
+    get_installed_canvas_extension,
+    get_installed_canvas_extension_manifest,
+    install_canvas_extension,
+    list_installed_canvas_extensions,
+    uninstall_canvas_extension,
+)
+from openhands.agent_server.canvas_extensions.manifest import CanvasExtensionManifest
+from openhands.sdk.extensions.fetch import ExtensionFetchError
+
+
+canvas_extensions_router = APIRouter(
+    prefix="/canvas-extensions", tags=["Canvas Extensions"]
+)
+
+# Matches the SDK's validate_extension_name() rule.
+CANVAS_EXTENSION_NAME_PATTERN: Final[str] = r"^[a-z0-9]+(?:-[a-z0-9]+)*$"
+
+CanvasExtensionNamePath = Annotated[
+    str,
+    Path(
+        min_length=1,
+        max_length=255,
+        pattern=CANVAS_EXTENSION_NAME_PATTERN,
+        description="Canvas extension name (lowercase alphanumeric, hyphens)",
+    ),
+]
+
+
+class InstallCanvasExtensionRequest(BaseModel):
+    """Request body for installing a canvas extension."""
+
+    source: str = Field(
+        min_length=1,
+        description=(
+            "Canvas extension source - git URL, GitHub shorthand, or local "
+            "path. Examples: 'github:owner/repo', '/path/to/extension'"
+        ),
+    )
+    ref: str | None = Field(
+        default=None, description="Optional branch, tag, or commit to install"
+    )
+    repo_path: str | None = Field(
+        default=None,
+        description="Subdirectory path within the repository (for monorepos)",
+    )
+    force: bool = Field(
+        default=False, description="If true, overwrite existing installation"
+    )
+
+
+class InstalledCanvasExtensionResponse(BaseModel):
+    """Response containing installed canvas extension information."""
+
+    name: str = Field(description="Canvas extension name")
+    version: str = Field(default="", description="Canvas extension version")
+    description: str = Field(default="", description="Canvas extension description")
+    enabled: bool = Field(
+        default=False, description="Whether the canvas extension is enabled"
+    )
+    source: str = Field(description="Original source (e.g., 'github:owner/repo')")
+    resolved_ref: str | None = Field(
+        default=None, description="Resolved git commit SHA"
+    )
+    repo_path: str | None = Field(
+        default=None, description="Subdirectory path within the repository"
+    )
+    installed_at: str = Field(description="ISO 8601 timestamp of installation")
+    install_path: str = Field(description="Path where the extension is installed")
+    manifest: CanvasExtensionManifest | None = Field(
+        default=None,
+        description=(
+            "The extension's validated manifest (display_name, "
+            "contributes.pages, ...). None if the installed manifest can "
+            "no longer be read."
+        ),
+    )
+
+    @classmethod
+    def from_info(
+        cls,
+        info: InstalledCanvasExtensionInfo,
+        manifest: CanvasExtensionManifest | None,
+    ) -> "InstalledCanvasExtensionResponse":
+        return cls(
+            name=info.name,
+            version=info.version,
+            description=info.description,
+            enabled=info.enabled,
+            source=info.source,
+            resolved_ref=info.resolved_ref,
+            repo_path=info.repo_path,
+            installed_at=info.installed_at,
+            install_path=str(info.install_path),
+            manifest=manifest,
+        )
+
+
+class InstalledCanvasExtensionsListResponse(BaseModel):
+    """Response containing the list of installed canvas extensions."""
+
+    canvas_extensions: list[InstalledCanvasExtensionResponse]
+
+
+class UpdateCanvasExtensionStateRequest(BaseModel):
+    """Request body for updating canvas extension state (enable/disable)."""
+
+    enabled: bool
+
+
+class UpdateCanvasExtensionStateResponse(BaseModel):
+    """Response from a canvas extension state update."""
+
+    name: str
+    enabled: bool
+
+
+class UninstallCanvasExtensionResponse(BaseModel):
+    """Response from a canvas extension uninstall."""
+
+    message: str
+
+
+@canvas_extensions_router.post(
+    "/install",
+    response_model=InstalledCanvasExtensionResponse,
+    responses={
+        400: {"description": "Failed to fetch canvas extension source"},
+        409: {"description": "Canvas extension already installed (use force=true)"},
+        422: {"description": "Invalid canvas extension (bad manifest, etc.)"},
+    },
+)
+def install_canvas_extension_endpoint(
+    request: InstallCanvasExtensionRequest,
+) -> InstalledCanvasExtensionResponse:
+    """Install a canvas extension from a git URL, GitHub shorthand, or local
+    path.
+
+    A fresh install always lands disabled, regardless of the request body --
+    there is no ``enabled`` field to smuggle a different state through.
+    """
+    try:
+        info = install_canvas_extension(
+            source=request.source,
+            ref=request.ref,
+            repo_path=request.repo_path,
+            force=request.force,
+        )
+        return InstalledCanvasExtensionResponse.from_info(
+            info, get_installed_canvas_extension_manifest(info.name)
+        )
+    except FileExistsError:
+        raise HTTPException(
+            status_code=409,
+            detail="Canvas extension already installed. Use force=true to overwrite.",
+        )
+    except ExtensionFetchError:
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                "Failed to fetch canvas extension source. "
+                "Check that the source is valid."
+            ),
+        )
+    except (ValidationError, ValueError, OSError):
+        raise HTTPException(
+            status_code=422,
+            detail="Invalid canvas extension. Ensure the manifest is well-formed.",
+        )
+
+
+@canvas_extensions_router.get(
+    "/installed", response_model=InstalledCanvasExtensionsListResponse
+)
+def list_installed_canvas_extensions_endpoint() -> (
+    InstalledCanvasExtensionsListResponse
+):
+    """List all installed canvas extensions (enabled and disabled)."""
+    infos = list_installed_canvas_extensions()
+    return InstalledCanvasExtensionsListResponse(
+        canvas_extensions=[
+            InstalledCanvasExtensionResponse.from_info(
+                i, get_installed_canvas_extension_manifest(i.name)
+            )
+            for i in infos
+        ]
+    )
+
+
+@canvas_extensions_router.get(
+    "/installed/{extension_name}",
+    response_model=InstalledCanvasExtensionResponse,
+    responses={404: {"description": "Canvas extension not installed"}},
+)
+def get_installed_canvas_extension_endpoint(
+    extension_name: CanvasExtensionNamePath,
+) -> InstalledCanvasExtensionResponse:
+    """Get information about a specific installed canvas extension."""
+    info = get_installed_canvas_extension(name=extension_name)
+    if info is None:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Canvas extension '{extension_name}' is not installed",
+        )
+    return InstalledCanvasExtensionResponse.from_info(
+        info, get_installed_canvas_extension_manifest(extension_name)
+    )
+
+
+@canvas_extensions_router.patch(
+    "/installed/{extension_name}",
+    response_model=UpdateCanvasExtensionStateResponse,
+    responses={404: {"description": "Canvas extension not installed"}},
+)
+def set_canvas_extension_enabled_endpoint(
+    extension_name: CanvasExtensionNamePath, request: UpdateCanvasExtensionStateRequest
+) -> UpdateCanvasExtensionStateResponse:
+    """Enable or disable an installed canvas extension."""
+    fn = enable_canvas_extension if request.enabled else disable_canvas_extension
+    if not fn(name=extension_name):
+        raise HTTPException(
+            status_code=404,
+            detail=f"Canvas extension '{extension_name}' is not installed",
+        )
+    return UpdateCanvasExtensionStateResponse(
+        name=extension_name, enabled=request.enabled
+    )
+
+
+@canvas_extensions_router.delete(
+    "/installed/{extension_name}",
+    response_model=UninstallCanvasExtensionResponse,
+    responses={404: {"description": "Canvas extension not installed"}},
+)
+def uninstall_canvas_extension_endpoint(
+    extension_name: CanvasExtensionNamePath,
+) -> UninstallCanvasExtensionResponse:
+    """Uninstall a canvas extension by name."""
+    if not uninstall_canvas_extension(name=extension_name):
+        raise HTTPException(
+            status_code=404,
+            detail=f"Canvas extension '{extension_name}' is not installed",
+        )
+    return UninstallCanvasExtensionResponse(
+        message=f"Canvas extension '{extension_name}' uninstalled"
+    )
+
+
+@canvas_extensions_router.get(
+    "/installed/{extension_name}/bundle",
+    responses={404: {"description": "Canvas extension or bundle not found"}},
+)
+def get_canvas_extension_bundle_endpoint(
+    extension_name: CanvasExtensionNamePath,
+) -> FileResponse:
+    """Serve an installed canvas extension's entrypoint bundle file.
+
+    Entrypoint containment is re-validated against the live install path on
+    every request, not just at install time -- see
+    ``get_canvas_extension_bundle_path``. ``Cache-Control: no-cache`` forces
+    revalidation on each request, so a client never keeps serving a bundle
+    from before the extension's last refresh: the actual bytes are re-read
+    from disk, and Starlette's file-stat-based ``ETag``/``Last-Modified``
+    change the moment the on-disk revision does.
+    """
+    bundle_path = get_canvas_extension_bundle_path(name=extension_name)
+    if bundle_path is None:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Canvas extension '{extension_name}' bundle not found",
+        )
+    return FileResponse(bundle_path, headers={"Cache-Control": "no-cache"})

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/openhands/agent_server/conversation_service.py

@@ -5,11 +5,12 @@ import logging
 import os
 from collections.abc import Awaitable, Callable
 from concurrent.futures import ThreadPoolExecutor
-from contextlib import suppress
+from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 from uuid import UUID, uuid4
+from weakref import WeakValueDictionary
 
 import httpx
 from pydantic import BaseModel
@@ -645,6 +646,14 @@ class ConversationService:
         default_factory=dict, init=False
     )
     _lifecycle_lock: asyncio.Lock = field(default_factory=asyncio.Lock, init=False)
+    _lifecycle_condition: asyncio.Condition = field(
+        default_factory=asyncio.Condition, init=False
+    )
+    _active_lifecycle_operations: int = field(default=0, init=False)
+    _exclusive_lifecycle_pending: bool = field(default=False, init=False)
+    _conversation_locks: WeakValueDictionary[UUID, asyncio.Lock] = field(
+        default_factory=WeakValueDictionary, init=False
+    )
     _conversation_webhook_subscribers: list["ConversationWebhookSubscriber"] = field(
         default_factory=list, init=False
     )
@@ -751,7 +760,7 @@ class ConversationService:
         secret_name: str,
         binding: VersionedCredentialBinding,
     ) -> None:
-        async with self._lifecycle_lock:
+        async with self._conversation_lifecycle(conversation_id):
             event_services = self._event_services
             event_service = (
                 event_services.get(conversation_id)
@@ -770,7 +779,7 @@ class ConversationService:
             )
 
     async def prepare_for_sandbox_pause(self) -> None:
-        async with self._lifecycle_lock:
+        async with self._exclusive_lifecycle():
             event_services = self._event_services
             if event_services is None:
                 raise ValueError("inactive_service")
@@ -1047,10 +1056,56 @@ class ConversationService:
                 context=f"resuming conversation {stored.id}",
             )
 
+    def _get_conversation_lock(self, conversation_id: UUID) -> asyncio.Lock:
+        lock = self._conversation_locks.get(conversation_id)
+        if lock is None:
+            lock = asyncio.Lock()
+            self._conversation_locks[conversation_id] = lock
+        return lock
+
+    @asynccontextmanager
+    async def _conversation_lifecycle(self, conversation_id: UUID):
+        async with self._lifecycle_condition:
+            await self._lifecycle_condition.wait_for(
+                lambda: not self._exclusive_lifecycle_pending
+            )
+            self._active_lifecycle_operations += 1
+        try:
+            async with self._get_conversation_lock(conversation_id):
+                yield
+        finally:
+            async with self._lifecycle_condition:
+                self._active_lifecycle_operations -= 1
+                if self._active_lifecycle_operations == 0:
+                    self._lifecycle_condition.notify_all()
+
+    @asynccontextmanager
+    async def _exclusive_lifecycle(self):
+        async with self._lifecycle_lock:
+            try:
+                async with self._lifecycle_condition:
+                    self._exclusive_lifecycle_pending = True
+                    await self._lifecycle_condition.wait_for(
+                        lambda: self._active_lifecycle_operations == 0
+                    )
+                yield
+            finally:
+                async with self._lifecycle_condition:
+                    self._exclusive_lifecycle_pending = False
+                    self._lifecycle_condition.notify_all()
+
     async def _get_or_load_event_service(
         self, conversation_id: UUID
     ) -> EventService | None:
-        async with self._lifecycle_lock:
+        event_services = self._event_services
+        if event_services is None:
+            raise ValueError("inactive_service")
+        if (
+            conversation_id not in event_services
+            and conversation_id not in self._conversation_records
+        ):
+            return None
+        async with self._conversation_lifecycle(conversation_id):
             return await self._get_or_load_event_service_locked(conversation_id)
 
     async def _get_or_load_event_service_locked(
@@ -1318,7 +1373,7 @@ class ConversationService:
         if existing_record is not None or (
             existing_event_service is not None and existing_event_service.is_open()
         ):
-            async with self._lifecycle_lock:
+            async with self._conversation_lifecycle(conversation_id):
                 existing_event_service = self._event_services.get(conversation_id)
                 if (
                     existing_event_service is not None
@@ -1625,7 +1680,7 @@ class ConversationService:
                 launched_agent_profile=launched_agent_profile,
                 **request_data,
             )
-        async with self._lifecycle_lock:
+        async with self._conversation_lifecycle(conversation_id):
             # New conversation: the agent is written to base_state.json (its
             # single source of truth), not to meta.json. Pass it explicitly.
             # ``new_agent`` is ``request.agent`` (decrypted when the request was
@@ -1683,10 +1738,15 @@ class ConversationService:
         return bool(await self._get_or_load_event_service(conversation_id))
 
     async def delete_conversation(self, conversation_id: UUID) -> bool:
-        async with self._lifecycle_lock:
-            event_services = self._event_services
-            if event_services is None:
-                raise ValueError("inactive_service")
+        event_services = self._event_services
+        if event_services is None:
+            raise ValueError("inactive_service")
+        if (
+            conversation_id not in event_services
+            and conversation_id not in self._conversation_records
+        ):
+            return False
+        async with self._conversation_lifecycle(conversation_id):
             event_service = await self._get_or_load_event_service_locked(
                 conversation_id,
                 require_runtime_bindings=False,
@@ -1911,7 +1971,7 @@ class ConversationService:
         # directory so we don't leave stale state on disk.
         fork_dir = self.conversations_dir / fork_conv_id.hex
         try:
-            async with self._lifecycle_lock:
+            async with self._conversation_lifecycle(fork_conv_id):
                 fork_event_service = await self._start_event_service(
                     fork_stored, is_new_conversation=True, agent=fork_agent
                 )
@@ -2036,7 +2096,7 @@ class ConversationService:
 
         Running or externally-subscribed conversations are skipped.
         """
-        async with self._lifecycle_lock:
+        async with self._exclusive_lifecycle():
             event_services = self._event_services
             if event_services is None:
                 return
@@ -2092,7 +2152,7 @@ class ConversationService:
                 await self._lease_renewal_task
             self._lease_renewal_task = None
 
-        async with self._lifecycle_lock:
+        async with self._exclusive_lifecycle():
             event_services = self._event_services
             if event_services is None:
                 return

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/openhands/agent_server/docker/Dockerfile

@@ -78,6 +78,58 @@ RUN --mount=type=cache,target=/home/${USERNAME}/.cache,uid=${UID},gid=${GID} \
 # Fail fast if the expected binary is missing
 RUN test -x /agent-server/dist/openhands-agent-server
 
+####################################################################################
+# ACP providers (parent-independent)
+#
+# Built from a fixed base rather than ${BASE_IMAGE} so that COPY --from=acp-providers
+# below produces the exact same compressed layer for every base-image-minimal build,
+# regardless of which BASE_IMAGE it lands on. This is what lets the ~600MB provider
+# payload be shared across per-instance evaluation image builds instead of being
+# reinstalled (and re-uploaded) once per instance.
+#
+# Failures here are fatal: there is no per-BASE_IMAGE fallback for a broken build of
+# the shared payload itself (see the compatibility probe in base-image-minimal for
+# the per-target-image fallback).
+####################################################################################
+FROM python:3.13-bookworm AS acp-providers
+# A fresh top-level path, not nested under a directory (e.g. /opt) that base
+# images commonly already populate (SWE-bench images ship /opt/miniconda3):
+# COPY --from=<stage> only produces a byte-identical layer across different
+# BASE_IMAGE parents when the destination itself doesn't already exist in the
+# parent, mirroring /agent-server's own top-level placement in the builder
+# stage above.
+ENV ACP_NODE_DIR=/acp-node
+RUN set -eux; \
+    apt-get -o Acquire::Retries=5 update; \
+    apt-get -o Acquire::Retries=5 install -y --no-install-recommends \
+        ca-certificates curl xz-utils; \
+    rm -rf /var/lib/apt/lists/*; \
+    ACP_WRAPPER_DIR=/opt/acp-wrappers; \
+    mkdir -p "$ACP_NODE_DIR" "$ACP_WRAPPER_DIR"; \
+    ARCH=$(uname -m); \
+    case "$ARCH" in \
+      x86_64|amd64) NARCH=x64; NODE_SHA256=69b09dba5c8dcb05c4e4273a4340db1005abeafe3927efda2bc5b249e80437ec;; \
+      aarch64|arm64) NARCH=arm64; NODE_SHA256=08bfbf538bad0e8cbb0269f0173cca28d705874a67a22f60b57d99dc99e30050;; \
+      *) echo "Unsupported architecture for ACP providers: '$ARCH'" >&2; exit 1;; \
+    esac; \
+    NODE_TARBALL="/tmp/node-v22.14.0-linux-${NARCH}.tar.xz"; \
+    curl -fsSL --retry 5 --retry-delay 2 --retry-connrefused \
+        "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${NARCH}.tar.xz" -o "$NODE_TARBALL"; \
+    echo "$NODE_SHA256  $NODE_TARBALL" | sha256sum -c -; \
+    tar -xJ --strip-components=1 -C "$ACP_NODE_DIR" -f "$NODE_TARBALL"; \
+    rm -f "$NODE_TARBALL"; \
+    "$ACP_NODE_DIR/bin/node" --version; \
+    PATH="$ACP_NODE_DIR/bin:$PATH" "$ACP_NODE_DIR/bin/npm" install -g \
+        @agentclientprotocol/claude-agent-acp@0.63.0 \
+        @agentclientprotocol/codex-acp@1.1.7 \
+        @google/gemini-cli@0.46.0; \
+    for bin in claude-agent-acp codex-acp gemini; do \
+      printf '#!/bin/sh\nPATH="%s/bin:$PATH" exec "%s/bin/%s" "$@"\n' \
+        "$ACP_NODE_DIR" "$ACP_NODE_DIR" "$bin" \
+        > "$ACP_WRAPPER_DIR/$bin"; \
+      chmod +x "$ACP_WRAPPER_DIR/$bin"; \
+    done
+
 ####################################################################################
 # Base image (minimal)
 # It includes only basic packages and the UV runtime.
@@ -150,61 +202,31 @@ RUN set -eux; \
     mkdir -p /workspace/project; \
     chown -R "${USERNAME}:${USERNAME}" /workspace
 
-# Pre-install ACP servers for ACPAgent support (Claude Code, Codex, Gemini CLI)
-# Install Node.js 22 to a dedicated prefix so ACP packages get a modern runtime
+# Install ACP servers for ACPAgent support (Claude Code, Codex, Gemini CLI).
+# The payload itself (Node.js 22 + the ACP npm packages, under $ACP_NODE_DIR) is
+# built once in the acp-providers stage above, independent of BASE_IMAGE, and
+# copied in here so the layer is byte-identical across every base image it lands
+# on. Only the compatibility probe below runs against the real BASE_IMAGE.
+#
+# Node.js 22 lives at a dedicated prefix so ACP packages get a modern runtime
 # WITHOUT overwriting the repo-specific Node.js that test suites depend on.
 # SWE-bench images ship NVM/apt-managed Node 8-14 which cannot run ACP packages.
-#
-# This step is best-effort: SWE-Bench Pro base images come from many distros
-# and some have an old glibc (or use musl) that cannot run the upstream Node
-# 22 glibc tarball. When that happens we leave $ACP_NODE_DIR empty and skip
-# ACP setup so the rest of the build (and non-ACP agents) still work.
-ENV ACP_NODE_DIR=/opt/acp-node
-RUN set -ux; \
-    mkdir -p "$ACP_NODE_DIR"; \
-    ARCH=$(uname -m); \
-    NARCH=""; \
-    NODE_SHA256=""; \
-    case "$ARCH" in \
-      x86_64|amd64) NARCH=x64; NODE_SHA256=69b09dba5c8dcb05c4e4273a4340db1005abeafe3927efda2bc5b249e80437ec;; \
-      aarch64|arm64) NARCH=arm64; NODE_SHA256=08bfbf538bad0e8cbb0269f0173cca28d705874a67a22f60b57d99dc99e30050;; \
-    esac; \
-    NODE_TARBALL=""; \
-    if [ -z "$NARCH" ]; then \
-      echo "Skipping ACP Node install: unsupported architecture '$ARCH'" >&2; \
-    else \
-      NODE_TARBALL="/tmp/node-v22.14.0-linux-${NARCH}.tar.xz"; \
-      if curl -fsSL --retry 5 --retry-delay 2 --retry-connrefused "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${NARCH}.tar.xz" -o "$NODE_TARBALL" \
-         && echo "$NODE_SHA256  $NODE_TARBALL" | sha256sum -c - \
-         && tar -xJ --strip-components=1 -C "$ACP_NODE_DIR" -f "$NODE_TARBALL" \
-         && "$ACP_NODE_DIR/bin/node" --version; then \
-        PATH="$ACP_NODE_DIR/bin:$PATH"; \
-        if "$ACP_NODE_DIR/bin/npm" install -g \
-            @agentclientprotocol/claude-agent-acp@0.63.0 \
-            @agentclientprotocol/codex-acp@1.1.7 \
-            @google/gemini-cli@0.46.0; then \
-          # Create wrappers in /usr/local/bin that prepend ACP's Node 22 to PATH.
-          # This ensures the ACP binary's #!/usr/bin/env node shebang resolves
-          # to Node 22, while the repo's own node (NVM/system) stays untouched
-          # for tests.
-          for bin in claude-agent-acp codex-acp gemini; do \
-            if [ -e "$ACP_NODE_DIR/bin/$bin" ]; then \
-              printf '#!/bin/sh\nPATH="%s/bin:$PATH" exec "%s/bin/%s" "$@"\n' \
-                "$ACP_NODE_DIR" "$ACP_NODE_DIR" "$bin" \
-                > /usr/local/bin/"$bin"; \
-              chmod +x /usr/local/bin/"$bin"; \
-            fi; \
-          done; \
-        else \
-          echo "Warning: ACP npm install failed; ACP agents will not be available on this image" >&2; \
-          rm -rf "$ACP_NODE_DIR"/*; \
-        fi; \
-      else \
-        echo "Warning: ACP Node 22 runtime is not compatible with this base image (likely older glibc or musl libc); ACP agents will not be available" >&2; \
-        rm -rf "$ACP_NODE_DIR"/*; \
-      fi; \
-    fi; \
-    rm -f "$NODE_TARBALL" 2>/dev/null || true
+ENV ACP_NODE_DIR=/acp-node
+COPY --from=acp-providers /acp-node /acp-node
+COPY --from=acp-providers /opt/acp-wrappers/. /usr/local/bin/
+
+# This probe is best-effort: SWE-Bench Pro base images come from many distros
+# and some have an old glibc (or use musl) that cannot run the upstream Node 22
+# glibc build. The payload above was built and sha256-verified against a fixed,
+# glibc-modern stage, so a failure here means "incompatible with this specific
+# BASE_IMAGE", not "the ACP install failed". When that happens we remove the
+# copied payload and wrappers so the rest of the build (and non-ACP agents)
+# still work, rather than leaving binaries in place that cannot execute.
+RUN if ! "$ACP_NODE_DIR/bin/node" --version >/dev/null 2>&1; then \
+      echo "Warning: ACP Node 22 runtime is not compatible with this base image (likely older glibc or musl libc); ACP agents will not be available" >&2; \
+      rm -rf "$ACP_NODE_DIR"/*; \
+      rm -f /usr/local/bin/claude-agent-acp /usr/local/bin/codex-acp /usr/local/bin/gemini; \
+    fi
 
 # Configure Claude Code managed settings for headless operation:
 # Allow all tool permissions (no human in the loop to approve).

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/openhands/agent_server/event_service.py

@@ -1161,7 +1161,14 @@ class EventService:
                     for e in state.events
                 )
                 if not already_observed:
+                    # The persisted HEAD can lag this action when the process
+                    # dies after writing the event file but before autosaving
+                    # leaf_event_id. Parent the recovery result to the action
+                    # explicitly; otherwise normal tree stamping attaches it to
+                    # the stale HEAD, making the action and result siblings and
+                    # leaving an orphan tool result on the active branch.
                     error_event = AgentErrorEvent(
+                        parent_id=first_action.id,
                         tool_name=first_action.tool_name,
                         tool_call_id=first_action.tool_call_id,
                         error=(

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/openhands/agent_server/persistence/models.py

@@ -33,6 +33,38 @@ from openhands.sdk.settings import (
 from openhands.sdk.utils.pydantic_secrets import serialize_secret, validate_secret
 
 
+class _SecretProbeCipher:
+    """Fake cipher that flags secret serialization without needing a real key.
+
+    Passed as ``context={"cipher": probe}`` this forces every secret field's
+    serializer down the "encrypted" branch (see ``resolve_expose_mode``),
+    reusing the real serialization pipeline to detect secret-bearing fields
+    instead of hand-walking the model for ``SecretStr`` instances. That
+    matters for fields like ``AgentContext.secrets``, whose bare-string
+    entries are plain ``str`` at rest and only become secret-shaped inside
+    their own field serializer at dump time -- a value-type walk can't see
+    that, but reusing the pipeline does.
+    """
+
+    def __init__(self) -> None:
+        self.found = False
+
+    def try_decrypt_str(self, raw: str) -> str | None:  # noqa: ARG002
+        return None
+
+    def encrypt(self, value: SecretStr) -> str:
+        if value.get_secret_value():
+            self.found = True
+        return ""
+
+
+def _contains_secret_value(model: BaseModel) -> bool:
+    """Check if serializing `model` would touch any secret-bearing field."""
+    probe = _SecretProbeCipher()
+    model.model_dump(mode="json", context={"cipher": probe})
+    return probe.found
+
+
 class SettingsUpdatePayload(TypedDict, total=False):
     """Typed payload for PersistedSettings.update() method.
 
@@ -180,6 +212,17 @@ class PersistedSettings(BaseModel):
         )
         return bool(secret_value and secret_value.strip())
 
+    @property
+    def has_any_secret(self) -> bool:
+        """Check if these settings contain any secret value anywhere.
+
+        Broader than ``llm_api_key_is_set``: walks the whole ``agent_settings``
+        tree (MCP server env/headers, ``critic_api_key``, provider creds,
+        ``agent_context.secrets``, ...) rather than checking a fixed field
+        list, so it stays correct as new secret-bearing fields are added.
+        """
+        return _contains_secret_value(self.agent_settings)
+
     def update(
         self,
         payload: SettingsUpdatePayload,
@@ -412,6 +455,11 @@ class Secrets(BaseModel):
 
     model_config = ConfigDict(frozen=True)
 
+    @property
+    def has_any_secret(self) -> bool:
+        """Check if these secrets contain any non-empty value."""
+        return _contains_secret_value(self)
+
     def get_env_vars(self) -> dict[str, str]:
         """Get secrets as environment variables dict.
 

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/openhands/agent_server/persistence/store.py

@@ -373,7 +373,7 @@ class FileSettingsStore(SettingsStore):
         else:
             context = {"expose_secrets": "plaintext"}
             # Warn about plaintext secret storage (only if secrets exist)
-            if settings.llm_api_key_is_set:
+            if settings.has_any_secret:
                 logger.warning(
                     "Saving settings with secrets in PLAINTEXT (no cipher configured). "
                     "Configure OH_SECRET_KEY for production deployments."
@@ -542,7 +542,7 @@ class FileSecretsStore(SecretsStore):
         else:
             context = {"expose_secrets": "plaintext"}
             # Warn about plaintext secret storage (only if secrets exist)
-            if secrets.custom_secrets:
+            if secrets.has_any_secret:
                 logger.warning(
                     "Saving secrets in PLAINTEXT (no cipher configured). "
                     "Configure OH_SECRET_KEY for production deployments."

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/openhands_agent_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.43.0
+Version: 1.44.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

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/openhands_agent_server.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ pyproject.toml
 ./openhands/agent_server/auth_router.py
 ./openhands/agent_server/bash_router.py
 ./openhands/agent_server/bash_service.py
+./openhands/agent_server/canvas_extensions_router.py
 ./openhands/agent_server/config.py
 ./openhands/agent_server/conversation_lease.py
 ./openhands/agent_server/conversation_router.py
@@ -85,6 +86,7 @@ openhands/agent_server/api.py
 openhands/agent_server/auth_router.py
 openhands/agent_server/bash_router.py
 openhands/agent_server/bash_service.py
+openhands/agent_server/canvas_extensions_router.py
 openhands/agent_server/config.py
 openhands/agent_server/conversation_lease.py
 openhands/agent_server/conversation_router.py

{openhands_agent_server-1.43.0 → openhands_agent_server-1.44.0}/pyproject.toml

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