openhands-agent-server 1.25.0__tar.gz → 1.27.0__tar.gz

{openhands_agent_server-1.25.0 → openhands_agent_server-1.27.0}/PKG-INFO

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

@@ -2,6 +2,7 @@ import asyncio
 import os
 import tempfile
 import traceback
+import uuid
 from collections.abc import AsyncIterator, Sequence
 from contextlib import asynccontextmanager, suppress
 from pathlib import Path
@@ -24,7 +25,6 @@ from openhands.agent_server.config import (
     get_default_config,
 )
 from openhands.agent_server.conversation_router import conversation_router
-from openhands.agent_server.conversation_router_acp import conversation_router_acp
 from openhands.agent_server.conversation_service import (
     get_default_conversation_service,
 )
@@ -300,7 +300,6 @@ def _add_api_routes(app: FastAPI, config: Config) -> None:
     api_router = APIRouter(prefix="/api", dependencies=dependencies)
     api_router.include_router(event_router)
     api_router.include_router(conversation_router)
-    api_router.include_router(conversation_router_acp)
     api_router.include_router(tool_router)
     api_router.include_router(bash_router)
     api_router.include_router(git_router)
@@ -431,18 +430,24 @@ def _add_exception_handlers(api: FastAPI) -> None:
         request: Request, exc: Exception
     ) -> JSONResponse:
         """Handle unhandled exceptions."""
+        # Correlation id that ties the 500 a caller receives to the server-side
+        # log line (with full traceback) for this failure, so an otherwise
+        # opaque 500 can be matched to its traceback in the server logs.
+        error_id = uuid.uuid4().hex
         # Always log that we're in the exception handler for debugging
         logger.debug(
-            "Exception handler called for %s %s with %s: %s",
+            "Exception handler called for %s %s with %s: %s [error_id=%s]",
             request.method,
             request.url.path,
             type(exc).__name__,
             str(exc),
+            error_id,
         )
 
         content = {
             "detail": "Internal Server Error",
             "exception": str(exc),
+            "error_id": error_id,
         }
         # In DEBUG mode, include stack trace in response
         if DEBUG:
@@ -458,9 +463,10 @@ def _add_exception_handlers(api: FastAPI) -> None:
                 return await _http_exception_handler(request, http_exc)
             # If no HTTPException found, treat as unhandled exception
             logger.error(
-                "Unhandled ExceptionGroup on %s %s",
+                "Unhandled ExceptionGroup on %s %s [error_id=%s]",
                 request.method,
                 request.url.path,
+                error_id,
                 exc_info=(type(exc), exc, exc.__traceback__),
             )
             return JSONResponse(status_code=500, content=content)
@@ -468,9 +474,10 @@ def _add_exception_handlers(api: FastAPI) -> None:
         # Logs full stack trace for any unhandled error that FastAPI would
         # turn into a 500
         logger.error(
-            "Unhandled exception on %s %s",
+            "Unhandled exception on %s %s [error_id=%s]",
             request.method,
             request.url.path,
+            error_id,
             exc_info=(type(exc), exc, exc.__traceback__),
         )
         return JSONResponse(status_code=500, content=content)

{openhands_agent_server-1.25.0 → openhands_agent_server-1.27.0}/openhands/agent_server/conversation_service.py

@@ -1256,9 +1256,15 @@ class WebhookSubscriber(Subscriber):
         if self.session_api_key:
             headers["X-Session-API-Key"] = self.session_api_key
 
-        # Convert events to serializable format
+        # Convert events to a JSON-serializable format. mode="json" is required
+        # so types like set and SecretStr become JSON-safe primitives; without
+        # it httpx's encoder raises "Object of type set/SecretStr is not JSON
+        # serializable", every retry fails identically, and the events are
+        # dropped. (Mirrors ConversationWebhookSubscriber.post_conversation_info.)
         event_data = [
-            event.model_dump() if hasattr(event, "model_dump") else event.__dict__
+            event.model_dump(mode="json")
+            if hasattr(event, "model_dump")
+            else event.__dict__
             for event in events_to_post
         ]
 

