openhands-agent-server 1.31.0__tar.gz → 1.31.2__tar.gz

{openhands_agent_server-1.31.0 → openhands_agent_server-1.31.2}/PKG-INFO

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

@@ -12,7 +12,6 @@ MCP references and returns :class:`~openhands.sdk.profiles.AgentProfileDiagnosti
 """
 
 import asyncio
-import copy
 from collections.abc import Iterator
 from contextlib import contextmanager
 from typing import Annotated, Any
@@ -42,10 +41,8 @@ from openhands.sdk.llm.llm_profile_store import (
 from openhands.sdk.logger import get_logger
 from openhands.sdk.profiles import (
     SEED_PROFILE_NAME,
-    ACPAgentProfile,
     AgentProfileDiagnostics,
     AgentProfileStore,
-    OpenHandsAgentProfile,
     ProfileLimitExceeded,
     build_seed_profile,
     resolve_agent_profile_dry_run,
@@ -55,7 +52,6 @@ from openhands.sdk.profiles import (
 )
 from openhands.sdk.profiles.agent_profile_store import PROFILE_NAME_PATTERN
 from openhands.sdk.utils.cipher import Cipher
-from openhands.sdk.utils.pydantic_secrets import decrypt_str_with_cipher_or_keep
 
 
 logger = get_logger(__name__)
@@ -134,54 +130,6 @@ def _store_errors() -> Iterator[None]:
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
 
 
-def _decrypt_mcp_tools(tools: dict[str, Any], cipher: Cipher) -> dict[str, Any]:
-    """Return a copy of an ``mcp_tools`` dict with env/headers Fernet tokens
-    decrypted. Non-Fernet (plaintext) values pass through unchanged."""
-    servers = tools.get("mcpServers")
-    if not isinstance(servers, dict):
-        return tools
-    out = copy.deepcopy(tools)
-    for server in out["mcpServers"].values():
-        if not isinstance(server, dict):
-            continue
-        for key in ("env", "headers"):
-            mapping = server.get(key)
-            if isinstance(mapping, dict):
-                server[key] = {
-                    k: decrypt_str_with_cipher_or_keep(
-                        cipher, v, description="MCP env/headers"
-                    )
-                    for k, v in mapping.items()
-                }
-    return out
-
-
-def _decrypt_profile_mcp_tools(
-    profile: OpenHandsAgentProfile | ACPAgentProfile, cipher: Cipher | None
-) -> OpenHandsAgentProfile | ACPAgentProfile:
-    """Decrypt Fernet ``skills[].mcp_tools`` env/headers (no-op without a cipher).
-
-    The store masks/encrypts these on save but has no symmetric load-time
-    validator, so values arrive as ciphertext on both GET (at-rest) and save
-    (client round-trip). Decrypting here lets GET re-mask from plaintext and
-    stops save from double-encrypting an already-encrypted value.
-    """
-    if cipher is None:
-        return profile
-    skills = getattr(profile, "skills", None)
-    if not skills:
-        return profile
-    new_skills = [
-        skill.model_copy(
-            update={"mcp_tools": _decrypt_mcp_tools(skill.mcp_tools, cipher)}
-        )
-        if skill.mcp_tools
-        else skill
-        for skill in skills
-    ]
-    return profile.model_copy(update={"skills": new_skills})
-
-
 def _seed_default_llm_profile(llm: LLM, cipher: Cipher | None) -> str:
     """Mirror the live LLM config into a ``SEED_PROFILE_NAME`` LLM profile.
 
@@ -265,9 +213,6 @@ def _seed_default_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)
         store.save(profile, cipher=cipher, max_profiles=MAX_AGENT_PROFILES)
 
         profile_id = str(profile.id)
@@ -342,10 +287,6 @@ async def get_agent_profile(
             detail=f"Agent profile '{name}' not found",
         )
 
-    # The store leaves skills[].mcp_tools encrypted on load; decrypt to plaintext
-    # so the expose serializer can correctly redact / re-encrypt / reveal them.
-    profile = _decrypt_profile_mcp_tools(profile, cipher)
-
     context = build_expose_context(expose_mode, cipher)
     with translate_missing_cipher():
         payload = profile.model_dump(mode="json", context=context)
@@ -374,7 +315,8 @@ async def save_agent_profile(
     except ValidationError as e:
         # Match FastAPI's request-validation shape (``detail`` is a list of error
         # objects), but surface only ``loc``/``type`` — a nested mcp_tools
-        # MCPConfig error embeds the input (which may carry secrets) in ``msg``.
+        # FastMCP config error embeds the input (which may carry secrets) in
+        # ``msg``.
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=safe_validation_error_detail(e),
@@ -388,11 +330,6 @@ async def save_agent_profile(
             detail="Invalid agent profile",
         )
 
-    # A client editing a profile fetched with X-Expose-Secrets: encrypted posts
-    # back Fernet tokens; decrypt them so the save re-encrypts the original
-    # secret once rather than double-encrypting the token.
-    profile = _decrypt_profile_mcp_tools(profile, cipher)
-
     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,
@@ -564,10 +501,6 @@ async def materialize_agent_profile(
             detail=f"Agent profile '{name}' not found",
         )
 
-    # The store leaves skills[].mcp_tools encrypted on load; decrypt so the
-    # resolver builds settings from plaintext (not ciphertext) values.
-    profile = _decrypt_profile_mcp_tools(profile, cipher)
-
     config = get_config(request)
     settings = get_settings_store(config).load() or PersistedSettings()
     mcp_config = settings.agent_settings.mcp_config

{openhands_agent_server-1.31.0 → openhands_agent_server-1.31.2}/openhands/agent_server/conversation_service.py

@@ -48,12 +48,15 @@ from openhands.sdk.event import MessageEvent
 from openhands.sdk.event.conversation_state import ConversationStateUpdateEvent
 from openhands.sdk.git.exceptions import GitCommandError, GitRepositoryError
 from openhands.sdk.git.utils import run_git_command, validate_git_repository
+from openhands.sdk.mcp.utils import MCPToolProvider
+from openhands.sdk.tool import BROWSER_TOOL_NAME, Tool, is_tool_usable
 from openhands.sdk.tool.client_tool import register_client_tools
 from openhands.sdk.utils.cipher import Cipher
 from openhands.sdk.workspace import LocalWorkspace
 
 
 if TYPE_CHECKING:
+    from openhands.sdk.mcp.config import MCPServer
     from openhands.sdk.subagent.schema import AgentDefinition
 
 CONVERSATION_WORKTREE_ROOT = Path("/tmp/conversation-worktrees")
@@ -249,14 +252,14 @@ logger = logging.getLogger(__name__)
 def _resolve_agent_from_profile(
     profile_id: "UUID",
     cipher: "Cipher | None",
-    mcp_config: "Any",
+    mcp_config: "dict[str, MCPServer]",
 ) -> "tuple[AgentBase, LaunchedAgentProfile]":
     """Load and resolve an agent profile by id, returning the built agent + provenance.
 
     Runs synchronously (call via ``asyncio.to_thread`` from async context).
 
     Args:
-        mcp_config: Global MCP config already loaded by the caller using the
+        mcp_config: Global MCP servers already loaded by the caller using the
             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).
@@ -312,6 +315,17 @@ def _resolve_agent_from_profile(
         raise ValueError(f"Profile '{profile_name}' failed to resolve: {exc}") from exc
 
     agent = settings_config.create_agent()
+    # Browser is deliberately absent from the deterministic SDK default
+    # (environment-dependent); this server knows its runtime, so it injects
+    # browser when usable. An explicit profile.tools list is authoritative.
+    if (
+        profile.agent_kind == "openhands"
+        and profile.tools is None
+        and is_tool_usable(BROWSER_TOOL_NAME)
+    ):
+        agent = agent.model_copy(
+            update={"tools": [*agent.tools, Tool(name=BROWSER_TOOL_NAME)]}
+        )
     launched = LaunchedAgentProfile(
         agent_profile_id=profile.id,
         revision=profile.revision,
@@ -461,6 +475,7 @@ class ConversationService:
     webhook_specs: list[WebhookSpec] = field(default_factory=list)
     session_api_key: str | None = field(default=None)
     cipher: Cipher | None = None
+    mcp_tool_provider: MCPToolProvider | 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
@@ -1256,6 +1271,9 @@ class ConversationService:
     def get_instance(cls, config: Config) -> "ConversationService":
         # Initialise the settings-store singleton with the server cipher before
         # any conversation handler can call get_settings_store() without config.
+        from openhands.agent_server.mcp_oauth_store import (
+            create_settings_backed_mcp_tool_provider,
+        )
         from openhands.agent_server.persistence import get_settings_store
 
         get_settings_store(config)
@@ -1266,6 +1284,7 @@ class ConversationService:
                 config.session_api_keys[0] if config.session_api_keys else None
             ),
             cipher=config.cipher,
+            mcp_tool_provider=create_settings_backed_mcp_tool_provider(config),
             max_concurrent_runs=config.max_concurrent_runs,
             lease_ttl_seconds=config.lease_ttl_seconds,
         )
@@ -1279,6 +1298,7 @@ class ConversationService:
             stored=stored,
             conversations_dir=self.conversations_dir,
             cipher=self.cipher,
+            mcp_tool_provider=self.mcp_tool_provider,
             owner_instance_id=self.owner_instance_id,
             lease_ttl_seconds=self.lease_ttl_seconds,
         )

openhands_agent_server-1.31.2/openhands/agent_server/event_compat.py

@@ -0,0 +1,50 @@
+"""Compatibility helpers for event transport payloads."""
+
+from typing import Any, Final
+
+from openhands.sdk.event import Event
+
+
+_LEGACY_TOOL_KINDS: Final[set[str]] = {
+    "ClientTool",
+    "FileEditorTool",
+    "FinishTool",
+    "InvokeSkillTool",
+    "MCPToolDefinition",
+    "SwitchLLMTool",
+    "TaskTool",
+    "TaskToolSet",
+    "TaskTrackerTool",
+    "TerminalTool",
+    "ThinkTool",
+    "WorkflowTool",
+    "WorkflowToolSet",
+}
+
+
+def event_transport_dump(event: Event | dict[str, Any]) -> dict[str, Any]:
+    """Serialize an event for HTTP/WebSocket clients across SDK versions.
+
+    Some deployed clients run older SDKs than the agent-server. They parse event
+    payloads with strict pydantic unions, so additive fields and new tool kinds
+    can make otherwise completed conversations look failed client-side. Keep
+    persistence untouched and apply this compatibility envelope only at the API
+    transport boundary.
+    """
+    if isinstance(event, dict):
+        dumped = dict(event)
+    else:
+        dumped = event.model_dump(mode="json", exclude_none=True)
+    dumped.pop("parent_id", None)
+
+    tools = dumped.get("tools")
+    if isinstance(tools, list):
+        dumped["tools"] = [
+            tool
+            for tool in tools
+            if not isinstance(tool, dict)
+            or tool.get("kind") is None
+            or tool.get("kind") in _LEGACY_TOOL_KINDS
+        ]
+
+    return dumped

{openhands_agent_server-1.31.0 → openhands_agent_server-1.31.2}/openhands/agent_server/event_router.py

@@ -4,7 +4,7 @@ Local Event router for OpenHands SDK.
 
 import logging
 from datetime import datetime
-from typing import Annotated
+from typing import Annotated, Any, cast
 
 from fastapi import (
     APIRouter,
@@ -13,12 +13,13 @@ from fastapi import (
     Query,
     status,
 )
+from starlette.responses import JSONResponse
 
 from openhands.agent_server.dependencies import get_event_service
+from openhands.agent_server.event_compat import event_transport_dump
 from openhands.agent_server.event_service import EventService
 from openhands.agent_server.models import (
     ConfirmationResponseRequest,
-    EventPage,
     EventSortOrder,
     SendMessageRequest,
     Success,
@@ -99,7 +100,7 @@ async def search_conversation_events(
         Query(title="Filter: event timestamp < this datetime"),
     ] = None,
     event_service: EventService = Depends(get_event_service),
-) -> EventPage:
+) -> JSONResponse:
     """Search / List local events"""
     assert limit > 0
     assert limit <= 100
@@ -114,9 +115,21 @@ async def search_conversation_events(
         normalize_datetime_to_server_timezone(timestamp__lt) if timestamp__lt else None
     )
 
-    return await event_service.search_events(
+    page = await event_service.search_events(
         page_id, limit, kind, source, body, sort_order, normalized_gte, normalized_lt
     )
+    if isinstance(page, dict):
+        items = cast(list[Any], page.get("items", []))
+        next_page_id = cast(str | None, page.get("next_page_id"))
+    else:
+        items = page.items
+        next_page_id = page.next_page_id
+    return JSONResponse(
+        {
+            "items": [event_transport_dump(event) for event in items],
+            "next_page_id": next_page_id,
+        }
+    )
 
 
 @event_router.get("/count", responses={404: {"description": "Conversation not found"}})

{openhands_agent_server-1.31.0 → openhands_agent_server-1.31.2}/openhands/agent_server/event_service.py

@@ -55,6 +55,7 @@ from openhands.sdk.event.llm_completion_log import LLMCompletionLogEvent
 from openhands.sdk.git.exceptions import GitCommandError, GitRepositoryError
 from openhands.sdk.git.utils import run_git_command, validate_git_repository
 from openhands.sdk.llm.streaming import LLMStreamChunk
+from openhands.sdk.mcp.utils import MCPToolProvider
 from openhands.sdk.security.analyzer import SecurityAnalyzerBase
 from openhands.sdk.security.confirmation_policy import ConfirmationPolicyBase
 from openhands.sdk.utils.async_utils import AsyncCallbackWrapper
@@ -81,6 +82,7 @@ class EventService:
     stored: StoredConversation
     conversations_dir: Path
     cipher: Cipher | None = None
+    mcp_tool_provider: MCPToolProvider | 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)
@@ -579,21 +581,26 @@ class EventService:
         # conversation's synchronous FIFOLock cannot block the server event loop.
         if self._conversation:
             state_update_event = await self._create_state_update_event()
+        else:
+            state_update_event = ConversationStateUpdateEvent(
+                key="execution_status",
+                value=ConversationExecutionStatus.IDLE,
+            )
 
-            try:
-                await asyncio.wait_for(
-                    subscriber(state_update_event),
-                    timeout=INITIAL_STATE_PUSH_TIMEOUT_SECONDS,
-                )
-            except TimeoutError:
-                # Subscriber stays registered; only the initial-state push is
-                # dropped. Subsequent publishes go through pub_sub and may
-                # still block there if the subscriber remains wedged.
-                logger.warning(
-                    f"Initial state push to subscriber {subscriber_id} timed "
-                    f"out after {INITIAL_STATE_PUSH_TIMEOUT_SECONDS}s."
-                )
-            # Non-timeout errors propagate to caller (e.g. webhook failures).
+        try:
+            await asyncio.wait_for(
+                subscriber(state_update_event),
+                timeout=INITIAL_STATE_PUSH_TIMEOUT_SECONDS,
+            )
+        except TimeoutError:
+            # Subscriber stays registered; only the initial-state push is
+            # dropped. Subsequent publishes go through pub_sub and may
+            # still block there if the subscriber remains wedged.
+            logger.warning(
+                f"Initial state push to subscriber {subscriber_id} timed "
+                f"out after {INITIAL_STATE_PUSH_TIMEOUT_SECONDS}s."
+            )
+        # Non-timeout errors propagate to caller (e.g. webhook failures).
 
         return subscriber_id
 
@@ -832,6 +839,7 @@ class EventService:
             observability_metadata=self.stored.observability_metadata,
             observability_tags=self.stored.observability_tags,
             observability_span_name=self.stored.observability_span_name,
+            mcp_tool_provider=self.mcp_tool_provider,
         )
 
         conversation.set_confirmation_policy(self.stored.confirmation_policy)