openhands-agent-server 1.43.1__tar.gz → 1.44.1__tar.gz

{openhands_agent_server-1.43.1 → openhands_agent_server-1.44.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.43.1
+Version: 1.44.1
 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.1 → openhands_agent_server-1.44.1}/openhands/agent_server/agent_profiles_router.py

@@ -514,13 +514,17 @@ async def materialize_agent_profile(
     mcp_config = settings.agent_settings.mcp_config
 
     # Discover skills off the event loop so the dry-run can report which skills
-    # (catalog minus ``disabled_skills``) resolve. Only OpenHands profiles carry
-    # user/public skills; ACP profiles do not. A discovery failure must not 500
+    # (catalog minus ``disabled_skills``) resolve. Mirrors the launch rule in
+    # ``conversation_service._resolve_agent_from_profile`` so the preview matches
+    # a real launch: an ACP profile is only given a catalog where the CLI cannot
+    # read the user's own configuration (#4019). A discovery failure must not 500
     # the preview: pass ``available_skills=None`` and surface the failure as its
     # own diagnostic below.
     discovery_error: str | None = None
     available_skills = None
-    if profile.agent_kind == "openhands":
+    if profile.agent_kind == "openhands" or (
+        config.acp_skill_sourcing == "openhands_managed"
+    ):
         try:
             available_skills = await asyncio.to_thread(discover_profile_skills)
         except Exception as exc:

{openhands_agent_server-1.43.1 → openhands_agent_server-1.44.1}/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.1 → openhands_agent_server-1.44.1}/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.1 → openhands_agent_server-1.44.1}/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.1/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.1 → openhands_agent_server-1.44.1}/openhands/agent_server/config.py

@@ -27,6 +27,7 @@ CONFIG_PATH_ENV = "OPENHANDS_AGENT_SERVER_CONFIG_PATH"
 DEFAULT_CONFIG_PATH = Path("workspace/openhands_agent_server_config.json")
 # 20 minutes, matching the idle timeout used by OpenHands Cloud.
 DEFAULT_CONVERSATION_IDLE_TTL_SECONDS: Final[float] = 20 * 60.0
+ACPSkillSourcing = Literal["native", "openhands_managed"]
 _logger = logging.getLogger(__name__)
 
 
@@ -349,6 +350,20 @@ class Config(BaseModel):
             "The URL where this agent server instance is available externally"
         ),
     )
+    acp_skill_sourcing: ACPSkillSourcing = Field(
+        default="native",
+        description=(
+            "Who supplies an ACP agent's skills. 'native' (the default, for a "
+            "host-local agent-server): nobody but the ACP CLI — it reads the "
+            "user's own home configuration and the repository, so OpenHands "
+            "injects none of its managed skills. 'openhands_managed' (for "
+            "container runtimes, where that host configuration is absent): also "
+            "inject the user/org/public/marketplace skills the server "
+            "discovers. Project/repository skills are never injected either way "
+            "— the CLI reads AGENTS.md itself (#4019). Set explicitly per "
+            "deployment; the agent-server image sets 'openhands_managed'."
+        ),
+    )
     registered_marketplaces: list[MarketplaceRegistration] = Field(
         default_factory=list,
         description=(