{openhands_agent_server-1.25.0 → openhands_agent_server-1.27.0}/openhands/agent_server/mcp_router.py

@@ -6,9 +6,12 @@ to settings, where a misconfiguration would otherwise surface only at
 conversation start (and there manifest as a noisy traceback that aborts
 agent initialization).
 
-The endpoint is intentionally side-effect-free: it spins up the MCP
-connection, lists the advertised tools, then tears the connection down.
-It never mutates server state or touches stored settings.
+The endpoint never mutates server state or touches stored settings: it
+spins up the MCP connection, lists the advertised tools, optionally invokes
+one caller-chosen tool (``tool_call``), then tears the connection down.
+The optional tool call exists because listing tools does not exercise the
+credentials many servers only use inside tool handlers (e.g. the Slack MCP
+server starts fine with a bogus token); callers must pick a read-only tool.
 """
 
 from __future__ import annotations
@@ -16,12 +19,16 @@ from __future__ import annotations
 import asyncio
 from typing import Annotated, Any, Literal
 
-from fastapi import APIRouter
+import mcp.types
+from fastapi import APIRouter, Request
 from pydantic import BaseModel, Field, model_validator
 
+from openhands.agent_server._secrets_exposure import get_cipher
 from openhands.sdk.logger import get_logger
 from openhands.sdk.mcp import create_mcp_tools
 from openhands.sdk.mcp.exceptions import MCPError, MCPTimeoutError
+from openhands.sdk.utils.cipher import Cipher
+from openhands.sdk.utils.pydantic_secrets import decrypt_str_with_cipher_or_keep
 
 
 logger = get_logger(__name__)
@@ -85,6 +92,22 @@ class _RemoteMCPServerSpec(BaseModel):
         return out
 
 
+class MCPToolCallSpec(BaseModel):
+    """A single tool invocation to run as part of the connection test.
+
+    Listing tools does not exercise the credentials many servers only use
+    inside tool handlers, so callers can name one tool to invoke after the
+    listing succeeds. Callers are responsible for choosing a read-only tool;
+    the endpoint executes it verbatim.
+    """
+
+    name: str = Field(..., min_length=1, description="Name of the tool to invoke")
+    arguments: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Arguments passed to the tool unchanged.",
+    )
+
+
 class MCPTestRequest(BaseModel):
     """Body for ``POST /api/mcp/test``."""
 
@@ -108,6 +131,15 @@ class MCPTestRequest(BaseModel):
         le=120,
         description="Seconds to wait for connection + tools/list to complete.",
     )
+    tool_call: MCPToolCallSpec | None = Field(
+        default=None,
+        description=(
+            "Optional read-only tool to invoke after listing succeeds, so "
+            "callers can verify credentials the server only exercises on "
+            "tool invocation. Its outcome is reported verbatim in "
+            "`tool_result` without affecting `ok`."
+        ),
+    )
 
     @model_validator(mode="after")
     def _strip_name(self) -> MCPTestRequest:
@@ -117,6 +149,19 @@ class MCPTestRequest(BaseModel):
         return self
 
 
+class MCPToolCallResult(BaseModel):
+    """Verbatim outcome of the requested ``tool_call``.
+
+    The endpoint stays provider-neutral: many servers report upstream
+    failures (e.g. Slack's ``{"ok": false, "error": "invalid_auth"}``)
+    as ordinary text content with ``isError`` unset, so interpreting the
+    payload is the caller's job.
+    """
+
+    is_error: bool = Field(description="The MCP-level isError flag of the result.")
+    text: str = Field(description="Concatenated text content of the result.")
+
+
 class MCPTestSuccess(BaseModel):
     """Response when the candidate server connects and lists its tools."""
 
@@ -125,6 +170,10 @@ class MCPTestSuccess(BaseModel):
         default_factory=list,
         description="Names of tools advertised by the MCP server.",
     )
+    tool_result: MCPToolCallResult | None = Field(
+        default=None,
+        description=("Outcome of the requested `tool_call`, when one was supplied."),
+    )
 
 
 class MCPTestFailure(BaseModel):
@@ -151,18 +200,81 @@ MCPTestResponse = MCPTestSuccess | MCPTestFailure
 # ---------------------------------------------------------------------------
 
 
-def _server_to_fastmcp_dict(spec: _StdioMCPServerSpec | _RemoteMCPServerSpec) -> dict:
+def _decrypt_mapping(cipher: Cipher | None, mapping: dict[str, str]) -> dict[str, str]:
+    """Decrypt Fernet-encrypted values round-tripped from settings.
+
+    The GUI fetches stored settings with ``X-Expose-Secrets: encrypted`` and
+    forwards the ciphertext unchanged so the edit flow can test the *real*
+    stored credentials without ever seeing them. Plaintext values (the
+    common case: freshly typed input) pass through untouched.
+    """
+    if cipher is None:
+        return dict(mapping)
+    return {
+        key: decrypt_str_with_cipher_or_keep(
+            cipher, value, description="MCP test env/headers"
+        )
+        for key, value in mapping.items()
+    }
+
+
+def _server_to_fastmcp_dict(
+    spec: _StdioMCPServerSpec | _RemoteMCPServerSpec, cipher: Cipher | None
+) -> dict:
     if isinstance(spec, _StdioMCPServerSpec):
         out: dict[str, Any] = {"command": spec.command, "args": list(spec.args)}
         if spec.env:
-            out["env"] = dict(spec.env)
+            out["env"] = _decrypt_mapping(cipher, spec.env)
         if spec.cwd:
             out["cwd"] = spec.cwd
         return out
-    return spec.to_fastmcp_dict()
+    remote = spec.to_fastmcp_dict()
+    if "headers" in remote:
+        remote["headers"] = _decrypt_mapping(cipher, remote["headers"])
+    return remote
+
+
+def _run_tool_call(
+    client: Any, spec: MCPToolCallSpec, tool_names: list[str], timeout: float
+) -> MCPToolCallResult:
+    """Invoke the requested tool on the connected client.
+
+    Uses ``call_tool_mcp`` (not ``call_tool``, which raises on ``isError``)
+    so in-band failures come back as data -- mirrors ``MCPToolExecutor``.
+    A timeout is reported as an errored result rather than failing the
+    whole test: the server did connect and list, which is still useful.
+    """
+    if spec.name not in tool_names:
+        return MCPToolCallResult(
+            is_error=True,
+            text=(
+                f"Tool {spec.name!r} not advertised by server "
+                f"(available: {', '.join(tool_names) or 'none'})"
+            ),
+        )
+    try:
+        result: mcp.types.CallToolResult = client.call_async_from_sync(
+            client.call_tool_mcp,
+            name=spec.name,
+            arguments=spec.arguments,
+            timeout=timeout,
+        )
+    except TimeoutError:
+        return MCPToolCallResult(
+            is_error=True,
+            text=f"Tool {spec.name!r} call timed out after {timeout} seconds",
+        )
+    text = "\n".join(
+        block.text
+        for block in result.content
+        if isinstance(block, mcp.types.TextContent)
+    )
+    return MCPToolCallResult(is_error=bool(result.isError), text=text)
 
 
-def _probe_mcp_server(request: MCPTestRequest) -> MCPTestResponse:
+def _probe_mcp_server(
+    request: MCPTestRequest, cipher: Cipher | None
+) -> MCPTestResponse:
     """Synchronous probe -- safe to run inside ``run_in_executor``.
 
     ``create_mcp_tools`` already runs its own event loop in a background
@@ -171,14 +283,22 @@ def _probe_mcp_server(request: MCPTestRequest) -> MCPTestResponse:
     threadpool first.
     """
 
-    config = {"mcpServers": {request.name: _server_to_fastmcp_dict(request.server)}}
+    config = {
+        "mcpServers": {request.name: _server_to_fastmcp_dict(request.server, cipher)}
+    }
 
     try:
         # ``create_mcp_tools`` returns a client that owns a background loop
         # and a (possibly long-lived) subprocess. Use the context-manager
         # form so we always tear it down, even when listing succeeded.
         with create_mcp_tools(config, timeout=request.timeout) as client:
-            return MCPTestSuccess(tools=[tool.name for tool in client.tools])
+            tool_names = [tool.name for tool in client.tools]
+            tool_result: MCPToolCallResult | None = None
+            if request.tool_call is not None:
+                tool_result = _run_tool_call(
+                    client, request.tool_call, tool_names, request.timeout
+                )
+            return MCPTestSuccess(tools=tool_names, tool_result=tool_result)
     except MCPTimeoutError as exc:
         logger.info("MCP test timed out for server %r: %s", request.name, exc)
         return MCPTestFailure(error=str(exc), error_kind="timeout")
@@ -215,11 +335,21 @@ def _probe_mcp_server(request: MCPTestRequest) -> MCPTestResponse:
         "Attempt to connect to a candidate MCP server and list its tools, "
         "without persisting any settings. Useful for validating user input "
         "in 'add MCP server' flows before storing the config. "
+        "Optionally invokes one caller-chosen (read-only) tool via "
+        "`tool_call` and reports its outcome in `tool_result`, so callers "
+        "can verify credentials that are only exercised on tool invocation. "
+        "Encrypted `env`/`headers` values round-tripped from settings are "
+        "decrypted before the connection is attempted. "
         "Returns 200 with `ok=false` for connection / timeout failures "
         "(those are expected during validation, not server errors)."
     ),
 )
-async def test_mcp_server(request: MCPTestRequest) -> MCPTestResponse:
+async def test_mcp_server(
+    request: MCPTestRequest, http_request: Request
+) -> MCPTestResponse:
     """Probe a single MCP server config and report whether it works."""
+    # Resolve the cipher here: the threadpool function below must not
+    # reach back into ``http_request.app.state``.
+    cipher = get_cipher(http_request)
     loop = asyncio.get_running_loop()
-    return await loop.run_in_executor(None, _probe_mcp_server, request)
+    return await loop.run_in_executor(None, _probe_mcp_server, request, cipher)

{openhands_agent_server-1.25.0 → openhands_agent_server-1.27.0}/openhands/agent_server/persistence/models.py

@@ -34,16 +34,23 @@ from openhands.sdk.utils.pydantic_secrets import serialize_secret, validate_secr
 class SettingsUpdatePayload(TypedDict, total=False):
     """Typed payload for PersistedSettings.update() method.
 
-    The ``*_diff`` dicts are deep-merged via :func:`_deep_merge`: nested
+    All three ``*_diff`` dicts are deep-merged via :func:`_deep_merge`: nested
     objects merge recursively, and a ``None`` value *inside a nested map*
     deletes that entry (the "unset" primitive) — e.g. send
     ``{"acp_env": {"NAME": None}}`` to drop one env-var without re-sending the
     whole map. A ``None`` on a top-level *field* is not treated as delete; it
     flows to validation as before.
+
+    ``misc_settings_diff`` is deep-merged into the persisted ``misc_settings``
+    block. The agent-server treats ``misc_settings`` as opaque
+    frontend-owned data (it persists and merges, but does not interpret), so
+    any shape the client chooses is valid; lists are replaced wholesale by
+    the deep-merge.
     """
 
     agent_settings_diff: dict[str, Any]
     conversation_settings_diff: dict[str, Any]
+    misc_settings_diff: dict[str, Any]
     active_profile: str | None
 
 
@@ -97,7 +104,7 @@ def _deep_merge(
     return result
 
 
-PERSISTED_SETTINGS_SCHEMA_VERSION = 1
+PERSISTED_SETTINGS_SCHEMA_VERSION = 2
 
 
 class PersistedSettings(BaseModel):
@@ -109,6 +116,12 @@ class PersistedSettings(BaseModel):
 
     The ``active_profile`` field tracks which LLM profile was last activated,
     allowing frontends to display which profile is currently in use.
+
+    The ``misc_settings`` field is an opaque dict the agent-server persists
+    on behalf of the frontend. The agent-server never reads its contents and
+    has no schema for it; clients are free to store any JSON-serializable
+    structure they need (e.g. app/UI preferences, analytics consent, git
+    identity used for in-conversation commits, etc.).
     """
 
     schema_version: int = Field(
@@ -124,6 +137,14 @@ class PersistedSettings(BaseModel):
         default=None,
         description="Name of the currently active LLM profile.",
     )
+    misc_settings: dict[str, Any] = Field(
+        default_factory=dict,
+        description=(
+            "Opaque dict the agent-server persists on behalf of the frontend. "
+            "Updated through misc_settings_diff (deep-merged); contents are "
+            "never read or validated by the agent-server."
+        ),
+    )
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -173,7 +194,7 @@ class PersistedSettings(BaseModel):
         agent_update = payload.get("agent_settings_diff")
         conv_update = payload.get("conversation_settings_diff")
 
-        # Phase 1: Validate both updates before any mutations
+        # Phase 1: Validate all updates before any mutations
         new_agent: AgentSettingsConfig | None = None
         new_conv: ConversationSettings | None = None
         agent_merged: dict | None = None
@@ -232,11 +253,23 @@ class PersistedSettings(BaseModel):
                         f"Failed to update conversation settings: {type(e).__name__}"
                     ) from None
 
