openhands-sdk 1.57.0__tar.gz → 1.58.0__tar.gz

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-sdk
-Version: 1.57.0
+Version: 1.58.0
 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

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/openhands/sdk/conversation/goal/controller.py

@@ -103,12 +103,14 @@ class GoalController:
     def on_run_finished(self, events: Sequence[Event]) -> GoalStep:
         """Judge the objective after a run and decide whether to continue.
 
-        Increments the iteration count, audits ``events`` with the judge LLM,
-        and returns a :class:`GoalContinue` (with a followup) or a terminal
-        :class:`GoalDone` (with a :class:`GoalOutcome`).
+        Audits ``events`` with the judge LLM, counts the round once the judge
+        has returned a verdict, and returns a :class:`GoalContinue` (with a
+        followup) or a terminal :class:`GoalDone` (with a :class:`GoalOutcome`).
+        A judge call that raises leaves the count unchanged: a failed or
+        abandoned audit is not a completed round.
         """
-        self.iteration += 1
         verdict = judge_goal(self.judge_llm, self.objective, events)
+        self.iteration += 1
         logger.info(
             "Goal audit %d/%d: score=%.2f complete=%s",
             self.iteration,

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/openhands/sdk/conversation/impl/local_conversation.py

@@ -446,8 +446,14 @@ class LocalConversation(BaseConversation):
             # Single chokepoint: stamps parent_id (catching any event a hook
             # swapped in downstream of _tree_stamping) and advances HEAD.
             self._state.append_event(e)
+
+        def _track_last_user_message(e):
             # Track user MessageEvent IDs here so hook callbacks (which may
             # synthesize or alter user messages) are captured in one place.
+            # This runs after the caller-supplied callbacks: setting the field
+            # can emit a ConversationStateUpdateEvent through on_state_change
+            # (the agent server wires it to this chain), and that update must
+            # reach subscribers after the message that caused it.
             if isinstance(e, MessageEvent) and e.source == "user":
                 # Track the latest real user message ID for hook-blocked checks.
                 # Stop-hook feedback is emitted with source="environment".
@@ -461,7 +467,7 @@ class LocalConversation(BaseConversation):
         # list never run. The visualizer is prepended below and so still renders
         # ahead of persist — that is local terminal output, not an announcement
         # a client can act on.
-        composed_list = [_default_callback] + callback_list
+        composed_list = [_default_callback] + callback_list + [_track_last_user_message]
         # Handle visualization configuration
         if isinstance(visualizer, ConversationVisualizerBase):
             # Use custom visualizer instance
@@ -1605,6 +1611,13 @@ class LocalConversation(BaseConversation):
                     self._state,
                     on_event=self._on_event,
                 )
+
+                # Deliver any SessionStart additional_context now that
+                # init_state() has emitted the SystemPromptEvent, so the system
+                # prompt stays first in the LLM request. The hook processor
+                # collected it earlier during _ensure_plugins_loaded().
+                if self._hook_processor is not None:
+                    self._hook_processor.inject_pending_additional_context()
             except Exception:
                 self._close_runtime_tools(runtime_mcp_tools)
                 raise

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/openhands/sdk/git/git_diff.py

@@ -50,6 +50,21 @@ def get_closest_git_repo(path: Path) -> Path | None:
         current_path = parent
 
 
+def _base_file_size(repo: Path, ref: str, relative_path: Path) -> int | None:
+    """Size of the file (blob) ``relative_path`` at ``ref``, or ``None``
+    when ``ref`` has no file at that path."""
+    spec = f"{ref}:{relative_path.as_posix()}"
+    try:
+        object_type = run_git_command(
+            ["git", "cat-file", "-t", spec], repo, expected_failure=True
+        )
+        if object_type != "blob":
+            return None
+        return int(run_git_command(["git", "cat-file", "-s", spec], repo))
+    except (GitCommandError, ValueError):
+        return None
+
+
 def get_git_diff(relative_file_path: str | Path, ref: str | None = None) -> GitDiff:
     """Get git diff for a single file.
 
@@ -63,20 +78,23 @@ def get_git_diff(relative_file_path: str | Path, ref: str | None = None) -> GitD
         GitDiff object containing diff information
 
     Raises:
-        GitPathError: If file is too large or doesn't exist
+        GitPathError: If file is too large, or exists neither on disk nor
+            at the base ref (a working-tree deletion diffs as the base text
+            against ``""``)
         GitRepositoryError: If not in a git repository
         GitCommandError: If git commands fail (including when ``ref`` is
             provided but does not resolve in the repository).
     """
     path = Path(os.getcwd(), relative_file_path).resolve()
