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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.44.0
+Version: 1.45.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.44.0 → openhands_agent_server-1.45.0}/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.44.0 → openhands_agent_server-1.45.0}/openhands/agent_server/api.py

@@ -39,7 +39,6 @@ from openhands.agent_server.dependencies import (
     check_workspace_session,
 )
 from openhands.agent_server.desktop_router import desktop_router
-from openhands.agent_server.desktop_service import get_desktop_service
 from openhands.agent_server.event_router import event_router
 from openhands.agent_server.file_router import file_router
 from openhands.agent_server.git_router import git_router
@@ -66,6 +65,7 @@ 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
@@ -167,7 +167,6 @@ async def api_lifespan(api: FastAPI) -> AsyncIterator[None]:
             emit_server_started()
 
         vscode_service = get_vscode_service()
-        desktop_service = get_desktop_service()
         tool_preload_service = get_tool_preload_service()
 
         # Define async functions for starting each service
@@ -183,18 +182,6 @@ async def api_lifespan(api: FastAPI) -> AsyncIterator[None]:
             else:
                 logger.info("VSCode service is disabled")
 
-        async def start_desktop_service():
-            if desktop_service is not None:
-                desktop_started = await desktop_service.start()
-                if desktop_started:
-                    logger.info("Desktop service started successfully")
-                else:
-                    logger.warning(
-                        "Desktop service failed to start, continuing without desktop"
-                    )
-            else:
-                logger.info("Desktop service is disabled")
-
         async def start_tool_preload_service():
             if tool_preload_service is not None:
                 tool_preload_started = await tool_preload_service.start()
@@ -208,7 +195,6 @@ async def api_lifespan(api: FastAPI) -> AsyncIterator[None]:
         # Start all services concurrently
         results = await asyncio.gather(
             start_vscode_service(),
-            start_desktop_service(),
             start_tool_preload_service(),
             return_exceptions=True,
         )
@@ -231,17 +217,12 @@ async def api_lifespan(api: FastAPI) -> AsyncIterator[None]:
                 if vscode_service is not None:
                     await vscode_service.stop()
 
-            async def stop_desktop_service():
-                if desktop_service is not None:
-                    await desktop_service.stop()
-
             async def stop_tool_preload_service():
                 if tool_preload_service is not None:
                     await tool_preload_service.stop()
 
             await asyncio.gather(
                 stop_vscode_service(),
-                stop_desktop_service(),
                 stop_tool_preload_service(),
                 return_exceptions=True,
             )
@@ -471,6 +452,8 @@ def _add_api_routes(app: FastAPI) -> None:
 
     app.include_router(sockets_router)
 