+            # ``misc_settings`` is opaque: deep-merge without schema
+            # validation. The agent-server doesn't interpret what's inside,
+            # and ``misc_settings`` is not a secret container — the merged
+            # dict is therefore stored directly without the post-commit
+            # clear-down used by ``agent_settings`` / ``conversation_settings``.
+            misc_update = payload.get("misc_settings_diff")
+            new_misc: dict[str, Any] | None = None
+            if isinstance(misc_update, dict):
+                new_misc = _deep_merge(self.misc_settings, misc_update)
+
             # Phase 2: Apply validated changes atomically
             if new_agent is not None:
                 self.agent_settings = new_agent
             if new_conv is not None:
                 self.conversation_settings = new_conv
+            if new_misc is not None:
+                self.misc_settings = new_misc
 
             # Update active_profile if explicitly provided (including None to clear)
             if "active_profile" in payload:
@@ -252,7 +285,14 @@ class PersistedSettings(BaseModel):
     def from_persisted(
         cls, data: Any, *, context: dict[str, Any] | None = None
     ) -> PersistedSettings:
-        """Load persisted settings, applying top-level and nested migrations."""
+        """Load persisted settings.
+
+        Schema-version history:
+
+        - **v1**: ``agent_settings`` + ``conversation_settings`` only.
+          Missing ``misc_settings`` defaults to an empty dict.
+        - **v2** (current): adds the opaque ``misc_settings`` container.
+        """
         if not isinstance(data, dict):
             return cls.model_validate(data, context=context)
 
