openhands-sdk 1.29.0__tar.gz → 1.29.2__tar.gz

{openhands_sdk-1.29.0 → openhands_sdk-1.29.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-sdk
-Version: 1.29.0
+Version: 1.29.2
 Summary: OpenHands SDK - Core functionality for building AI agents
 Project-URL: Source, https://github.com/OpenHands/software-agent-sdk
 Project-URL: Homepage, https://github.com/OpenHands/software-agent-sdk
@@ -26,3 +26,5 @@ Requires-Dist: tree-sitter>=0.25
 Requires-Dist: tree-sitter-bash>=0.25
 Provides-Extra: boto3
 Requires-Dist: boto3>=1.35.0; extra == "boto3"
+Provides-Extra: vertex
+Requires-Dist: google-cloud-aiplatform>=1.38; extra == "vertex"

{openhands_sdk-1.29.0 → openhands_sdk-1.29.2}/openhands/sdk/agent/base.py

@@ -6,6 +6,7 @@ import os
 import re
 import sys
 from abc import ABC, abstractmethod
+from collections import Counter
 from collections.abc import Generator, Iterable, Sequence
 from concurrent.futures import ThreadPoolExecutor
 from typing import TYPE_CHECKING, Any, Literal
@@ -901,6 +902,42 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
         # Drive the traversal from self
         yield from _walk(self)
 
+    def _close_tool_executor(self, tool: ToolDefinition) -> None:
+        try:
+            executable_tool = tool.as_executable()
+            executable_tool.executor.close()
+        except NotImplementedError:
+            return
+        except Exception as exc:
+            logger.warning("Error closing executor for tool '%s': %s", tool.name, exc)
+
+    def add_runtime_tools(self, tools: Sequence[ToolDefinition]) -> None:
+        if not self._initialized:
+            logger.warning(
+                "add_runtime_tools called before agent initialization; "
+                "tools will not be registered"
+            )
+            return
+        for tool in tools:
+            if not isinstance(tool, ToolDefinition):
+                raise ValueError(
+                    f"Tool {tool} is not an instance of 'ToolDefinition'. "
+                    f"Got type: {type(tool)}"
+                )
+
+        tool_names = [tool.name for tool in tools]
+        if len(tool_names) != len(set(tool_names)):
+            duplicates = {
+                name for name, count in Counter(tool_names).items() if count > 1
+            }
+            raise ValueError(f"Duplicate runtime tool names found: {duplicates}")
+
+        for tool in tools:
+            previous_tool = self._tools.get(tool.name)
+            if previous_tool is not None:
+                self._close_tool_executor(previous_tool)
+            self._tools[tool.name] = tool
+
     @property
     def tools_map(self) -> dict[str, ToolDefinition]:
         """Get the initialized tools map.

{openhands_sdk-1.29.0 → openhands_sdk-1.29.2}/openhands/sdk/context/agent_context.py

@@ -19,6 +19,7 @@ from openhands.sdk.context.prompts import render_template
 from openhands.sdk.llm import Message, TextContent
 from openhands.sdk.llm.utils.model_prompt_spec import get_model_prompt_spec
 from openhands.sdk.logger import get_logger
+from openhands.sdk.marketplace.registration import MarketplaceRegistration
 from openhands.sdk.secret import SecretSource, SecretValue
 from openhands.sdk.skills import (
     Skill,
@@ -111,6 +112,14 @@ class AgentContext(BaseModel):
         ),
         json_schema_extra={"acp_compatible": True},
     )
+    registered_marketplaces: list[MarketplaceRegistration] = Field(
+        default_factory=list,
+        description=(
+            "Marketplace registrations for plugin resolution. Registrations with "
+            "auto_load=True are resolved by LocalConversation at startup."
+        ),
+        json_schema_extra={"acp_compatible": True},
+    )
     load_project_skills: bool = Field(
         default=False,
         description=(
@@ -206,15 +215,18 @@ class AgentContext(BaseModel):
 
     @model_validator(mode="after")
     def _load_auto_skills(self):
-        """Load user and/or public skills if enabled."""
-        if not self.load_user_skills and not self.load_public_skills:
+        """Load user and/or legacy public skills if enabled."""
+        # Any marketplace registration opts the context out of the legacy
+        # public-skills path, even when the registration is resolution-only.
+        include_public = self.load_public_skills and not self.registered_marketplaces
+        if not self.load_user_skills and not include_public:
             return self
 
         auto_skills = load_available_skills(
             work_dir=None,
             include_user=self.load_user_skills,
             include_project=False,
-            include_public=self.load_public_skills,
+            include_public=include_public,
             marketplace_path=self.marketplace_path,
         )
 

{openhands_sdk-1.29.0 → openhands_sdk-1.29.2}/openhands/sdk/conversation/impl/local_conversation.py

@@ -53,6 +53,8 @@ from openhands.sdk.llm.auth.openai import create_subscription_llm_from_config
 from openhands.sdk.llm.llm_profile_store import LLMProfileStore
 from openhands.sdk.llm.llm_registry import LLMRegistry
 from openhands.sdk.logger import get_logger
+from openhands.sdk.marketplace.registry import MarketplaceRegistry
+from openhands.sdk.mcp import create_mcp_tools
 from openhands.sdk.observability.laminar import observe
 from openhands.sdk.plugin import (
     Plugin,
@@ -75,6 +77,8 @@ from openhands.sdk.subagent import (
     register_file_agents,
     register_plugin_agents,
 )
+from openhands.sdk.tool import ToolDefinition
+from openhands.sdk.tool.builtins import InvokeSkillTool
 from openhands.sdk.tool.client_tool import ClientToolSpec
 from openhands.sdk.tool.schema import Action, Observation
 from openhands.sdk.utils.cipher import Cipher
@@ -86,6 +90,8 @@ logger = get_logger(__name__)
 ACP_LAST_PROMPT_USER_MESSAGE_ID = "acp_last_prompt_user_message_id"
 ACP_INFLIGHT_PROMPT_USER_MESSAGE_ID = "acp_inflight_prompt_user_message_id"
 ACP_SUPERSEDE_INFLIGHT_PROMPT = "acp_supersede_inflight_prompt"
+_RUNTIME_MCP_TIMEOUT_SECS = 30
+
 ACP_STOP_HOOK_FEEDBACK_PREFIX = "[Stop hook feedback]"
 
 
@@ -663,35 +669,58 @@ class LocalConversation(BaseConversation):
         # Track whether we have plugins or MCP config to process
         has_mcp_config = bool(merged_mcp)
 
-        # Load plugins if specified
+        plugins_to_load: list[tuple[PluginSource, bool]] = []
+        if merged_context is not None and merged_context.registered_marketplaces:
+            registrations = [
+                registration.model_copy(
+                    update={
+                        "source": self._expand_plugin_source_ref(registration.source),
+                        "ref": self._expand_plugin_source_ref(registration.ref)
+                        if registration.ref
+                        else None,
+                    }
+                )
+                for registration in merged_context.registered_marketplaces
+            ]
+            registry = MarketplaceRegistry(registrations)
+            for registration in registry.get_auto_load_registrations():
+                try:
+                    marketplace, _ = registry.get_marketplace(registration.name)
+                except Exception:
+                    logger.warning(
+                        "Failed to load marketplace '%s'; continuing without it",
+                        registration.name,
+                        exc_info=True,
+                    )
+                    continue
+                for entry in marketplace.plugins:
+                    source, ref, repo_path = marketplace.resolve_plugin_source(entry)
+                    plugins_to_load.append(
+                        (
+                            PluginSource(source=source, ref=ref, repo_path=repo_path),
+                            True,
+                        )
+                    )
+
         if self._plugin_specs:
-            logger.info(f"Loading {len(self._plugin_specs)} plugin(s)...")
-            self._resolved_plugins = []
+            plugins_to_load.extend((spec, False) for spec in self._plugin_specs)
 
-            # Expand ${VAR} placeholders in the source/ref using per-conversation
-            # secrets, so private plugins can be cloned with a token supplied via
-            # the secrets API, e.g. "https://x-token-auth:${MY_TOKEN}@host/repo.git".
-            #
-            # SECURITY: secrets only (check_env=False) -- never fold host
-            # environment variables into a URL sent to a remote git host.
-            # Braced-only (support_unbraced=False) avoids mangling a literal "$"
-            # that may legitimately appear in a token/password. expand_defaults
-            # is False so an unknown ${VAR} is left verbatim rather than silently
-            # defaulted inside a URL.
-            get_secret = self._state.secret_registry.get_secret_value
-
-            def _expand_secret_refs(value: str) -> str:
-                return expand_variable_references(
-                    value,
-                    get_secret=get_secret,
-                    check_env=False,
-                    support_unbraced=False,
-                    expand_defaults=False,
-                )
+        # Load plugins if specified or registered for auto-load
+        if plugins_to_load:
+            logger.info(f"Loading {len(plugins_to_load)} plugin(s)...")
+            self._resolved_plugins = []
 
-            for spec in self._plugin_specs:
-                fetch_source = _expand_secret_refs(spec.source)
-                fetch_ref = _expand_secret_refs(spec.ref) if spec.ref else spec.ref
+            for spec, source_refs_expanded in plugins_to_load:
+                if source_refs_expanded:
+                    fetch_source = spec.source
+                    fetch_ref = spec.ref
+                else:
+                    fetch_source = self._expand_plugin_source_ref(spec.source)
+                    fetch_ref = (
+                        self._expand_plugin_source_ref(spec.ref)
+                        if spec.ref
+                        else spec.ref
+                    )
 
                 # Fetch plugin and get resolved commit SHA
                 path, resolved_ref = fetch_plugin_with_resolution(
@@ -711,7 +740,7 @@ class LocalConversation(BaseConversation):
                 # Load the plugin
                 plugin = Plugin.load(path)
                 logger.debug(
-                    f"Loaded plugin '{plugin.manifest.name}' from {spec.source}"
+                    f"Loaded plugin '{plugin.manifest.name}'"
                     + (f" @ {resolved_ref[:8]}" if resolved_ref else "")
                 )
 
@@ -728,7 +757,7 @@ class LocalConversation(BaseConversation):
                 if plugin.agents:
                     all_plugin_agents.extend(plugin.agents)
 
-            logger.info(f"Loaded {len(self._plugin_specs)} plugin(s) via Conversation")
+            logger.info(f"Loaded {len(plugins_to_load)} plugin(s) via Conversation")
 
         # Resolve project skills from the workspace. AgentContext can't do this
         # itself (the workspace path is unknown at validation time), so it is done
@@ -781,7 +810,7 @@ class LocalConversation(BaseConversation):
 
         # Update agent with merged content only if something changed.
         # Skip update otherwise to avoid unnecessary agent state mutations.
-        if self._plugin_specs or has_mcp_config or project_skills_loaded:
+        if plugins_to_load or has_mcp_config or project_skills_loaded:
             self.agent = self.agent.model_copy(
                 update={
                     "agent_context": merged_context,
@@ -840,6 +869,190 @@ class LocalConversation(BaseConversation):
 
         self._plugins_loaded = True
 
+    def _expand_plugin_source_ref(self, value: str) -> str:
+        return expand_variable_references(
+            value,
+            get_secret=self._state.secret_registry.get_secret_value,
+            check_env=False,
+            support_unbraced=False,
+            expand_defaults=False,
+        )
+
+    def _marketplace_registry_from_context(self) -> MarketplaceRegistry:
+        agent_context = self.agent.agent_context
+        if agent_context is None:
+            raise ValueError(
+                "No agent context available. Configure agent_context with "
+                "registered_marketplaces to use load_plugin()."
+            )
+        registrations = agent_context.registered_marketplaces
+        if not registrations:
+            raise ValueError(
+                "No marketplaces registered. Configure registered_marketplaces "
+                "in AgentContext to use load_plugin()."
+            )
+        return MarketplaceRegistry(
+            [
+                registration.model_copy(
+                    update={
+                        "source": self._expand_plugin_source_ref(registration.source),
+                        "ref": self._expand_plugin_source_ref(registration.ref)
+                        if registration.ref
+                        else None,
+                    }
+                )
+                for registration in registrations
+            ]
+        )
+
+    def _merge_runtime_plugin_hooks(self, plugin_hooks: HookConfig) -> None:
+        existing_config = self._state.hook_config
+        merged_config = (
+            HookConfig.merge([existing_config, plugin_hooks])
+            if existing_config is not None
+            else plugin_hooks
+        )
+        if merged_config is None:
+            return
+
+        hook_persistence_dir = (
+            str(Path(self._state.persistence_dir).parent)
+            if self._state.persistence_dir is not None
+            else None
+        )
+        previous_processor = self._hook_processor
+        if previous_processor is not None:
+            previous_processor.run_session_end()
+
+        self._state.hook_config = merged_config
+        self._pending_hook_config = merged_config
+        self._hook_processor, self._on_event = create_hook_callback(
+            hook_config=merged_config,
+            working_dir=str(self.workspace.working_dir),
+            session_id=str(self._state.id),
+            original_callback=self._base_callback,
+            llm_getter=lambda: self.agent.llm,
+            persistence_dir=hook_persistence_dir,
+            visualizer=self._visualizer,
+            conversation_stats=self._state.stats,
+        )
+        self._hook_processor.set_conversation_state(self._state)
+        self._hook_processor.run_session_start()
+
+    def _runtime_mcp_tools_for_plugin(
+        self, plugin_mcp_config: dict[str, Any] | None
+    ) -> list[ToolDefinition]:
+        if not plugin_mcp_config:
+            return []
+        return list(
+            create_mcp_tools(plugin_mcp_config, _RUNTIME_MCP_TIMEOUT_SECS).tools
+        )
+
+    def _runtime_skill_tools_for_agent(self) -> list[ToolDefinition]:
+        agent_context = self.agent.agent_context
+        has_invocable_skills = bool(
+            agent_context
+            and any(
+                skill.is_agentskills_format and not skill.disable_model_invocation
+                for skill in agent_context.skills
+            )
+        )
+        if has_invocable_skills and InvokeSkillTool.name not in self.agent.tools_map:
+            return list(InvokeSkillTool.create(self._state))
+        return []
+
+    def _close_runtime_tools(self, tools: Sequence[ToolDefinition]) -> None:
+        for tool in tools:
+            try:
+                tool.as_executable().executor.close()
+            except NotImplementedError:
+                continue
+            except Exception as exc:
+                logger.warning(
+                    "Error closing runtime tool executor for tool '%s': %s",
+                    tool.name,
+                    exc,
+                )
+
+    def load_plugin(self, plugin_ref: str) -> None:
+        """Load a plugin from the conversation's registered marketplaces."""
+        self._ensure_plugins_loaded()
+        spec = self._marketplace_registry_from_context().resolve_plugin(plugin_ref)
+
+        fetch_source = self._expand_plugin_source_ref(spec.source)
+        fetch_ref = self._expand_plugin_source_ref(spec.ref) if spec.ref else spec.ref
+        path, resolved_ref = fetch_plugin_with_resolution(
+            source=fetch_source,
+            ref=fetch_ref,
+            repo_path=spec.repo_path,
+        )
+        plugin = Plugin.load(path)
+        logger.info(
+            f"Loaded plugin '{plugin.manifest.name}'"
+            + (f" @ {resolved_ref[:8]}" if resolved_ref else "")
+        )
+
+        get_secret = self._state.secret_registry.get_secret_value
+        runtime_plugin_mcp = (
+            expand_mcp_variables(
+                plugin.mcp_config,
+                {},
+                get_secret=get_secret,
+                expand_defaults=True,
+            )
+            if plugin.mcp_config
+            else None
+        )
+        merged_context = plugin.add_skills_to(self.agent.agent_context)
+        merged_mcp = plugin.add_mcp_config_to(
+            dict(self.agent.mcp_config) if self.agent.mcp_config else {}
+        )
+        if merged_mcp:
+            merged_mcp = expand_mcp_variables(
+                merged_mcp,
+                {},
+                get_secret=get_secret,
+                expand_defaults=True,
+            )
+        runtime_mcp_tools = (
+            self._runtime_mcp_tools_for_plugin(runtime_plugin_mcp)
+            if self._agent_ready
+            else []
+        )
+
+        with self._state:
+            self.agent = self.agent.model_copy(
+                update={
+                    "agent_context": merged_context,
+                    "mcp_config": merged_mcp,
+                }
+            )
+
+            if plugin.agents:
+                register_plugin_agents(
+                    agents=plugin.agents,
+                    work_dir=self.workspace.working_dir,
+                )
+            if plugin.hooks and not plugin.hooks.is_empty():
+                self._merge_runtime_plugin_hooks(plugin.hooks)
+
+            resolved = ResolvedPluginSource.from_plugin_source(spec, resolved_ref)
+            if self._resolved_plugins is None:
+                self._resolved_plugins = []
+            self._resolved_plugins.append(resolved)
+
+            self._state.agent = self.agent
+            if self._agent_ready:
+                runtime_tools = [
+                    *runtime_mcp_tools,
+                    *self._runtime_skill_tools_for_agent(),
+                ]
+                try:
+                    self.agent.add_runtime_tools(runtime_tools)
+                except Exception:
+                    self._close_runtime_tools(runtime_mcp_tools)
+                    raise
+
     def _register_file_based_agents(self) -> None:
         """Discover and register file-based agents into the agent registry.
 

{openhands_sdk-1.29.0 → openhands_sdk-1.29.2}/openhands/sdk/critic/impl/api/critic.py

@@ -12,7 +12,7 @@ from openhands.sdk.critic.impl.api.taxonomy import categorize_features
 
 
 if TYPE_CHECKING:
-    from openhands.sdk.event import LLMConvertibleEvent, SystemPromptEvent
+    from openhands.sdk.event import LLMConvertibleEvent
 
 
 def _format_feature_list(features: list[dict[str, Any]]) -> str:

{openhands_sdk-1.29.0 → openhands_sdk-1.29.2}/openhands/sdk/llm/llm.py

@@ -10,13 +10,13 @@ from collections.abc import Callable, Sequence
 from contextlib import contextmanager
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, get_args, get_origin
 
-import httpx  # noqa: F401
 from pydantic import (
     BaseModel,
     ConfigDict,
     Field,
     PrivateAttr,
     SecretStr,
+    computed_field,
     field_serializer,
     field_validator,
     model_validator,
@@ -120,6 +120,7 @@ from openhands.sdk.llm.utils.openhands_provider import (
 )
 from openhands.sdk.llm.utils.retry_mixin import RetryMixin
 from openhands.sdk.llm.utils.telemetry import Telemetry
+from openhands.sdk.llm.utils.vertex_preflight import assert_vertex_sdk_available
 from openhands.sdk.logger import ENV_LOG_DIR, get_logger
 
 
@@ -279,6 +280,8 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
         default=None,
     )
 
+    # OpenRouter uses HTTP-Referer as the app identity for rankings.
+    # Keep this stable unless the OpenRouter app attribution is migrated.
     openrouter_site_url: str = Field(
         default="https://docs.all-hands.dev/",
     )
@@ -725,6 +728,14 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
             )
         return self._telemetry
 
+    @computed_field(
+        return_type=bool,
+        description=(
+            "Whether this LLM uses subscription-based authentication. "
+            "Serialized so that subscription-specific request handling "
+            "survives transport to a remote agent-server."
+        ),
+    )
     @property
     def is_subscription(self) -> bool:
         """Check if this LLM uses subscription-based authentication.
@@ -738,6 +749,24 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
         """
         return self._is_subscription
 
+    @model_validator(mode="wrap")
+    @classmethod
+    def _restore_is_subscription(cls, data, handler):
+        """Restore the subscription flag when validating serialized data.
+
+        ``is_subscription`` is a computed field backed by the private
+        ``_is_subscription`` attribute, so plain validation would drop it.
+        Without this, an LLM created via ``LLM.subscription_login()`` loses
+        its subscription-specific request handling (streaming exemption,
+        Codex system prompt transform, reasoning-item stripping) after a
+        dump/validate round trip - e.g. when shipped to a remote
+        agent-server.
+        """
+        llm = handler(data)
+        if isinstance(data, dict) and data.get("is_subscription"):
+            llm._is_subscription = True
+        return llm
+
     def restore_metrics(self, metrics: Metrics) -> None:
         # Only used by ConversationStats to seed metrics
         self._metrics = metrics
@@ -1890,6 +1919,9 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
         **kwargs,
     ) -> dict[str, Any]:
         """Build the keyword arguments for a litellm (a)completion call."""
+        provider = self._infer_litellm_provider()
+        assert_vertex_sdk_available(provider)
+
         # When streaming, request usage in the final chunk so that detailed
         # token breakdowns (prompt_tokens_details with cached_tokens, etc.) are
         # not silently discarded by litellm's streaming handler.

{openhands_sdk-1.29.0 → openhands_sdk-1.29.2}/openhands/sdk/llm/utils/model_features.py

@@ -102,6 +102,12 @@ def _normalized_supported_openai_params(model: str | None) -> frozenset[str]:
 REASONING_EFFORT_MODELS: list[str] = [
     # https://www.anthropic.com/news/claude-fable-5
     "claude-fable-5",
+    # LiteLLM recognizes the first-party "anthropic/claude-opus-4-8" id, but not
+    # the Bedrock cross-region inference ids (e.g.
+    # "bedrock/us.anthropic.claude-opus-4-8-v1:0"), which fall through to the
+    # non-reasoning branch and leak temperature/top_p. List explicitly until
+    # LiteLLM ships Bedrock metadata for this model.
+    "claude-opus-4-8",
 ]
 
 

openhands_sdk-1.29.2/openhands/sdk/llm/utils/vertex_preflight.py

@@ -0,0 +1,36 @@
+"""Preflight check for Vertex AI partner-model dependencies.
+
+`google-cloud-aiplatform` is an optional extra (`openhands-sdk[vertex]`). When a
+caller targets a `vertex_ai/*` model without the extra installed, LiteLLM fails
+with a low-level `ModuleNotFoundError` from inside its provider handler. We
+catch that earlier and surface a friendly install hint instead.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+
+from openhands.sdk.llm.exceptions import LLMBadRequestError
+
+
+_INSTALL_HINT = (
+    "Vertex AI partner models require the Vertex SDK. "
+    'Install with: pip install "openhands-sdk[vertex]"'
+)
+
+
+def _vertex_sdk_available() -> bool:
+    return importlib.util.find_spec("vertexai") is not None
+
+
+def assert_vertex_sdk_available(provider: str | None) -> None:
+    """Raise a friendly error if the caller is targeting Vertex without the SDK.
+
+    No-op for any non-`vertex_ai` provider, so it's safe to call unconditionally
+    from the transport path.
+    """
+    if provider != "vertex_ai":
+        return
+    if _vertex_sdk_available():
+        return
+    raise LLMBadRequestError(_INSTALL_HINT)

{openhands_sdk-1.29.0 → openhands_sdk-1.29.2}/openhands/sdk/marketplace/__init__.py

@@ -23,27 +23,40 @@ Example marketplace.json:
 ```
 """
 
-from openhands.sdk.marketplace.types import (
-    MARKETPLACE_MANIFEST_DIRS,
-    MARKETPLACE_MANIFEST_FILE,
-    Marketplace,
-    MarketplaceEntry,
-    MarketplaceMetadata,
-    MarketplaceOwner,
-    MarketplacePluginEntry,
-    MarketplacePluginSource,
+from importlib import import_module
+from typing import Any
+
+from openhands.sdk.marketplace.registration import (
+    MarketplaceRegistration as MarketplaceRegistration,
 )
 
 
-__all__ = [
-    # Constants
+_TYPE_EXPORTS = {
     "MARKETPLACE_MANIFEST_DIRS",
     "MARKETPLACE_MANIFEST_FILE",
-    # Marketplace classes
     "Marketplace",
     "MarketplaceEntry",
+    "MarketplaceMetadata",
     "MarketplaceOwner",
     "MarketplacePluginEntry",
     "MarketplacePluginSource",
-    "MarketplaceMetadata",
-]
+}
+_REGISTRY_EXPORTS = {
+    "AmbiguousPluginError",
+    "FetchedMarketplace",
+    "MarketplaceNotFoundError",
+    "MarketplaceRegistry",
+    "PluginNotFoundError",
+    "PluginResolutionError",
+}
+
+
+__all__ = sorted(_TYPE_EXPORTS | _REGISTRY_EXPORTS | {"MarketplaceRegistration"})
+
+
+def __getattr__(name: str) -> Any:
+    if name in _TYPE_EXPORTS:
+        return getattr(import_module("openhands.sdk.marketplace.types"), name)
+    if name in _REGISTRY_EXPORTS:
+        return getattr(import_module("openhands.sdk.marketplace.registry"), name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

openhands_sdk-1.29.2/openhands/sdk/marketplace/registration.py

@@ -0,0 +1,47 @@
+"""Marketplace registration model."""
+
+from __future__ import annotations
+
+from pathlib import PurePosixPath, PureWindowsPath
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class MarketplaceRegistration(BaseModel):
+    """Registration for a marketplace source used for plugin resolution."""
+
+    name: str = Field(description="Identifier for this marketplace registration")
+    source: str = Field(
+        description="Marketplace source: 'github:owner/repo', git URL, or local path"
+    )
+    ref: str | None = Field(
+        default=None,
+        description="Optional branch, tag, or commit for git sources",
+    )
+    repo_path: str | None = Field(
+        default=None,
+        description=(
+            "Subdirectory path within the git repository containing the marketplace. "
+            "Only relevant for git sources."
+        ),
+    )
+    auto_load: bool = Field(
+        default=False,
+        description="Whether to load all marketplace plugins at conversation start.",
+    )
+
+    @field_validator("repo_path")
+    @classmethod
+    def _validate_repo_path(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        if not value:
+            raise ValueError("repo_path must not be empty")
+        if "\\" in value:
+            raise ValueError("repo_path must use '/' separators")
+        path = PurePosixPath(value)
+        if PureWindowsPath(value).drive or path.is_absolute():
+            raise ValueError("repo_path must be relative, not absolute")
+        if ".." in path.parts:
+            raise ValueError("repo_path cannot contain '..' path traversal")
+        return value