+    app.include_router(session_router)
+
 
 def _setup_static_files(app: FastAPI, config: Config) -> None:
     """Set up static file serving and root redirect if configured.

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

@@ -35,6 +35,7 @@ from openhands.sdk.extensions.installation import (
     InstallationMetadata,
 )
 from openhands.sdk.extensions.installation.manager import DEFAULT_CACHE_DIR
+from openhands.sdk.utils.path import get_user_persistence_dir
 
 
 # Matches the InstalledPluginInfo naming convention.
@@ -43,7 +44,7 @@ InstalledCanvasExtensionInfo = InstallationInfo
 
 def get_installed_canvas_extensions_dir() -> Path:
     """Get the default directory for installed canvas extensions."""
-    return Path.home() / ".openhands" / "canvas-extensions" / "installed"
+    return get_user_persistence_dir() / "canvas-extensions" / "installed"
 
 
 class CanvasExtensionInstallationInterface(

{openhands_agent_server-1.44.0 → openhands_agent_server-1.45.0}/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__)
 
 
@@ -318,10 +319,6 @@ class Config(BaseModel):
             "For example, '/{runtime_id}/vscode' when using path-based routing."
         ),
     )
-    enable_vnc: bool = Field(
-        default=False,
-        description="Whether to enable VNC desktop functionality",
-    )
     preload_tools: bool = Field(
         default=True,
         description="Whether to preload tools",
@@ -349,6 +346,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=(

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

@@ -15,7 +15,7 @@ from weakref import WeakValueDictionary
 import httpx
 from pydantic import BaseModel
 
-from openhands.agent_server.config import Config, WebhookSpec
+from openhands.agent_server.config import ACPSkillSourcing, Config, WebhookSpec
 from openhands.agent_server.conversation_lease import (
     DEFAULT_LEASE_TTL_SECONDS,
     ConversationLeaseHeldError,
@@ -130,6 +130,22 @@ def _append_system_message_suffix(agent: AgentBase, addition: str) -> AgentBase:
     return agent.model_copy(update={"agent_context": updated_context})
 
 
+def _with_load_memory(agent: AgentBase) -> AgentBase:
+    """Stamp the global persistent-memory preference onto an agent.
+
+    ``load_memory`` is a user-level setting, not part of any agent, profile or
+    client payload, so it is applied here regardless of how the agent reached
+    the request.
+    """
+    # current_datetime stays suppressed on a synthesized context: a null
+    # agent_context means "no prompt context", and ACPAgent._render_suffix
+    # relies on that to keep a <CURRENT_DATETIME> block out of the prompt.
+    context = agent.agent_context or AgentContext(current_datetime=None)
+    return agent.model_copy(
+        update={"agent_context": context.model_copy(update={"load_memory": True})}
+    )
+
+
 def _has_git_remote(repo_root: Path, remote: str = "origin") -> bool:
     try:
         run_git_command(["git", "remote", "get-url", remote], repo_root)
@@ -290,11 +306,52 @@ def _same_workspace(a: LocalWorkspace, b: LocalWorkspace) -> bool:
     return Path(a.working_dir).resolve() == Path(b.working_dir).resolve()
 
 
+def _apply_acp_skill_sourcing(
+    agent: "AgentBase", sourcing: ACPSkillSourcing
+) -> "AgentBase":
+    """Strip OpenHands-managed skills from an ACP agent under ``native`` sourcing.
+
+    A host-local ACP CLI reads the user's own skills from its home directory, so
+    a second, OpenHands-managed set injected into its prompt is at best noise —
+    and the catalog listing tells it to call ``invoke_skill``, a tool no ACP
+    agent has. Container runtimes set ``openhands_managed`` because that home
+    configuration is absent there. Project skills are excluded either way, by
+    ``ACPAgent`` itself (#4019).
+
+    A caller that sends ``agent`` / ``agent_settings`` puts its own skills on the
+    context, so the strip happens here rather than at profile resolution.
+    """
+    if sourcing != "native" or not isinstance(agent, ACPAgent):
+        return agent
+    context = agent.agent_context
+    if context is None:
+        return agent
+    if not (
+        context.skills
+        or context.load_user_skills
+        or context.load_public_skills
+        or context.registered_marketplaces
+    ):
+        return agent
+    return agent.model_copy(
+        update={
+            "agent_context": context.model_copy(
+                update={
+                    "skills": [],
+                    "load_user_skills": False,
+                    "load_public_skills": False,
+                    "registered_marketplaces": [],
+                }
+            )
+        }
+    )
+
+
 def _resolve_agent_from_profile(
     profile_id: "UUID",
     cipher: "Cipher | None",
     mcp_config: "dict[str, MCPServer]",
-    load_memory: bool = False,
+    acp_skill_sourcing: ACPSkillSourcing = "native",
 ) -> "tuple[AgentBase, LaunchedAgentProfile]":
     """Load and resolve an agent profile by id, returning the built agent + provenance.
 
@@ -305,11 +362,9 @@ def _resolve_agent_from_profile(
             server's cipher.  Passed explicitly so this free function never
             touches the settings-store singleton (which may not have been
             initialised with the correct cipher yet).
-        load_memory: The user's global persistent-memory preference
-            (``agent_settings.agent_context.load_memory``).  An ``AgentProfile``
-            has no ``agent_context`` field, so the preference cannot ride the
-            profile — it is stamped onto the resolved agent below, else a
-            profile-launched conversation would silently ignore the setting.
+        acp_skill_sourcing: This deployment's ACP skill policy
+            (``Config.acp_skill_sourcing``).  Decides whether an ACP profile is
+            resolved with the server's managed skill catalog or with none.
 
     Raises:
         ProfileNotFound: No stored profile has ``profile_id``.
@@ -340,11 +395,15 @@ def _resolve_agent_from_profile(
         ) from exc
 
     # OpenHands profiles get the discovered catalog minus their ``disabled_skills``
-    # deny-list; ACP profiles carry no user/public skills so discovery is skipped.
-    # A genuine discovery failure fails the launch loudly rather than silently
-    # producing a zero-skill agent.
+    # deny-list. An ACP profile gets it only where the CLI cannot reach the user's
+    # own configuration (``openhands_managed``); under ``native`` it sources its
+    # own skills and OpenHands injects none (#4019). A genuine discovery failure
+    # fails the launch loudly rather than silently producing a zero-skill agent.
     available_skills = None
-    if profile.agent_kind == "openhands":
+    wants_skills = profile.agent_kind == "openhands" or (
+        acp_skill_sourcing == "openhands_managed"
+    )
+    if wants_skills:
         try:
             available_skills = discover_profile_skills()
         except Exception as exc:
@@ -386,15 +445,7 @@ def _resolve_agent_from_profile(
         agent = agent.model_copy(
             update={"tools": [*agent.tools, Tool(name=BROWSER_TOOL_NAME)]}
         )
-    # Persistent memory is a global user preference, not a profile field, so it
-    # is carried across the profile-resolution boundary the same way the global
-    # ``mcp_config`` is. Left untouched when off, so the resolved agent stays
-    # byte-identical for everyone who hasn't opted in.
-    if load_memory:
-        context = agent.agent_context or AgentContext()
-        agent = agent.model_copy(
-            update={"agent_context": context.model_copy(update={"load_memory": True})}
-        )
+
     launched = LaunchedAgentProfile(
         agent_profile_id=profile.id,
         revision=profile.revision,
@@ -641,6 +692,7 @@ class ConversationService:
     conversation_worktree_root: Path = field(
         default=Path("/tmp/conversation-worktrees")
     )
+    acp_skill_sourcing: ACPSkillSourcing = "native"
     _event_services: dict[UUID, EventService] | None = field(default=None, init=False)
     _conversation_records: dict[UUID, _ConversationRecord] = field(
         default_factory=dict, init=False
@@ -1511,31 +1563,64 @@ class ConversationService:
                     f"to a different workspace"
                 )
 
-        # Profile resolution must happen before _prepare_request_workspace (which
-        # asserts request.agent is not None) and before model_dump so the resolved
-        # agent is captured in request_data.
+        # Profile resolution and the load_memory stamp must happen before
+        # _prepare_request_workspace (which asserts request.agent is not None)
+        # and before model_dump so the resolved agent is captured in request_data.
         launched_agent_profile: LaunchedAgentProfile | None = None
-        if request.agent_profile_id is not None:
-            # get_settings_store() is safe here: get_instance() initialises the
-            # singleton with the server cipher before any conversation can start.
-            from openhands.agent_server.persistence import (
-                PersistedSettings,
-                get_settings_store,
+
+        from openhands.agent_server.persistence import (
+            PersistedSettings,
+            get_settings_store,
+        )
+
+        # get_settings_store() is safe here: get_instance() initialises the
+        # singleton with the server cipher before any conversation can start.
+        # FileSettingsStore.load re-raises PermissionError/OSError by design;
+        # now that every launch reads it, a bad file mode must not take down
+        # request shapes that need nothing from settings.
+        try:
+            settings = await asyncio.to_thread(
+                lambda: get_settings_store().load() or PersistedSettings()
+            )
+        except (PermissionError, OSError):
+            logger.warning(
+                "Cannot read settings; starting without the stored agent preferences",
+                exc_info=True,
             )
+            settings = PersistedSettings()
 
-            settings = get_settings_store().load() or PersistedSettings()
+        # ``ACPAgentSettings.agent_context`` is nullable, hence the guard.
+        stored_context = settings.agent_settings.agent_context
+        load_memory = bool(stored_context and stored_context.load_memory)
+
+        if request.agent_profile_id is not None:
             mcp_config = settings.agent_settings.mcp_config
-            # ``ACPAgentSettings.agent_context`` is nullable, hence the guard.
-            stored_context = settings.agent_settings.agent_context
             resolved_agent, launched_agent_profile = await asyncio.to_thread(
                 _resolve_agent_from_profile,
                 request.agent_profile_id,
                 self.cipher,
                 mcp_config,
-                load_memory=bool(stored_context and stored_context.load_memory),
+                acp_skill_sourcing=self.acp_skill_sourcing,
             )
             request = request.model_copy(update={"agent": resolved_agent})
 
+        # Applied unconditionally: a serialized agent always carries
+        # ``load_memory`` (model_dump emits defaults), so there is no way to
+        # tell a deliberate ``false`` from an echoed one. Opting a single
+        # conversation out needs a tri-state field; tracked separately.
+        if load_memory and request.agent is not None:
+            request = request.model_copy(
+                update={"agent": _with_load_memory(request.agent)}
+            )
+
+        request = request.model_copy(
+            update={
+                "agent": _apply_acp_skill_sourcing(
+                    request.agent, self.acp_skill_sourcing
+                )
+            }
+        )
+
         additions = request.agent_launch_additions
         suffix = (
             additions.system_message_suffix_append.strip()
@@ -2238,6 +2323,7 @@ class ConversationService:
             lease_ttl_seconds=config.lease_ttl_seconds,
             conversation_idle_ttl_seconds=config.conversation_idle_ttl_seconds,
             conversation_worktree_root=config.conversation_worktree_root,
+            acp_skill_sourcing=config.acp_skill_sourcing,
         )
 
     async def _start_event_service(

openhands_agent_server-1.45.0/openhands/agent_server/desktop_router.py

@@ -0,0 +1,28 @@
+"""Desktop router for agent server API endpoints."""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+
+desktop_router = APIRouter(prefix="/desktop", tags=["Desktop"])
+
+
+class DesktopUrlResponse(BaseModel):
+    """Response model for Desktop URL."""
+
+    url: str | None
+
+
+@desktop_router.get("/url", response_model=DesktopUrlResponse, deprecated=True)
+async def get_desktop_url(
+    base_url: str = "http://localhost:8002",  # noqa: ARG001
+) -> DesktopUrlResponse:
+    """Deprecated since v1.44.1 and scheduled for removal in v1.49.0.
+
+    The VNC/desktop stack has been removed; this always returns 503, the
+    same response every deployment has always gotten since VNC defaults off.
+    """
+    raise HTTPException(
+        status_code=503,
+        detail="Desktop is disabled. VNC/desktop support has been removed.",
+    )