@@ -266,6 +306,7 @@ class PersistedSettings(BaseModel):
                 f"{version} is newer than supported version "
                 f"{PERSISTED_SETTINGS_SCHEMA_VERSION}"
             )
+
         payload["schema_version"] = PERSISTED_SETTINGS_SCHEMA_VERSION
         return cls.model_validate(payload, context=context)
 

{openhands_agent_server-1.25.0 → openhands_agent_server-1.27.0}/openhands/agent_server/settings_router.py

@@ -160,6 +160,7 @@ async def get_settings(request: Request) -> SettingsResponse:
                 mode="json"
             ),
             llm_api_key_is_set=settings.llm_api_key_is_set,
+            misc_settings=settings.misc_settings,
         )
 
 
@@ -169,11 +170,12 @@ async def update_settings(
 ) -> SettingsResponse:
     """Update settings with partial changes.
 
-    Accepts ``agent_settings_diff`` and/or ``conversation_settings_diff``
-    for incremental updates. Diffs are deep-merged; nested objects merge
-    recursively, and a ``null`` value **inside a nested map deletes that
-    entry** — the "unset" primitive that lets a client remove a single map
-    key without round-tripping the whole map. To drop one ACP env-var::
+    Accepts ``agent_settings_diff``, ``conversation_settings_diff``, and/or
+    ``misc_settings_diff`` for incremental updates. All three are deep-merged;
+    nested objects merge recursively, and a ``null`` value **inside a nested
+    map deletes that entry** — the "unset" primitive that lets a client
+    remove a single map key without round-tripping the whole map. To drop one
+    ACP env-var::
 
         PATCH /api/settings
         {"agent_settings_diff": {"acp_env": {"STALE_KEY": null}}}
@@ -187,6 +189,11 @@ async def update_settings(
     is **not** an unset — it flows to model validation as before, so it still
     fails loudly rather than silently resetting the field to its default.
 
+    ``misc_settings_diff`` is deep-merged into the persisted ``misc_settings``
+    block. The agent-server treats ``misc_settings`` as opaque frontend-owned
+    data: nested dicts are merged recursively, lists are replaced wholesale,
+    and the contents are never read or validated server-side.
+
     Uses file locking to prevent concurrent updates from overwriting each other.
 
     Raises:
@@ -201,8 +208,9 @@ async def update_settings(
         raise HTTPException(
             status_code=400,
             detail=(
-                "At least one of agent_settings_diff or "
-                "conversation_settings_diff must be provided"
+                "At least one of agent_settings_diff, "
+                "conversation_settings_diff, or misc_settings_diff "
+                "must be provided"
             ),
         )
 
@@ -223,6 +231,7 @@ async def update_settings(
                 "conversation_settings_modified": (
                     "conversation_settings_diff" in update_data
                 ),
+                "misc_settings_modified": "misc_settings_diff" in update_data,
             },
         )
     except (ValueError, ValidationError):
@@ -256,6 +265,7 @@ async def update_settings(
         agent_settings=settings.agent_settings.model_dump(mode="json"),
         conversation_settings=settings.conversation_settings.model_dump(mode="json"),
         llm_api_key_is_set=settings.llm_api_key_is_set,
+        misc_settings=settings.misc_settings,
     )
 
 

{openhands_agent_server-1.25.0 → openhands_agent_server-1.27.0}/openhands/agent_server/skills_service.py

@@ -40,7 +40,7 @@ from openhands.sdk.skills import (
 )
 from openhands.sdk.skills.skill import (
     DEFAULT_MARKETPLACE_PATH,
-    PUBLIC_SKILLS_BRANCH,
+    PUBLIC_SKILLS_REF,
     PUBLIC_SKILLS_REPO,
     _invalidate_public_skills_cache,
     load_skills_from_dir,
@@ -391,7 +391,7 @@ def sync_public_skills() -> tuple[bool, str]:
     try:
         cache_dir = get_skills_cache_dir()
         result = update_skills_repository(
-            PUBLIC_SKILLS_REPO, PUBLIC_SKILLS_BRANCH, cache_dir
+            PUBLIC_SKILLS_REPO, PUBLIC_SKILLS_REF, cache_dir
         )
 
         if result:
@@ -634,7 +634,7 @@ def _fetch_catalog_entries(marketplace_path: str) -> list[_CatalogEntry]:
     """
     cache_dir = get_skills_cache_dir()
     repo_path = update_skills_repository(
-        PUBLIC_SKILLS_REPO, PUBLIC_SKILLS_BRANCH, cache_dir
+        PUBLIC_SKILLS_REPO, PUBLIC_SKILLS_REF, cache_dir
     )
 
     if repo_path is None:

{openhands_agent_server-1.25.0 → openhands_agent_server-1.27.0}/openhands_agent_server.egg-info/PKG-INFO

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

@@ -10,7 +10,6 @@ pyproject.toml
 ./openhands/agent_server/config.py
 ./openhands/agent_server/conversation_lease.py
 ./openhands/agent_server/conversation_router.py
-./openhands/agent_server/conversation_router_acp.py
 ./openhands/agent_server/conversation_service.py
 ./openhands/agent_server/dependencies.py
 ./openhands/agent_server/desktop_router.py
@@ -62,7 +61,6 @@ openhands/agent_server/cloud_proxy_router.py
 openhands/agent_server/config.py
 openhands/agent_server/conversation_lease.py
 openhands/agent_server/conversation_router.py
-openhands/agent_server/conversation_router_acp.py
 openhands/agent_server/conversation_service.py
 openhands/agent_server/dependencies.py
 openhands/agent_server/desktop_router.py

{openhands_agent_server-1.25.0 → openhands_agent_server-1.27.0}/pyproject.toml

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

openhands_agent_server-1.25.0/openhands/agent_server/conversation_router_acp.py

@@ -1,185 +0,0 @@
-"""ACP-capable conversation routes for the schema-sensitive endpoints."""
-
-# Deprecated REST contract: all /api/acp/conversations routes were deprecated
-# in v1.22.0 and are scheduled for removal in v1.27.0. The standard
-# FastAPI/OpenAPI deprecation marker for routes is ``deprecated=True`` on each
-# route decorator; keep matching docstring notices for CI deprecation checks.
-
-from typing import Annotated
-from uuid import UUID
-
-from fastapi import APIRouter, Body, Depends, HTTPException, Query, Response, status
-from pydantic import SecretStr
-
-from openhands.agent_server.conversation_service import ConversationService
-from openhands.agent_server.dependencies import get_conversation_service
-from openhands.agent_server.models import (
-    INCLUDE_SKILLS_PARAM_TITLE,
-    ACPConversationInfo,
-    ACPConversationPage,
-    ConversationSortOrder,
-    SendMessageRequest,
-    StartACPConversationRequest,
-    trim_conversation_response_skills,
-)
-from openhands.sdk import LLM, Agent, TextContent
-from openhands.sdk.agent.acp_agent import ACPAgent
-from openhands.sdk.conversation.state import ConversationExecutionStatus
-from openhands.sdk.workspace import LocalWorkspace
-from openhands.tools.preset.default import get_default_tools
-
-
-conversation_router_acp = APIRouter(
-    prefix="/acp/conversations",
-    tags=["ACP Conversations"],
-)
-
-START_ACP_CONVERSATION_EXAMPLES = [
-    StartACPConversationRequest(
-        agent=Agent(
-            llm=LLM(
-                usage_id="your-llm-service",
-                model="your-model-provider/your-model-name",
-                api_key=SecretStr("your-api-key-here"),
-            ),
-            tools=get_default_tools(enable_browser=True),
-        ),
-        workspace=LocalWorkspace(working_dir="workspace/project"),
-        initial_message=SendMessageRequest(
-            role="user", content=[TextContent(text="Flip a coin!")]
-        ),
-    ).model_dump(exclude_defaults=True, mode="json"),
-    StartACPConversationRequest(
-        agent=ACPAgent(acp_command=["npx", "-y", "claude-agent-acp"]),
-        workspace=LocalWorkspace(working_dir="workspace/project"),
-        initial_message=SendMessageRequest(
-            role="user",
-            content=[TextContent(text="Inspect the repository and summarize it.")],
-        ),
-    ).model_dump(exclude_defaults=True, mode="json"),
-]
-
-
-@conversation_router_acp.get("/search", deprecated=True)
-async def search_acp_conversations(
-    page_id: Annotated[
-        str | None,
-        Query(title="Optional next_page_id from the previously returned page"),
-    ] = None,
-    limit: Annotated[
-        int,
-        Query(title="The max number of results in the page", gt=0, lte=100),
-    ] = 100,
-    status: Annotated[
-        ConversationExecutionStatus | None,
-        Query(title="Optional filter by conversation execution status"),
-    ] = None,
-    sort_order: Annotated[
-        ConversationSortOrder,
-        Query(title="Sort order for conversations"),
-    ] = ConversationSortOrder.CREATED_AT_DESC,
-    include_skills: Annotated[bool, Query(title=INCLUDE_SKILLS_PARAM_TITLE)] = False,
-    conversation_service: ConversationService = Depends(get_conversation_service),
-) -> ACPConversationPage:
-    """Search conversations using the ACP-capable contract.
-
-    Deprecated since v1.22.0 and scheduled for removal in v1.27.0.
-    Use ``/api/conversations/search`` instead.
-    """
-    assert limit > 0
-    assert limit <= 100
-    page = await conversation_service.search_acp_conversations(
-        page_id, limit, status, sort_order
-    )
-    if not include_skills:
-        page = page.model_copy(
-            update={
-                "items": [
-                    trim_conversation_response_skills(item) for item in page.items
-                ]
-            }
-        )
-    return page
-
-
-@conversation_router_acp.get("/count", deprecated=True)
-async def count_acp_conversations(
-    status: Annotated[
-        ConversationExecutionStatus | None,
-        Query(title="Optional filter by conversation execution status"),
-    ] = None,
-    conversation_service: ConversationService = Depends(get_conversation_service),
-) -> int:
-    """Count conversations using the ACP-capable contract.
-
-    Deprecated since v1.22.0 and scheduled for removal in v1.27.0.
-    Use ``/api/conversations/count`` instead.
-    """
-    return await conversation_service.count_conversations(status)
-
-
-@conversation_router_acp.get(
-    "/{conversation_id}",
-    responses={404: {"description": "Item not found"}},
-    deprecated=True,
-)
-async def get_acp_conversation(
-    conversation_id: UUID,
-    include_skills: Annotated[bool, Query(title=INCLUDE_SKILLS_PARAM_TITLE)] = False,
-    conversation_service: ConversationService = Depends(get_conversation_service),
-) -> ACPConversationInfo:
-    """Get a conversation using the ACP-capable contract.
-
-    Deprecated since v1.22.0 and scheduled for removal in v1.27.0.
-    Use ``/api/conversations/{conversation_id}`` instead.
-    """
-    conversation = await conversation_service.get_acp_conversation(conversation_id)
-    if conversation is None:
-        raise HTTPException(status.HTTP_404_NOT_FOUND)
-    if not include_skills:
-        conversation = trim_conversation_response_skills(conversation)
-    return conversation
-
-
-@conversation_router_acp.get("", deprecated=True)
-async def batch_get_acp_conversations(
-    ids: Annotated[list[UUID], Query()],
-    include_skills: Annotated[bool, Query(title=INCLUDE_SKILLS_PARAM_TITLE)] = False,
-    conversation_service: ConversationService = Depends(get_conversation_service),
-) -> list[ACPConversationInfo | None]:
-    """Batch get conversations using the ACP-capable contract.
-
-    Deprecated since v1.22.0 and scheduled for removal in v1.27.0.
-    Use ``/api/conversations`` instead.
-    """
-    assert len(ids) < 100
-    conversations = await conversation_service.batch_get_acp_conversations(ids)
-    if not include_skills:
-        return [
-            trim_conversation_response_skills(c) if c is not None else None
-            for c in conversations
-        ]
-    return conversations
-
-
-@conversation_router_acp.post("", deprecated=True)
-async def start_acp_conversation(
-    request: Annotated[
-        StartACPConversationRequest,
-        Body(examples=START_ACP_CONVERSATION_EXAMPLES),
-    ],
-    response: Response,
-    include_skills: Annotated[bool, Query(title=INCLUDE_SKILLS_PARAM_TITLE)] = False,
-    conversation_service: ConversationService = Depends(get_conversation_service),
-) -> ACPConversationInfo:
-    """Start a conversation using the ACP-capable contract.
-
-    Deprecated since v1.22.0 and scheduled for removal in v1.27.0.
-    Use ``/api/conversations`` instead; it now accepts ACP agents and
-    ``agent_settings`` payloads.
-    """
-    info, is_new = await conversation_service.start_acp_conversation(request)
-    response.status_code = status.HTTP_201_CREATED if is_new else status.HTTP_200_OK
-    if not include_skills:
-        info = trim_conversation_response_skills(info)
-    return info