openhands-agent-server 1.29.2__tar.gz → 1.29.3__tar.gz

{openhands_agent_server-1.29.2 → openhands_agent_server-1.29.3}/PKG-INFO

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

@@ -50,6 +50,7 @@ from openhands.agent_server.openai.router import (
     check_openai_api_key,
     openai_router,
 )
+from openhands.agent_server.plugins_router import plugins_router
 from openhands.agent_server.profiles_router import profiles_router
 from openhands.agent_server.server_details_router import (
     get_server_info,
@@ -348,6 +349,7 @@ def _add_api_routes(app: FastAPI) -> None:
     api_router.include_router(vscode_router)
     api_router.include_router(desktop_router)
     api_router.include_router(skills_router)
+    api_router.include_router(plugins_router)
     api_router.include_router(hooks_router)
     api_router.include_router(llm_router)
     api_router.include_router(mcp_router)

{openhands_agent_server-1.29.2 → openhands_agent_server-1.29.3}/openhands/agent_server/conversation_service.py

@@ -1,6 +1,7 @@
 import asyncio
 import importlib
 import logging
+from collections.abc import Awaitable, Callable
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import suppress
 from dataclasses import dataclass, field
@@ -1367,6 +1368,12 @@ class WebhookSubscriber(Subscriber):
     session_api_key: str | None = None
     queue: list[Event] = field(default_factory=list)
     _flush_timer: asyncio.Task | None = field(default=None, init=False)
+    # Per-instance sleep seam so tests override delays without patching the
+    # global asyncio.sleep. default_factory (not default) keeps it an instance
+    # attribute, else the function would be descriptor-bound as a method.
+    _sleep: Callable[[float], Awaitable[None]] = field(
+        default_factory=lambda: asyncio.sleep, init=False
+    )
 
     async def __call__(self, event: Event):
         """Add event to queue and post to webhook when buffer size is reached."""
@@ -1437,7 +1444,7 @@ class WebhookSubscriber(Subscriber):
             except Exception as e:
                 logger.warning(f"Webhook post attempt {attempt + 1} failed: {e}")
                 if attempt < self.spec.num_retries:
-                    await asyncio.sleep(self.spec.retry_delay)
+                    await self._sleep(self.spec.retry_delay)
                 else:
                     logger.error(
                         f"Failed to post events to webhook {events_url} "
@@ -1462,7 +1469,7 @@ class WebhookSubscriber(Subscriber):
     async def _flush_after_delay(self):
         """Wait for flush_delay seconds then flush events if any exist."""
         try:
-            await asyncio.sleep(self.spec.flush_delay)
+            await self._sleep(self.spec.flush_delay)
             # Only flush if there are events in the queue
             if self.queue:
                 await self._post_events()
@@ -1479,6 +1486,10 @@ class ConversationWebhookSubscriber:
 
     spec: WebhookSpec
     session_api_key: str | None = None
+    # Per-instance sleep seam; see WebhookSubscriber._sleep.
+    _sleep: Callable[[float], Awaitable[None]] = field(
+        default_factory=lambda: asyncio.sleep, init=False
+    )
 
     async def post_conversation_info(self, conversation_info: BaseModel):
         """Post conversation info to the webhook immediately (no batching)."""
@@ -1516,7 +1527,7 @@ class ConversationWebhookSubscriber:
                     f"Conversation webhook post attempt {attempt + 1} failed: {e}"
                 )
                 if attempt < self.spec.num_retries:
-                    await asyncio.sleep(self.spec.retry_delay)
+                    await self._sleep(self.spec.retry_delay)
                 else:
                     # Log response content for debugging failures
                     response_content = (

{openhands_agent_server-1.29.2 → openhands_agent_server-1.29.3}/openhands/agent_server/event_service.py

@@ -605,10 +605,9 @@ class EventService:
         from callbacks that may run in different threads. Events are emitted through
         the conversation's normal event flow to ensure they are persisted.
         """
-        if self._main_loop and self._main_loop.is_running() and self._conversation:
-            # Capture conversation reference for closure
-            conversation = self._conversation
-
+        main_loop = self._main_loop
+        conversation = self._conversation
+        if main_loop and main_loop.is_running() and conversation:
             # Wrap _on_event with lock acquisition to ensure thread-safe access
             # to conversation state and event log during concurrent operations
             def locked_on_event():
@@ -617,7 +616,7 @@ class EventService:
 
             # Run the locked callback in an executor to ensure the event is
             # both persisted and sent to WebSocket subscribers
-            self._main_loop.run_in_executor(None, locked_on_event)
+            main_loop.run_in_executor(None, locked_on_event)
 
     def _setup_llm_log_streaming(self, agent: AgentBase) -> None:
         """Configure LLM log callbacks to stream logs via events."""
@@ -633,13 +632,16 @@ class EventService:
                 filename: str, log_data: str, uid=usage_id, model=model_name
             ) -> None:
                 """Callback to emit LLM completion logs as events."""
-                event = LLMCompletionLogEvent(
-                    filename=filename,
-                    log_data=log_data,
-                    model_name=model,
-                    usage_id=uid,
-                )
-                self._emit_event_from_thread(event)
+                try:
+                    event = LLMCompletionLogEvent(
+                        filename=filename,
+                        log_data=log_data,
+                        model_name=model,
+                        usage_id=uid,
+                    )
+                    self._emit_event_from_thread(event)
+                except Exception:
+                    logger.exception("Failed to emit LLM completion log event")
 
             llm.telemetry.set_log_completions_callback(log_callback)
 

openhands_agent_server-1.29.3/openhands/agent_server/plugins_router.py

@@ -0,0 +1,333 @@
+"""Plugins router for OpenHands Agent Server.
+
+HTTP API endpoints for plugin operations. Business logic is delegated to
+``plugins_service.py``; this module mirrors ``skills_router.py`` and stays
+focused on HTTP concerns. It exposes:
+
+* Installed-plugin management — install / list / enable-disable / uninstall /
+  refresh — plus listing locally-available plugins.
+* The plugins-only marketplace catalog.
+"""
+
+from typing import Annotated
+
+from fastapi import APIRouter, HTTPException, Path
+from pydantic import BaseModel, Field
+
+from openhands.agent_server.plugins_service import (
+    MarketplacePluginInfo,
+    service_disable_plugin,
+    service_enable_plugin,
+    service_get_installed_plugin,
+    service_get_plugins_marketplace_catalog,
+    service_install_plugin,
+    service_list_available_plugins,
+    service_list_installed_plugins,
+    service_uninstall_plugin,
+    service_update_plugin,
+)
+from openhands.sdk.extensions.fetch import ExtensionFetchError
+from openhands.sdk.plugin import InstalledPluginInfo, PluginFetchError
+
+
+plugins_router = APIRouter(prefix="/plugins", tags=["Plugins"])
+
+# Kebab-case plugin name — matches the SDK's installed-plugin name rule. Guards
+# the {plugin_name} path parameter against empty strings, path traversal, and
+# invalid characters.
+PLUGIN_NAME_PATTERN = r"^[a-z0-9]+(?:-[a-z0-9]+)*$"
+
+PluginNamePath = Annotated[
+    str,
+    Path(
+        min_length=1,
+        max_length=255,
+        pattern=PLUGIN_NAME_PATTERN,
+        description="Plugin name (lowercase alphanumeric, hyphens)",
+    ),
+]
+
+
+# ---------------------------------------------------------------------------
+# Models
+# ---------------------------------------------------------------------------
+
+
+class PluginsRequest(BaseModel):
+    """Request body for listing locally-available plugins."""
+
+    load_user: bool = Field(
+        default=True, description="Load user plugins (~/.agents/plugins, etc.)"
+    )
+    load_project: bool = Field(
+        default=True, description="Load project plugins from the workspace"
+    )
+    project_dir: str | None = Field(
+        default=None, description="Workspace directory path for project plugins"
+    )
+
+
+class PluginInfo(BaseModel):
+    """Summary of an available plugin."""
+
+    name: str
+    version: str = ""
+    description: str = ""
+
+
+class PluginsResponse(BaseModel):
+    """Response containing the locally-available plugins."""
+
+    plugins: list[PluginInfo]
+
+
+class InstallPluginRequest(BaseModel):
+    """Request body for installing a plugin."""
+
+    source: str = Field(
+        min_length=1,
+        description=(
+            "Plugin source - git URL, GitHub shorthand, or local path. Examples: "
+            "'github:OpenHands/extensions/plugins/city-weather', '/path/to/plugin'"
+        ),
+    )
+    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 InstalledPluginResponse(BaseModel):
+    """Response containing installed plugin information."""
+
+    name: str = Field(description="Plugin name")
+    version: str = Field(default="", description="Plugin version")
+    description: str = Field(default="", description="Plugin description")
+    enabled: bool = Field(default=True, description="Whether the plugin 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 plugin is installed")
+
+    @classmethod
+    def from_plugin_info(cls, info: InstalledPluginInfo) -> "InstalledPluginResponse":
+        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),
+        )
+
+
+class InstalledPluginsListResponse(BaseModel):
+    """Response containing the list of installed plugins."""
+
+    plugins: list[InstalledPluginResponse]
+
+
+class UpdatePluginStateRequest(BaseModel):
+    """Request body for updating plugin state (enable/disable)."""
+
+    enabled: bool
+
+
+class UpdatePluginStateResponse(BaseModel):
+    """Response from a plugin state update."""
+
+    name: str
+    enabled: bool
+
+
+class UninstallPluginResponse(BaseModel):
+    """Response from a plugin uninstall."""
+
+    message: str
+
+
+class UpdatePluginResponse(BaseModel):
+    """Response from a plugin refresh/update."""
+
+    message: str
+    plugin: InstalledPluginResponse
+
+
+class MarketplaceCatalogResponse(BaseModel):
+    """Response containing the plugins marketplace catalog."""
+
+    plugins: list[MarketplacePluginInfo]
+
+
+# ---------------------------------------------------------------------------
+# Endpoints
+# ---------------------------------------------------------------------------
+
+
+@plugins_router.post("", response_model=PluginsResponse)
+def get_plugins(request: PluginsRequest) -> PluginsResponse:
+    """List locally-available plugins (enabled installed + user/project dirs).
+
+    Args:
+        request: Which local sources to load.
+
+    Returns:
+        PluginsResponse with available plugin summaries.
+    """
+    plugins = service_list_available_plugins(
+        load_user=request.load_user,
+        load_project=request.load_project,
+        project_dir=request.project_dir,
+    )
+    return PluginsResponse(
+        plugins=[
+            PluginInfo(name=p.name, version=p.version, description=p.description)
+            for p in plugins
+        ]
+    )
+
+
+@plugins_router.post(
+    "/install",
+    response_model=InstalledPluginResponse,
+    responses={
+        400: {"description": "Failed to fetch plugin source"},
+        409: {"description": "Plugin already installed (use force=true)"},
+        422: {"description": "Invalid plugin (bad name, etc.)"},
+    },
+)
+def install_plugin_endpoint(request: InstallPluginRequest) -> InstalledPluginResponse:
+    """Install a plugin from a git URL, GitHub shorthand, or local path."""
+    try:
+        info = service_install_plugin(
+            source=request.source,
+            ref=request.ref,
+            repo_path=request.repo_path,
+            force=request.force,
+        )
+        return InstalledPluginResponse.from_plugin_info(info)
+    except FileExistsError:
+        raise HTTPException(
+            status_code=409,
+            detail="Plugin already installed. Use force=true to overwrite.",
+        )
+    except (PluginFetchError, ExtensionFetchError):
+        raise HTTPException(
+            status_code=400,
+            detail="Failed to fetch plugin source. Check that the source is valid.",
+        )
+    except ValueError:
+        raise HTTPException(
+            status_code=422,
+            detail="Invalid plugin. Ensure it has a valid kebab-case name.",
+        )
+
+
+@plugins_router.get("/installed", response_model=InstalledPluginsListResponse)
+def list_installed_plugins_endpoint() -> InstalledPluginsListResponse:
+    """List all installed plugins (enabled and disabled)."""
+    plugins = service_list_installed_plugins()
+    return InstalledPluginsListResponse(
+        plugins=[InstalledPluginResponse.from_plugin_info(info) for info in plugins]
+    )
+
+
+@plugins_router.get(
+    "/installed/{plugin_name}",
+    response_model=InstalledPluginResponse,
+    responses={404: {"description": "Plugin not installed"}},
+)
+def get_installed_plugin_endpoint(
+    plugin_name: PluginNamePath,
+) -> InstalledPluginResponse:
+    """Get information about a specific installed plugin."""
+    info = service_get_installed_plugin(name=plugin_name)
+    if info is None:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Plugin '{plugin_name}' is not installed",
+        )
+    return InstalledPluginResponse.from_plugin_info(info)
+
+
+@plugins_router.patch(
+    "/installed/{plugin_name}",
+    response_model=UpdatePluginStateResponse,
+    responses={404: {"description": "Plugin not installed"}},
+)
+def set_plugin_enabled_endpoint(
+    plugin_name: PluginNamePath, request: UpdatePluginStateRequest
+) -> UpdatePluginStateResponse:
+    """Enable or disable an installed plugin."""
+    fn = service_enable_plugin if request.enabled else service_disable_plugin
+    if not fn(name=plugin_name):
+        raise HTTPException(
+            status_code=404,
+            detail=f"Plugin '{plugin_name}' is not installed",
+        )
+    return UpdatePluginStateResponse(name=plugin_name, enabled=request.enabled)
+
+
+@plugins_router.delete(
+    "/installed/{plugin_name}",
+    response_model=UninstallPluginResponse,
+    responses={404: {"description": "Plugin not installed"}},
+)
+def uninstall_plugin_endpoint(plugin_name: PluginNamePath) -> UninstallPluginResponse:
+    """Uninstall a plugin by name."""
+    if not service_uninstall_plugin(name=plugin_name):
+        raise HTTPException(
+            status_code=404,
+            detail=f"Plugin '{plugin_name}' is not installed",
+        )
+    return UninstallPluginResponse(message=f"Plugin '{plugin_name}' uninstalled")
+
+
+@plugins_router.post(
+    "/installed/{plugin_name}/refresh",
+    response_model=UpdatePluginResponse,
+    responses={404: {"description": "Plugin not installed"}},
+)
+def refresh_plugin_endpoint(plugin_name: PluginNamePath) -> UpdatePluginResponse:
+    """Refresh an installed plugin to the latest version from its source."""
+    info = service_update_plugin(name=plugin_name)
+    if info is None:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Plugin '{plugin_name}' is not installed",
+        )
+    return UpdatePluginResponse(
+        message=f"Plugin '{plugin_name}' updated",
+        plugin=InstalledPluginResponse.from_plugin_info(info),
+    )
+
+
+@plugins_router.get("/marketplace", response_model=MarketplaceCatalogResponse)
+def get_marketplace_catalog() -> MarketplaceCatalogResponse:
+    """Get the plugins marketplace catalog with installation status.
+
+    Returns the true plugins (entries whose source lives under ``./plugins/``)
+    from the OpenHands extensions repository marketplace, each with attachable
+    ``PluginSource`` coordinates (``source`` / ``ref`` / ``repo_path``) and an
+    ``installed`` flag. This enables the front-end to render a plugins
+    marketplace with install/installed state and to attach plugins to
+    conversations.
+
+    Returns:
+        MarketplaceCatalogResponse containing the list of available plugins.
+    """
+    return MarketplaceCatalogResponse(plugins=service_get_plugins_marketplace_catalog())

openhands_agent_server-1.29.3/openhands/agent_server/plugins_service.py

@@ -0,0 +1,295 @@
+"""Plugins service for OpenHands Agent Server.
+
+Business logic for two related concerns, both mirroring their skills
+counterparts (``skills_service.py``) so the router stays focused on HTTP:
+
+* Installed-plugin management — thin wrappers over the SDK's installed-plugins
+  subsystem (``openhands.sdk.plugin``) — plus listing the locally-available
+  plugins.
+* The *plugins-only* marketplace catalog. It returns only true plugins from the
+  OpenHands extensions marketplace — entries whose ``source`` lives under
+  ``./plugins/`` — each carrying attachable ``PluginSource`` coordinates
+  (``source`` / ``ref`` / ``repo_path``) plus an ``installed`` flag, so the
+  front-end can drive both *attach* and *install* and show install state.
+"""
+
+import json
+from pathlib import Path
+from time import monotonic
+
+from pydantic import BaseModel, ValidationError
+
+from openhands.sdk.logger import get_logger
+from openhands.sdk.marketplace import Marketplace
+from openhands.sdk.plugin import (
+    InstalledPluginInfo,
+    Plugin,
+    disable_plugin,
+    enable_plugin,
+    get_installed_plugin,
+    install_plugin,
+    list_installed_plugins,
+    uninstall_plugin,
+    update_plugin,
+)
+from openhands.sdk.skills.skill import (
+    DEFAULT_MARKETPLACE_PATH,
+    PUBLIC_SKILLS_REF,
+    PUBLIC_SKILLS_REPO,
+)
+from openhands.sdk.skills.utils import (
+    get_skills_cache_dir,
+    update_skills_repository,
+)
+from openhands.sdk.utils.path import to_posix_path
+
+
+logger = get_logger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Installed-plugin management
+# ---------------------------------------------------------------------------
+
+
+def service_install_plugin(
+    source: str,
+    ref: str | None = None,
+    repo_path: str | None = None,
+    force: bool = False,
+    installed_dir: Path | None = None,
+) -> InstalledPluginInfo:
+    """Install a plugin from a source into the installed-plugins directory."""
+    return install_plugin(
+        source=source,
+        ref=ref,
+        repo_path=repo_path,
+        force=force,
+        installed_dir=installed_dir,
+    )
+
+
+def service_uninstall_plugin(name: str, installed_dir: Path | None = None) -> bool:
+    """Uninstall a plugin by name. Returns False if it wasn't installed."""
+    return uninstall_plugin(name, installed_dir=installed_dir)
+
+
+def service_enable_plugin(name: str, installed_dir: Path | None = None) -> bool:
+    """Enable an installed plugin. Returns False if it isn't installed."""
+    return enable_plugin(name, installed_dir=installed_dir)
+
+
+def service_disable_plugin(name: str, installed_dir: Path | None = None) -> bool:
+    """Disable an installed plugin. Returns False if it isn't installed."""
+    return disable_plugin(name, installed_dir=installed_dir)
+
+
+def service_list_installed_plugins(
+    installed_dir: Path | None = None,
+) -> list[InstalledPluginInfo]:
+    """List all installed plugins (enabled and disabled)."""
+    return list_installed_plugins(installed_dir=installed_dir)
+
+
+def service_get_installed_plugin(
+    name: str, installed_dir: Path | None = None
+) -> InstalledPluginInfo | None:
+    """Get a specific installed plugin, or None if it isn't installed."""
+    return get_installed_plugin(name, installed_dir=installed_dir)
+
+
+def service_update_plugin(
+    name: str, installed_dir: Path | None = None
+) -> InstalledPluginInfo | None:
+    """Update an installed plugin, or None if it isn't installed."""
+    return update_plugin(name, installed_dir=installed_dir)
+
+
+def service_list_available_plugins(
+    load_user: bool = True,
+    load_project: bool = True,
+    project_dir: str | None = None,
+) -> list[Plugin]:
+    """List locally-available plugins (enabled installed + user/project dirs).
+
+    ``load_available_plugins`` is provided by the "Wire installed + local plugin
+    auto-load" ticket (``openhands.sdk.plugin.discovery``). It is imported lazily
+    so this module imports cleanly before that ticket is merged; this endpoint
+    becomes functional once it lands.
+    """
+    from openhands.sdk.plugin import load_available_plugins  # type: ignore
+
+    available = load_available_plugins(
+        work_dir=project_dir,
+        include_user=load_user,
+        include_project=load_project,
+    )
+    return list(available.values())
+
+
+# ---------------------------------------------------------------------------
+# Plugins-only marketplace catalog
+# ---------------------------------------------------------------------------
+
+# The OpenHands extensions marketplace lists both skills and true plugins under
+# its ``plugins`` array, distinguished only by the entry's source path: true
+# plugins live under ``./plugins/`` while skills live under ``./skills/``. We
+# filter on the raw source for this reason (NOT plugin.json presence, which
+# skills carry too).
+_PLUGINS_SOURCE_PREFIX = "./plugins/"
+# Equivalent prefix when an entry uses a structured source object (github/url)
+# carrying an explicit subpath.
+_PLUGINS_SUBPATH_PREFIX = "plugins/"
+
+
+class MarketplacePluginInfo(BaseModel):
+    """A true plugin in the marketplace catalog, with attach coordinates."""
+
+    name: str
+    description: str | None
+    source: str
+    ref: str | None = None
+    repo_path: str | None = None
+    installed: bool
+
+
+# ---------------------------------------------------------------------------
+# Marketplace catalog cache
+# ---------------------------------------------------------------------------
+# Mirrors the skills marketplace cache: each call would otherwise trigger a git
+# fetch (network-bound, multiple seconds). A short TTL avoids that on every tab
+# open. Only the catalog structure is cached; ``installed`` is always derived
+# fresh from the local FS. Unlike the skills cache, an *empty* result (e.g. a
+# transient fetch failure) is NOT cached, so one flaky fetch does not blank the
+# catalog for the whole TTL.
+#
+# Type: (timestamp, list-of-(name, description, source, ref, repo_path)) or None
+_PluginCatalogEntry = tuple[str, str | None, str, str | None, str | None]
+_plugin_catalog_cache: tuple[float, list[_PluginCatalogEntry]] | None = None
+_PLUGIN_CATALOG_TTL_SECONDS = 300  # 5 minutes
+
+
+def service_get_plugins_marketplace_catalog(
+    marketplace_path: str = DEFAULT_MARKETPLACE_PATH,
+    installed_dir: Path | None = None,
+) -> list[MarketplacePluginInfo]:
+    """Get the plugins-only marketplace catalog with installation status.
+
+    Loads the marketplace JSON from the public extensions repository, keeps only
+    true plugins (source under ``./plugins/``), and enriches each with its
+    attachable coordinates and installation status.
+
+    The catalog structure is cached for ``_PLUGIN_CATALOG_TTL_SECONDS`` to avoid
+    a git fetch on every call. The ``installed`` field is always resolved fresh
+    from the local FS.
+
+    Args:
+        marketplace_path: Relative path to the marketplace JSON file.
+        installed_dir: Directory of installed plugins to check status against.
+            Defaults to ``~/.openhands/plugins/installed/``.
+
+    Returns:
+        List of MarketplacePluginInfo with plugin details and install status.
+    """
+    global _plugin_catalog_cache
+
+    now = monotonic()
+    if (
+        _plugin_catalog_cache is not None
+        and now - _plugin_catalog_cache[0] < _PLUGIN_CATALOG_TTL_SECONDS
+    ):
+        entries = _plugin_catalog_cache[1]
+    else:
+        entries = _fetch_plugin_catalog_entries(marketplace_path)
+        # Only cache non-empty results so a transient fetch failure does not
+        # blank the catalog for the whole TTL.
+        if entries:
+            _plugin_catalog_cache = (now, entries)
+
+    # Always-fresh installed check — local FS scan, not a network call.
+    installed_names = {
+        p.name for p in list_installed_plugins(installed_dir=installed_dir)
+    }
+    return [
+        MarketplacePluginInfo(
+            name=name,
+            description=desc,
+            source=src,
+            ref=ref,
+            repo_path=repo_path,
+            installed=name in installed_names,
+        )
+        for name, desc, src, ref, repo_path in entries
+    ]
+
+
+def _is_true_plugin(raw_source: object) -> bool:
+    """Whether a marketplace entry's *raw* source points at a true plugin.
+
+    Must run on the raw source BEFORE ``resolve_plugin_source`` rewrites a
+    relative path into an absolute one (which drops the ``./plugins/`` prefix).
+    String sources are true plugins when under ``./plugins/``; structured
+    source objects when their subpath is under ``plugins/``. Skills (``./skills/``)
+    are excluded.
+    """
+    if isinstance(raw_source, str):
+        return raw_source.startswith(_PLUGINS_SOURCE_PREFIX)
+    subpath = getattr(raw_source, "path", None) or ""
+    return subpath.startswith(_PLUGINS_SUBPATH_PREFIX)
+
+
+def _fetch_plugin_catalog_entries(marketplace_path: str) -> list[_PluginCatalogEntry]:
+    """Fetch the marketplace and keep only true plugins.
+
+    Slow path: git fetch + read the marketplace JSON. Returns
+    ``(name, description, source, ref, repo_path)`` tuples, or an empty list on
+    error.
+    """
+    cache_dir = get_skills_cache_dir()
+    repo_path = update_skills_repository(
+        PUBLIC_SKILLS_REPO, PUBLIC_SKILLS_REF, cache_dir
+    )
+
+    if repo_path is None:
+        logger.warning("Failed to access public extensions repository")
+        return []
+
+    # Primary loader: ``Marketplace.load`` discovers the manifest in
+    # ``.plugin/`` or ``.claude-plugin/`` — the real OpenHands/extensions layout,
+    # where ``.plugin/marketplace.json`` points at the published catalog. We must
+    # NOT gate on ``marketplace_path`` (``marketplaces/default.json``) existing
+    # first: that file is absent in the current extensions repo, so an early
+    # return there would blank the catalog even though the manifest is present.
+    # The explicit ``marketplace_path`` file is only a fallback for layouts that
+    # ship it instead of a ``.plugin/`` manifest.
+    try:
+        marketplace = Marketplace.load(repo_path)
+    except (FileNotFoundError, ValueError) as e:
+        marketplace_file = repo_path / marketplace_path
+        if not marketplace_file.exists():
+            logger.warning(
+                f"Failed to load marketplace via manifest discovery ({e}); "
+                f"fallback file not found: {marketplace_file}"
+            )
+            return []
+        try:
+            with open(marketplace_file, encoding="utf-8") as f:
+                data = json.load(f)
+            marketplace = Marketplace.model_validate(
+                {**data, "path": to_posix_path(repo_path)}
+            )
+        except (json.JSONDecodeError, ValidationError, OSError) as e2:
+            logger.warning(f"Failed to load marketplace: {e}, {e2}")
+            return []
+
+    entries: list[_PluginCatalogEntry] = []
+    for plugin in marketplace.plugins:
+        if not _is_true_plugin(plugin.source):
+            continue
+        # Resolve to attachable coordinates. For a local ./plugins/<name> entry
+        # this yields an absolute path with ref/repo_path None; structured
+        # github/url sources yield their ref + subpath.
+        source, ref, repo_path = marketplace.resolve_plugin_source(plugin)
+        entries.append((plugin.name, plugin.description, source, ref, repo_path))
+
+    return entries

{openhands_agent_server-1.29.2 → openhands_agent_server-1.29.3}/openhands_agent_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.29.2
+Version: 1.29.3
 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.29.2 → openhands_agent_server-1.29.3}/openhands_agent_server.egg-info/SOURCES.txt

@@ -28,6 +28,8 @@ pyproject.toml
 ./openhands/agent_server/middleware.py
 ./openhands/agent_server/models.py
 ./openhands/agent_server/openapi.py
+./openhands/agent_server/plugins_router.py
+./openhands/agent_server/plugins_service.py
 ./openhands/agent_server/profiles_router.py
 ./openhands/agent_server/pub_sub.py
 ./openhands/agent_server/py.typed
@@ -84,6 +86,8 @@ openhands/agent_server/mcp_router.py
 openhands/agent_server/middleware.py
 openhands/agent_server/models.py
 openhands/agent_server/openapi.py
+openhands/agent_server/plugins_router.py
+openhands/agent_server/plugins_service.py
 openhands/agent_server/profiles_router.py
 openhands/agent_server/pub_sub.py
 openhands/agent_server/py.typed

{openhands_agent_server-1.29.2 → openhands_agent_server-1.29.3}/pyproject.toml

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