+    missing_error = GitPathError(f"File does not exist: {path}")
 
-    # Check if file exists
-    if not path.exists():
-        raise GitPathError(f"File does not exist: {path}")
+    # A path missing from disk may still be a working-tree deletion (or the
+    # old side of a rename) that only exists at the base ref.
+    deleted = not path.exists()
 
     # Check file size
     try:
-        file_size = os.path.getsize(path)
+        file_size = 0 if deleted else os.path.getsize(path)
         if file_size > MAX_FILE_SIZE_FOR_GIT_DIFF:
             raise GitPathError(
                 f"File too large for git diff: {file_size} bytes "
@@ -88,6 +106,8 @@ def get_git_diff(relative_file_path: str | Path, ref: str | None = None) -> GitD
     # Find git repository
     closest_git_repo = get_closest_git_repo(path)
     if not closest_git_repo:
+        if deleted:
+            raise missing_error
         raise GitRepositoryError(f"File is not in a git repository: {path}")
 
     # Validate the git repository
@@ -97,6 +117,8 @@ def get_git_diff(relative_file_path: str | Path, ref: str | None = None) -> GitD
     # so the per-file diff lines up with the change list it was opened from.
     current_rev = get_valid_ref(validated_repo, override=ref, purpose="display")
     if not current_rev:
+        if deleted:
+            raise missing_error
         logger.warning(f"No valid git reference found for {validated_repo}")
         return GitDiff(modified="", original="")
 
@@ -106,6 +128,18 @@ def get_git_diff(relative_file_path: str | Path, ref: str | None = None) -> GitD
     except ValueError as e:
         raise GitPathError(f"File is not within git repository: {path}") from e
 
+    if deleted:
+        base_size = _base_file_size(
+            validated_repo, current_rev, relative_path_from_repo
+        )
+        if base_size is None:
+            raise missing_error
+        if base_size > MAX_FILE_SIZE_FOR_GIT_DIFF:
+            raise GitPathError(
+                f"File too large for git diff: {base_size} bytes "
+                f"(max: {MAX_FILE_SIZE_FOR_GIT_DIFF} bytes)"
+            )
+
     # Get old content (from the ref)
     try:
         # Read the blob verbatim and normalize it like the modified side below,
@@ -121,6 +155,10 @@ def get_git_diff(relative_file_path: str | Path, ref: str | None = None) -> GitD
         logger.debug(f"No old content found for {path} at ref {current_rev}")
         original = ""
 
+    if deleted:
+        logger.info(f"Generated git diff for deleted file {path}")
+        return GitDiff(modified="", original=original)
+
     # Get new content (current file)
     try:
         with open(path, encoding="utf-8") as f:

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/openhands/sdk/hooks/conversation_hooks.py

@@ -15,7 +15,7 @@ from openhands.sdk.hooks.config import HookConfig
 from openhands.sdk.hooks.executor import HookResult
 from openhands.sdk.hooks.manager import HookManager
 from openhands.sdk.hooks.types import HookEventType
-from openhands.sdk.llm import TextContent
+from openhands.sdk.llm import Message, TextContent
 from openhands.sdk.logger import get_logger
 
 
@@ -66,6 +66,9 @@ class HookEventProcessor:
         self.original_callback = original_callback
         self._conversation_state: ConversationState | None = None
         self.emit_hook_events = emit_hook_events
+        # SessionStart additional_context collected by run_session_start() and
+        # delivered later by inject_pending_additional_context(); see those methods.
+        self._pending_additional_context: list[str] = []
 
     def set_conversation_state(self, state: "ConversationState") -> None:
         """Set conversation state for blocking support."""
@@ -338,6 +341,45 @@ class HookEventProcessor:
             if result.error:
                 logger.warning(f"SessionStart hook error: {result.error}")
 
+        # Collect additional_context for delivery to the agent, but do not emit
+        # it here. run_session_start() runs while plugins load, before the agent
+        # emits its SystemPromptEvent, so emitting now would place a user message
+        # ahead of the system prompt and break the system-first invariant (and the
+        # prompt cache, which only applies to a leading system message). The
+        # conversation flushes it with inject_pending_additional_context() once
+        # init_state() has emitted the system prompt.
+        self._pending_additional_context.extend(
+            r.additional_context for r in results if r.additional_context
+        )
+
+    def inject_pending_additional_context(self) -> None:
+        """Deliver collected SessionStart additional_context to the agent.
+
+        Emits the context as a single ``MessageEvent``. Call this after the
+        agent's ``SystemPromptEvent`` is in the log so the system prompt stays
+        first in the request, mirroring the ``UserPromptSubmit`` path (which
+        extends the existing user turn rather than prepending a new one). The
+        pending context is cleared on delivery, so re-running SessionStart hooks
+        (for example when runtime plugin hooks merge) does not deliver it twice.
+        """
+        if not self._pending_additional_context or not self.original_callback:
+            return
+
+        additional_context = "\n".join(self._pending_additional_context)
+        self._pending_additional_context = []
+        logger.debug(
+            f"SessionStart hook injecting context: {additional_context[:100]}..."
+        )
+        self.original_callback(
+            MessageEvent(
+                source="environment",
+                llm_message=Message(
+                    role="user",
+                    content=[TextContent(text=additional_context)],
+                ),
+            )
+        )
+
     def run_session_end(self) -> None:
         """Run SessionEnd hooks. Call before conversation is closed."""
         hooks = self.hook_manager.config.get_hooks_for_event(HookEventType.SESSION_END)

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/openhands/sdk/llm/meta_profile_store.py

@@ -88,7 +88,12 @@ class MetaProfile(BaseModel):
 
     @model_validator(mode="after")
     def validate_routing_mode(self) -> MetaProfile:
-        """Require either structured classes or a direct prompt, not both."""
+        """Validate direct-prompt mode: a template needs ``{{ instance_text }}``
+        and excludes classes.
+
+        A meta-profile with neither classes nor a template is accepted here so
+        persisted ones still load; ``POST /api/meta-profiles/{name}`` refuses it.
+        """
         if self.prompt_template is None:
             return self
         if re.search(r"{{\s*instance_text\s*}}", self.prompt_template) is None:

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/openhands/sdk/llm/utils/verified_models.py

@@ -70,8 +70,9 @@ VERIFIED_MOONSHOT_MODELS = [
     "kimi-for-coding",
 ]
 
-# M3 and M2.7.
+# M3 (incl. flash) and M2.7.
 VERIFIED_MINIMAX_MODELS = [
+    "minimax-m3.1-flash",
     "minimax-m3",
     "minimax-m2.7",
 ]
@@ -172,6 +173,7 @@ VERIFIED_OPENHANDS_MODELS = [
     "gpt-5.6",
     "gpt-5.3-codex",
     "gpt-5.2-codex",
+    "minimax-m3.1-flash",
     "minimax-m3",
     "minimax-m2.7",
     "gemini-3.1-pro",

openhands_sdk-1.58.0/openhands/sdk/mcp/oauth.py

@@ -0,0 +1,203 @@
+"""FastMCP OAuth client that discovers the token endpoint before refreshing."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from contextlib import aclosing
+from typing import Any, Literal
+from urllib.parse import parse_qsl
+
+import httpx
+from fastmcp.client.auth import OAuth
+from mcp.client.auth.utils import (
+    build_oauth_authorization_server_metadata_discovery_urls,
+    build_protected_resource_metadata_discovery_urls,
+    create_client_registration_request,
+    create_oauth_metadata_request,
+    handle_auth_metadata_response,
+    handle_protected_resource_response,
+)
+
+from openhands.sdk.logger import get_logger
+from openhands.sdk.mcp.exceptions import MCPError
+
+
+logger = get_logger(__name__)
+
+_DISCOVERY_TIMEOUT = httpx.Timeout(10.0)
+
+_TokenEndpointAuthMethod = Literal["none", "client_secret_post", "client_secret_basic"]
+
+# Most preferred first: a public client is never issued a secret to keep.
+_TOKEN_ENDPOINT_AUTH_METHODS: tuple[_TokenEndpointAuthMethod, ...] = (
+    "none",
+    "client_secret_post",
+    "client_secret_basic",
+)
+
+
+def _preferred_token_endpoint_auth_method(
+    supported: list[str] | None,
+) -> _TokenEndpointAuthMethod | None:
+    for method in _TOKEN_ENDPOINT_AUTH_METHODS:
+        if method in (supported or ()):
+            return method
+    return None
+
+
+def _without_client_id_when_basic(request: httpx.Request) -> httpx.Request:
+    """Drop ``client_id`` from the form body of a Basic-authenticated request.
+
+    RFC 6749 section 2.3.1 forbids combining the ``Authorization`` header with
+    body credentials, and strict servers reject the mix as using multiple
+    authentication methods.
+    """
+    if not request.headers.get("Authorization", "").startswith("Basic "):
+        return request
+    data = dict(parse_qsl(request.content.decode(), keep_blank_values=True))
+    data.pop("client_id", None)
+    headers = request.headers.copy()
+    headers.pop("Content-Length", None)
+    return httpx.Request(request.method, request.url, data=data, headers=headers)
+
+
+class MCPOAuth(OAuth):
+    """FastMCP ``OAuth`` whose token refresh targets the discovered endpoint.
+
+    The upstream ``OAuthClientProvider`` refreshes an expired access token
+    before sending a request, but discovers the authorization server's
+    metadata only inside its 401 branch and never persists it. Every
+    conversation builds a fresh client, so ``_refresh_token`` falls back to
+    ``<MCP server origin>/token``, which is wrong for providers such as GitLab
+    (``/oauth/token``) and Atlassian (``/v1/token``). The 404 that follows
+    drops the tokens and starts the interactive browser flow, which cannot
+    complete inside a sandbox.
+
+    ``_refresh_token`` runs under upstream's context lock after
+    ``_initialize()`` restored the stored tokens and expiry, so discovery only
+    happens when a refresh is actually about to be attempted.
+
+    Dynamic client registration asks for a token endpoint auth method the
+    authorization server advertises, preferring a public client. Upstream
+    sends none, so servers fall back to the RFC 7591 default
+    ``client_secret_basic`` and issue a secret. Token requests that do use
+    Basic auth leave ``client_id`` out of the body, which upstream always
+    includes and which strict servers reject.
+    """
+
+    async def async_auth_flow(
+        self, request: httpx.Request
+    ) -> AsyncGenerator[httpx.Request, httpx.Response]:
+        async with aclosing(super().async_auth_flow(request)) as flow:
+            outgoing = await anext(flow)
+            while True:
+                response = yield self._with_supported_auth_method(outgoing)
+                try:
+                    outgoing = await flow.asend(response)
+                except StopAsyncIteration:
+                    return
+
+    def _with_supported_auth_method(self, request: httpx.Request) -> httpx.Request:
+        """Rebuild the registration request around a supported auth method.
+
+        Any other request, an explicitly configured method and a server that
+        advertises no known method all pass through unchanged.
+        """
+        context = self.context
+        if (
+            context.client_info is not None
+            or context.oauth_metadata is None
+            or context.client_metadata.token_endpoint_auth_method is not None
+        ):
+            return request
+        method = _preferred_token_endpoint_auth_method(
+            context.oauth_metadata.token_endpoint_auth_methods_supported
+        )
+        if method is None or request.url != self._registration_request().url:
+            return request
+        context.client_metadata.token_endpoint_auth_method = method
+        return self._registration_request()
+
+    def _registration_request(self) -> httpx.Request:
+        return create_client_registration_request(
+            self.context.oauth_metadata,
+            self.context.client_metadata,
+            self.context.get_authorization_base_url(self.context.server_url),
+        )
+
+    async def _exchange_token_authorization_code(
+        self,
+        auth_code: str,
+        code_verifier: str,
+        *,
+        token_data: dict[str, Any] | None = None,
+    ) -> httpx.Request:
+        request = await super()._exchange_token_authorization_code(
+            auth_code, code_verifier, token_data=token_data
+        )
+        return _without_client_id_when_basic(request)
+
+    async def _refresh_token(self) -> httpx.Request:
+        if self.context.oauth_metadata is None:
+            await self._discover_oauth_metadata()
+        return _without_client_id_when_basic(await super()._refresh_token())
+
+    async def _discover_oauth_metadata(self) -> None:
+        """Populate the resource and authorization-server metadata.
+
+        Mirrors the discovery upstream performs on a 401 (protected resource
+        metadata first, then authorization server metadata, with the same
+        fallback URL lists). A network failure only logs: the refresh then
+        goes to upstream's default endpoint, exactly as before.
+        """
+        server_url = self.context.server_url
+        try:
+            async with self.httpx_client_factory(timeout=_DISCOVERY_TIMEOUT) as client:
+                for url in build_protected_resource_metadata_discovery_urls(
+                    None, server_url
+                ):
+                    response = await client.send(create_oauth_metadata_request(url))
+                    prm = await handle_protected_resource_response(response)
+                    if prm is None:
+                        continue
+                    await self._validate_resource_match(prm)
+                    self.context.protected_resource_metadata = prm
+                    # ``authorization_servers`` has a minimum length of one.
+                    self.context.auth_server_url = str(prm.authorization_servers[0])
+                    break
+
+                for url in build_oauth_authorization_server_metadata_discovery_urls(
+                    self.context.auth_server_url, server_url
+                ):
+                    response = await client.send(create_oauth_metadata_request(url))
+                    ok, metadata = await handle_auth_metadata_response(response)
+                    if not ok:
+                        break
+                    if metadata is not None:
+                        self.context.oauth_metadata = metadata
+                        break
+        except httpx.HTTPError as exc:
+            logger.warning(
+                "OAuth metadata discovery failed for %s; refreshing against the "
+                "default token endpoint: %s",
+                server_url,
+                exc,
+            )
+
+
+class NonInteractiveMCPOAuth(MCPOAuth):
+    """``MCPOAuth`` that only uses the stored tokens and refreshes them.
+
+    When no stored token is usable, FastMCP starts a new authorization: it
+    preflights the authorization URL with a loopback redirect URI, and if the
+    server rejects that URI it clears the token storage and registers a new
+    client before opening a browser. Nobody can complete that flow for an
+    unattended client, so this one fails the connection instead and leaves
+    the stored state for the user to replace by authorizing again.
+    """
+
+    async def redirect_handler(self, authorization_url: str) -> None:  # noqa: ARG002
+        raise MCPError(
+            f"MCP server {self.mcp_url} must be authorized again: its stored "
+            "OAuth tokens are missing or could not be refreshed."
+        )

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/openhands/sdk/mcp/utils.py

@@ -95,6 +95,7 @@ def _oauth_auth_from_authentication_config(
     authentication: MCPOAuthAuthentication | None,
     *,
     mcp_oauth_token_storage: AsyncKeyValue | None = None,
+    mcp_oauth_class: type[MCPOAuth] = MCPOAuth,
 ) -> OAuth | None:
     """Build FastMCP OAuth auth from explicit SDK MCP auth metadata."""
     if authentication is None:
@@ -105,7 +106,7 @@ def _oauth_auth_from_authentication_config(
     if client_auth_method is not None:
         additional_client_metadata["token_endpoint_auth_method"] = client_auth_method
 
-    return MCPOAuth(
+    return mcp_oauth_class(
         scopes=authentication.scopes,
         client_name=authentication.client_name or "FastMCP Client",
         token_storage=mcp_oauth_token_storage,
@@ -169,6 +170,7 @@ def _prepare_mcp_config(
     *,
     mcp_oauth_token_storage: AsyncKeyValue | None = None,
     mcp_oauth_factory: MCPOAuthFactory | None = None,
+    mcp_oauth_class: type[MCPOAuth] = MCPOAuth,
 ) -> FastMCPConfig:
     """Validate MCP config and apply explicit OpenHands runtime auth metadata."""
     prepared = FastMCPConfig.model_validate(to_fastmcp_mcp_config(mcp_config))
@@ -198,12 +200,13 @@ def _prepare_mcp_config(
             else _oauth_auth_from_authentication_config(
                 auth.authentication,
                 mcp_oauth_token_storage=mcp_oauth_token_storage,
+                mcp_oauth_class=mcp_oauth_class,
             )
         )
         if oauth_auth is not None:
             server.auth = oauth_auth
         elif mcp_oauth_token_storage is not None:
-            server.auth = MCPOAuth(token_storage=mcp_oauth_token_storage)
+            server.auth = mcp_oauth_class(token_storage=mcp_oauth_token_storage)
 
     return prepared
 
@@ -377,6 +380,7 @@ def create_mcp_tools(
     on_tools_reconciled: ToolsReconciledCallback | None = None,
     mcp_oauth_token_storage: AsyncKeyValue | None = None,
     mcp_oauth_factory: MCPOAuthFactory | None = None,
+    mcp_oauth_class: type[MCPOAuth] = MCPOAuth,
 ) -> MCPClient:
     """Create MCP tools from OpenHands-native MCP server settings.
 
@@ -408,6 +412,7 @@ def create_mcp_tools(
         mcp_config,
         mcp_oauth_token_storage=mcp_oauth_token_storage,
         mcp_oauth_factory=mcp_oauth_factory,
+        mcp_oauth_class=mcp_oauth_class,
     )
     handler = _ToolListChangedHandler(
         client=None,  # type: ignore[arg-type]

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/openhands/sdk/profiles/agent_profile_store.py

@@ -40,6 +40,15 @@ PROFILE_NAME_REGEX: Final[re.Pattern[str]] = re.compile(PROFILE_NAME_PATTERN)
 logger = get_logger(__name__)
 
 
+def canonical_profile_name(name: str) -> str:
+    """Return the store key for ``name``: a trailing ``.json`` is dropped.
+
+    The file store keys a profile by its file stem, so ``x.json`` and ``x``
+    name the same profile.
+    """
+    return name.removesuffix(".json")
+
+
 class ProfileLimitExceeded(Exception):
     """Raised when saving would exceed the configured profile limit."""
 
@@ -107,7 +116,7 @@ class AgentProfileStore:
         Raises:
             ValueError: If ``name`` does not match ``PROFILE_NAME_PATTERN``.
         """
-        clean_name = name.removesuffix(".json")
+        clean_name = canonical_profile_name(name)
         if not PROFILE_NAME_REGEX.match(clean_name):
             raise ValueError(
                 f"Invalid profile name: {name!r}. "
@@ -153,6 +162,9 @@ class AgentProfileStore:
         """
         profile_path = self._get_profile_path(profile.name)
         payload = profile.model_dump(mode="json")
+        # Keep the stored name equal to the file stem (as ``rename`` does), so
+        # ``x.json`` and ``x`` are one profile with one name.
+        payload["name"] = profile_path.stem
 
         with self._acquire_lock():
             if max_profiles is not None and not profile_path.exists():
@@ -420,6 +432,9 @@ def save_profile_preserving_identity(
     Raises:
         ProfileLimitExceeded: If ``max_profiles`` would be exceeded.
     """
+    name = canonical_profile_name(profile.name)
+    if name != profile.name:
+        profile = profile.model_copy(update={"name": name})
     with store.lock():
         existing_id, existing_rev = _existing_identity(store, profile.name)
         if existing_id is not None:

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/openhands/sdk/utils/command.py

@@ -13,16 +13,17 @@ from openhands.sdk.utils.redact import redact_text_secrets
 logger = get_logger(__name__)
 
 
-# Env vars that should not be exposed to subprocesses (e.g., bash commands
-# executed by the agent). These credentials allow access to user secrets via
-# the SaaS API and/or decrypting persisted secrets, and must remain isolated to
-# the SDK's Python process.
-#
-# - ``SESSION_API_KEY``: legacy (V0) session key name.
-# - ``OH_SECRET_KEY``: cipher key that decrypts persisted conversation/provider
-#   secrets; leaking it is at least as damaging as leaking the session key.
-# See ``openhands.agent_server.config`` for where these are read from the env.
-_SENSITIVE_ENV_VARS = frozenset({"SESSION_API_KEY", "OH_SECRET_KEY"})
+# Credentials needed by the SDK/server, not by agent-run subprocesses.
+_SENSITIVE_ENV_VARS = frozenset(
+    {
+        "SESSION_API_KEY",
+        "OH_SECRET_KEY",
+        "LMNR_PROJECT_API_KEY",
+        "OTEL_HEADERS",
+        "OTEL_EXPORTER_OTLP_HEADERS",
+        "OTEL_EXPORTER_OTLP_TRACES_HEADERS",
+    }
+)
 
 # Session keys are also delivered as an indexed list ``OH_SESSION_API_KEYS_0``,
 # ``OH_SESSION_API_KEYS_1``, ... (V1). Strip every slot by prefix so a rename or

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/openhands/sdk/utils/models.py

@@ -43,6 +43,12 @@ def _is_abstract(type_: type) -> bool:
         return False
 
 
+def _is_object_input(data: Any, cls: type) -> bool:
+    """Whether ``data`` is a dict or an instance of ``cls`` (a bool, so that
+    pyright does not narrow ``data`` at the call site)."""
+    return isinstance(data, (dict, cls))
+
+
 def get_handler_class_name(handler: SerializerFunctionWrapHandler) -> str:
     """Extract the class name from a Pydantic serializer handler's repr string.
 
@@ -209,8 +215,16 @@ class DiscriminatedUnionMixin(OpenHandsModel):
     def _validate_subtype(
         cls, data: Any, handler: ModelWrapValidatorHandler[Self], info: ValidationInfo
     ) -> Self:
+        if not _is_object_input(data, cls):
+            # Let pydantic report a non-object input (a string, number, null,
+            # list...) as a ValidationError instead of failing on .pop().
+            return handler(data)
         if isinstance(data, cls):
             return data
+        if isinstance(data, dict):
+            # Never mutate the caller's dict: callers such as RemoteState
+            # validate the same cached payload more than once.
+            data = dict(data)
         if not _is_abstract(cls):
             has_kind_alias_field = any(
                 field_name != "kind" and field_info.alias == "kind"
@@ -229,7 +243,6 @@ class DiscriminatedUnionMixin(OpenHandsModel):
                         None,
                     )
                     if internal_kind_field in data:
-                        data = data.copy()
                         data.pop("kind", None)
                 return handler(data)
             kind = data.pop("kind", None)

{openhands_sdk-1.57.0 → openhands_sdk-1.58.0}/openhands/sdk/workspace/remote/base.py

@@ -634,8 +634,8 @@ class RemoteWorkspace(RemoteWorkspaceMixin, BaseWorkspace):
 
         Clones specified repositories to meaningful directory names (e.g.,
         'openhands-cli' instead of 'repo_0'). Automatically fetches GitHub,
-        GitLab, and Bitbucket tokens from the agent server's secrets for
-        authentication.
+        GitLab, Bitbucket and Azure DevOps tokens from the agent server's
+        secrets for authentication.
 
         Args:
             repos: List of repositories to clone. Can be: