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

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

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

@@ -12,11 +12,9 @@ MCP references and returns :class:`~openhands.sdk.profiles.AgentProfileDiagnosti
 """
 
 import copy
-import shlex
 from collections.abc import Iterator
 from contextlib import contextmanager
 from typing import Annotated, Any
-from uuid import UUID, uuid4
 
 from fastapi import APIRouter, HTTPException, Path, Request, status
 from pydantic import BaseModel, Field, ValidationError
@@ -34,20 +32,26 @@ from openhands.agent_server.persistence import (
     get_llm_profile_store,
     get_settings_store,
 )
+from openhands.agent_server.profiles_router import MAX_PROFILES
+from openhands.sdk.llm import LLM
+from openhands.sdk.llm.llm_profile_store import (
+    ProfileLimitExceeded as LLMProfileLimitExceeded,
+)
 from openhands.sdk.logger import get_logger
 from openhands.sdk.profiles import (
+    SEED_PROFILE_NAME,
     ACPAgentProfile,
     AgentProfileDiagnostics,
     AgentProfileStore,
     OpenHandsAgentProfile,
     ProfileLimitExceeded,
-    ProfileVerificationSettings,
+    build_seed_profile,
     resolve_agent_profile_dry_run,
+    safe_validation_error_detail,
+    save_profile_preserving_identity,
     validate_agent_profile,
 )
 from openhands.sdk.profiles.agent_profile_store import PROFILE_NAME_PATTERN
-from openhands.sdk.settings import AgentSettingsConfig
-from openhands.sdk.settings.model import VerificationSettings
 from openhands.sdk.utils.cipher import Cipher
 from openhands.sdk.utils.pydantic_secrets import decrypt_str_with_cipher_or_keep
 
@@ -58,9 +62,6 @@ agent_profiles_router = APIRouter(prefix="/agent-profiles", tags=["Agent Profile
 
 MAX_AGENT_PROFILES = 50
 
-# Name the lazily-seeded migration profile (and its LLM ref fallback).
-SEED_PROFILE_NAME = "default"
-
 ProfileName = Annotated[
     str,
     Path(min_length=1, max_length=64, pattern=PROFILE_NAME_PATTERN),
@@ -179,65 +180,57 @@ def _decrypt_profile_mcp_tools(
     return profile.model_copy(update={"skills": new_skills})
 
 
-def _profile_verification(v: VerificationSettings) -> ProfileVerificationSettings:
-    """Project the secret-free subset of ``VerificationSettings``.
-
-    Drops ``critic_api_key`` — the profile is secret-free; the critic reuses
-    the resolved LLM profile's key.
-    """
-    return ProfileVerificationSettings(
-        critic_enabled=v.critic_enabled,
-        critic_mode=v.critic_mode,
-        enable_iterative_refinement=v.enable_iterative_refinement,
-        critic_threshold=v.critic_threshold,
-        max_refinement_iterations=v.max_refinement_iterations,
-        critic_server_url=v.critic_server_url,
-        critic_model_name=v.critic_model_name,
-    )
+def _seed_default_llm_profile(llm: LLM, cipher: Cipher | None) -> str:
+    """Mirror the live LLM config into a ``SEED_PROFILE_NAME`` LLM profile.
 
+    ``build_seed_profile`` falls back to the literal name ``SEED_PROFILE_NAME``
+    when no LLM profile is active, on the assumption that a profile by that
+    name exists — but nothing ever created one, so the seeded agent profile's
+    ``llm_profile_ref`` dangled from birth (#3933). Mirrors the cloud
+    ``SaasSettingsStore``'s legacy-LLM backfill: materialize the current
+    ``agent_settings.llm`` under that name so the reference resolves, unless a
+    profile is already stored there (never clobber it).
 
-def _build_seed_profile(
-    agent_settings: AgentSettingsConfig, active_llm_profile: str | None
-) -> OpenHandsAgentProfile | ACPAgentProfile:
-    """Build one ``AgentProfile`` faithfully from the current ``agent_settings``.
-
-    Carries every cleanly-overlapping launch field so the migrated profile is a
-    stable representation of the user's current configuration (the active
-    pointer is otherwise just a lightweight id). ``mcp_server_refs=None`` exposes
-    all of the user's MCP servers. An OpenHands profile references the active LLM
-    profile (falling back to ``"default"`` when none is set — a soft ref the
-    resolver checks at materialize time).
+    Existence is checked via ``load()``, not ``list()``: the store resolves a
+    name straight to a filesystem path, so on a case-insensitive filesystem
+    (macOS/Windows) a differently-cased ``Default`` profile already occupies
+    the ``default`` path even though it wouldn't case-sensitively match a
+    ``list()`` membership check — that mismatch would otherwise let ``save()``
+    silently clobber it.
     """
-    if agent_settings.agent_kind == "acp":
-        return ACPAgentProfile(
-            name=SEED_PROFILE_NAME,
-            acp_server=agent_settings.acp_server,
-            acp_model=agent_settings.acp_model,
-            acp_session_mode=agent_settings.acp_session_mode,
-            acp_prompt_timeout=agent_settings.acp_prompt_timeout,
-            # settings store the command as a token list; the profile holds a
-            # single (re-parseable) string. Empty list => use the server default.
-            acp_command=(
-                shlex.join(agent_settings.acp_command)
-                if agent_settings.acp_command
-                else None
-            ),
-            acp_args=list(agent_settings.acp_args) or None,
-            mcp_server_refs=None,
-        )
-    context = agent_settings.agent_context
-    return OpenHandsAgentProfile(
-        name=SEED_PROFILE_NAME,
-        llm_profile_ref=active_llm_profile or SEED_PROFILE_NAME,
-        agent=agent_settings.agent,
-        skills=list(context.skills),
-        system_message_suffix=context.system_message_suffix,
-        condenser=agent_settings.condenser,
-        verification=_profile_verification(agent_settings.verification),
-        enable_sub_agents=agent_settings.enable_sub_agents,
-        tool_concurrency_limit=agent_settings.tool_concurrency_limit,
-        mcp_server_refs=None,
-    )
+    llm_store = get_llm_profile_store()
+    with _store_errors():
+        try:
+            llm_store.load(SEED_PROFILE_NAME, cipher=cipher)
+            return SEED_PROFILE_NAME
+        except FileNotFoundError:
+            pass
+        except ValueError:
+            # Something already occupies the name (e.g. corrupted/unparsable
+            # file) — never overwrite it; a broken ref surfaces at
+            # materialize/launch time instead.
+            logger.warning(
+                f"Default LLM profile '{SEED_PROFILE_NAME}' exists but "
+                "failed to load; leaving it as-is"
+            )
+            return SEED_PROFILE_NAME
+        try:
+            llm_store.save(
+                SEED_PROFILE_NAME,
+                llm,
+                include_secrets=True,
+                cipher=cipher,
+                max_profiles=MAX_PROFILES,
+            )
+            logger.info(f"Seeded default LLM profile '{SEED_PROFILE_NAME}'")
+        except LLMProfileLimitExceeded:
+            # Can't mirror the live LLM as a profile; the agent profile's
+            # llm_profile_ref will still dangle, but no worse than before.
+            logger.warning(
+                "Could not seed default LLM profile "
+                f"'{SEED_PROFILE_NAME}': profile limit reached"
+            )
+    return SEED_PROFILE_NAME
 
 
 def _seed_default_profile(
@@ -251,13 +244,25 @@ def _seed_default_profile(
     The lock spans empty-check + save + pointer write so concurrent first
     requests seed exactly once and the pointer matches the persisted id.
     """
-    with _store_errors(), store._acquire_lock():
+    with _store_errors(), store.lock():
         # Double-checked under the lock: a concurrent first request may have
         # already seeded (the outer emptiness check in the list endpoint is
         # unlocked).
         if store.list():
             return
-        profile = _build_seed_profile(settings.agent_settings, settings.active_profile)
+        active_llm_profile = settings.active_profile
+        # Falsy check (not `is None`): mirrors build_seed_profile's own
+        # `active_llm_profile or SEED_PROFILE_NAME` fallback. A stray empty
+        # string (e.g. a hand-edited/legacy settings.json, or a direct
+        # PersistedSettings(active_profile="") construction — the HTTP PATCH
+        # payload's pattern validator blocks "" but the stored field has no
+        # such constraint) is falsy there too, so the backfill must trigger
+        # on the same condition or the exact #3933 dangling ref reappears.
+        if not active_llm_profile and settings.agent_settings.agent_kind != "acp":
+            active_llm_profile = _seed_default_llm_profile(
+                settings.agent_settings.llm, cipher
+            )
+        profile = build_seed_profile(settings.agent_settings, active_llm_profile)
         # Settings persist skills[].mcp_tools encrypted (and never decrypt on
         # load), so decrypt before re-encrypting at save to avoid double-encrypt.
         profile = _decrypt_profile_mcp_tools(profile, cipher)
@@ -284,29 +289,6 @@ def _summary_id_for_name(store: AgentProfileStore, name: str) -> str | None:
     return None
 
 
-def _existing_identity(
-    store: AgentProfileStore, name: str
-) -> tuple[UUID | None, int | None]:
-    """Return the stable ``(id, revision)`` of the profile under ``name``.
-
-    Used to keep ``id`` stable across an overwrite — the active pointer is keyed
-    on it — and to bump ``revision`` monotonically. Ignores a malformed stored
-    id (treated as no prior identity).
-    """
-    with _store_errors():
-        for summary in store.list_summaries():
-            if summary.get("name") != name:
-                continue
-            sid = summary.get("id")
-            rev = summary.get("revision")
-            try:
-                parsed = UUID(str(sid)) if sid is not None else None
-            except (ValueError, TypeError):
-                parsed = None
-            return parsed, rev if isinstance(rev, int) else None
-    return None, None
-
-
 @agent_profiles_router.get("", response_model=AgentProfileListResponse)
 async def list_agent_profiles(request: Request) -> AgentProfileListResponse:
     """List all stored agent profiles and the active pointer.
@@ -393,7 +375,7 @@ async def save_agent_profile(
         # MCPConfig error embeds the input (which may carry secrets) in ``msg``.
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=[{"loc": err["loc"], "type": err["type"]} for err in e.errors()],
+            detail=safe_validation_error_detail(e),
         )
     except Exception:
         # Any other validation failure (e.g. SkillValidationError from a
@@ -412,19 +394,14 @@ async def save_agent_profile(
     store = get_agent_profile_store()
     # The id is server-managed (the active pointer is keyed on it): overwrite
     # keeps the namesake's id and bumps revision; create mints a fresh id,
-    # ignoring any client-supplied one. The lock spans read + mint + save so two
-    # concurrent creates of the same new name can't both mint an id and clobber
-    # each other (the seed path guards the same window).
+    # ignoring any client-supplied one. ``save_profile_preserving_identity``
+    # holds the store lock across read + mint + save so two concurrent creates
+    # of the same new name can't both mint an id and clobber each other.
     try:
-        with _store_errors(), store._acquire_lock():
-            existing_id, existing_rev = _existing_identity(store, name)
-            if existing_id is not None:
-                profile = profile.model_copy(
-                    update={"id": existing_id, "revision": (existing_rev or 0) + 1}
-                )
-            else:
-                profile = profile.model_copy(update={"id": uuid4()})
-            store.save(profile, cipher=cipher, max_profiles=MAX_AGENT_PROFILES)
+        with _store_errors():
+            save_profile_preserving_identity(
+                store, profile, cipher=cipher, max_profiles=MAX_AGENT_PROFILES
+            )
     except ProfileLimitExceeded:
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT,

{openhands_agent_server-1.29.2 → openhands_agent_server-1.30.0}/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,
@@ -59,6 +60,7 @@ from openhands.agent_server.server_details_router import (
 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
+from openhands.agent_server.sub_agents_router import sub_agents_router
 from openhands.agent_server.tool_preload_service import get_tool_preload_service
 from openhands.agent_server.tool_router import tool_router
 from openhands.agent_server.vscode_router import vscode_router
@@ -348,6 +350,8 @@ 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(sub_agents_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.30.0}/openhands/agent_server/config.py

@@ -6,6 +6,7 @@ from typing import Any, ClassVar
 
 from pydantic import BaseModel, ConfigDict, Field, SecretStr
 
+from openhands.agent_server.conversation_lease import DEFAULT_LEASE_TTL_SECONDS
 from openhands.agent_server.env_parser import (
     MISSING,
     _get_default_parsers,
@@ -13,6 +14,7 @@ from openhands.agent_server.env_parser import (
     get_env_parser,
     merge,
 )
+from openhands.sdk.marketplace.registration import MarketplaceRegistration
 from openhands.sdk.utils.cipher import Cipher
 
 
@@ -236,6 +238,13 @@ class Config(BaseModel):
             "The URL where this agent server instance is available externally"
         ),
     )
+    registered_marketplaces: list[MarketplaceRegistration] = Field(
+        default_factory=list,
+        description=(
+            "Default marketplace registrations for plugin and skill loading. "
+            "Can be configured with OH_REGISTERED_MARKETPLACES as a JSON list."
+        ),
+    )
     deferred_init: bool = Field(
         default=False,
         description=(
@@ -247,6 +256,20 @@ class Config(BaseModel):
             "configuration is delivered later."
         ),
     )
+    lease_ttl_seconds: float = Field(
+        default=DEFAULT_LEASE_TTL_SECONDS,
+        ge=0.0,
+        description=(
+            "How long (in seconds) a conversation ownership lease remains valid "
+            "without renewal. The lease prevents two server instances from "
+            "concurrently owning the same conversation when storage is shared "
+            "across instances. Set to 0 to disable leasing entirely, which is "
+            "appropriate for single-instance deployments where concurrent "
+            "ownership is impossible. Values between 0 and "
+            "LEASE_RENEW_INTERVAL_SECONDS (15 s) are valid but cause the lease "
+            "to expire before the first renewal, effectively making it one-shot."
+        ),
+    )
     model_config: ClassVar[ConfigDict] = {"frozen": True}
 
     @property

{openhands_agent_server-1.29.2 → openhands_agent_server-1.30.0}/openhands/agent_server/conversation_router.py

@@ -42,6 +42,12 @@ from openhands.agent_server.models import (
 )
 from openhands.sdk import LLM, Agent, TextContent
 from openhands.sdk.conversation.state import ConversationExecutionStatus
+from openhands.sdk.marketplace.registry import (
+    MarketplaceNotFoundError,
+    PluginNotFoundError,
+    PluginResolutionError,
+)
+from openhands.sdk.plugin import PluginFetchError
 from openhands.sdk.profiles.resolver import DanglingMcpServerRef, ProfileNotFound
 from openhands.sdk.tool.client_tool import ClientToolRegistrationError
 from openhands.sdk.workspace import LocalWorkspace
@@ -497,6 +503,42 @@ async def switch_conversation_llm(
     return Success()
 
 
+@conversation_router.post(
+    "/{conversation_id}/load_plugin",
+    responses={
+        400: {"description": "Invalid plugin reference or inactive conversation"},
+        404: {"description": "Conversation or plugin not found"},
+    },
+)
+async def load_conversation_plugin(
+    conversation_id: UUID,
+    plugin_ref: str = Body(..., embed=True),
+    conversation_service: ConversationService = Depends(get_conversation_service),
+) -> Success:
+    """Load a plugin from the conversation's registered marketplaces."""
+    event_service = await conversation_service.get_event_service(conversation_id)
+    if event_service is None:
+        raise HTTPException(status.HTTP_404_NOT_FOUND)
+    try:
+        await event_service.load_plugin(plugin_ref)
+    except (PluginNotFoundError, MarketplaceNotFoundError) as e:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=str(e),
+        )
+    except (
+        PluginResolutionError,
+        PluginFetchError,
+        FileNotFoundError,
+        ValueError,
+    ) as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e),
+        )
+    return Success()
+
+
 @conversation_router.post(
     "/{conversation_id}/switch_acp_model",
     responses={

{openhands_agent_server-1.29.2 → openhands_agent_server-1.30.0}/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
@@ -12,7 +13,10 @@ import httpx
 from pydantic import BaseModel
 
 from openhands.agent_server.config import Config, WebhookSpec
-from openhands.agent_server.conversation_lease import ConversationLeaseHeldError
+from openhands.agent_server.conversation_lease import (
+    DEFAULT_LEASE_TTL_SECONDS,
+    ConversationLeaseHeldError,
+)
 from openhands.agent_server.event_service import (
     LEASE_RENEW_INTERVAL_SECONDS,
     EventService,
@@ -441,6 +445,7 @@ class ConversationService:
     cipher: Cipher | None = None
     owner_instance_id: str = field(default_factory=lambda: uuid4().hex)
     max_concurrent_runs: int = 10
+    lease_ttl_seconds: float = DEFAULT_LEASE_TTL_SECONDS
     _event_services: dict[UUID, EventService] | None = field(default=None, init=False)
     _conversation_webhook_subscribers: list["ConversationWebhookSubscriber"] = field(
         default_factory=list, init=False
@@ -1212,6 +1217,7 @@ class ConversationService:
             ),
             cipher=config.cipher,
             max_concurrent_runs=config.max_concurrent_runs,
+            lease_ttl_seconds=config.lease_ttl_seconds,
         )
 
     async def _start_event_service(self, stored: StoredConversation) -> EventService:
@@ -1224,6 +1230,7 @@ class ConversationService:
             conversations_dir=self.conversations_dir,
             cipher=self.cipher,
             owner_instance_id=self.owner_instance_id,
+            lease_ttl_seconds=self.lease_ttl_seconds,
         )
         # Lease renewal is handled by the centralized
         # _renew_all_leases_loop task on ConversationService.
@@ -1367,6 +1374,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 +1450,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 +1475,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 +1492,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 +1533,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.30.0}/openhands/agent_server/event_service.py

@@ -9,6 +9,7 @@ from uuid import UUID, uuid4
 from pydantic import ValidationError
 
 from openhands.agent_server.conversation_lease import (
+    DEFAULT_LEASE_TTL_SECONDS,
     ConversationLease,
     ConversationOwnershipLostError,
 )
@@ -81,6 +82,7 @@ class EventService:
     conversations_dir: Path
     cipher: Cipher | None = None
     owner_instance_id: str = field(default_factory=lambda: uuid4().hex)
+    lease_ttl_seconds: float = DEFAULT_LEASE_TTL_SECONDS
     _conversation: LocalConversation | None = field(default=None, init=False)
     _pub_sub: PubSub[Event] = field(
         default_factory=lambda: PubSub[Event](max_subscribers=50), init=False
@@ -605,10 +607,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 +618,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 +634,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)
 
@@ -731,12 +735,16 @@ class EventService:
 
         # self.stored contains an Agent configuration we can instantiate
         self.conversation_dir.mkdir(parents=True, exist_ok=True)
-        self._lease = ConversationLease(
-            conversation_dir=self.conversation_dir,
-            owner_instance_id=self.owner_instance_id,
-        )
-        lease_claim = self._lease.claim()
-        self._lease_generation = lease_claim.generation
+        # lease_ttl_seconds=0 disables leasing for single-instance deployments
+        # where shared-storage stale leases would otherwise block pod restarts.
+        if self.lease_ttl_seconds > 0:
+            self._lease = ConversationLease(
+                conversation_dir=self.conversation_dir,
+                owner_instance_id=self.owner_instance_id,
+                ttl_seconds=self.lease_ttl_seconds,
+            )
+            lease_claim = self._lease.claim()
+            self._lease_generation = lease_claim.generation
         workspace = self.stored.workspace
         assert isinstance(workspace, LocalWorkspace)
         working_dir = Path(workspace.working_dir)
@@ -823,6 +831,7 @@ class EventService:
             user_id=self.stored.user_id,
             observability_metadata=self.stored.observability_metadata,
             observability_tags=self.stored.observability_tags,
+            observability_span_name=self.stored.observability_span_name,
         )
 
         conversation.set_confirmation_policy(self.stored.confirmation_policy)
@@ -1360,6 +1369,13 @@ class EventService:
             None, self._conversation.set_security_analyzer, security_analyzer
         )
 
+    async def load_plugin(self, plugin_ref: str) -> None:
+        """Load a marketplace plugin into the active conversation."""
+        if self._conversation is None:
+            raise ValueError("inactive_service")
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, self._conversation.load_plugin, plugin_ref)
+
     async def switch_acp_model(self, model: str) -> None:
         """Switch the model on an ACP conversation.