openhands-sdk 1.49.3__tar.gz → 1.49.5__tar.gz

{openhands_sdk-1.49.3 → openhands_sdk-1.49.5}/PKG-INFO

@@ -1,20 +1,20 @@
 Metadata-Version: 2.4
 Name: openhands-sdk
-Version: 1.49.3
+Version: 1.49.5
 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
 Project-URL: Documentation, https://docs.openhands.dev/sdk
 Project-URL: Bug Tracker, https://github.com/OpenHands/software-agent-sdk/issues
 Requires-Python: >=3.12
-Requires-Dist: agent-client-protocol<0.11.0,>=0.10.1
+Requires-Dist: agent-client-protocol<0.13.0,>=0.12.1
 Requires-Dist: deprecation>=2.1.0
 Requires-Dist: fakeredis[lua]>=2.32.1
 Requires-Dist: fastmcp<4,>=3.2.0
 Requires-Dist: filelock>=3.20.1
 Requires-Dist: httpx[socks]>=0.27.0
 Requires-Dist: jsonschema>=4.23.0
-Requires-Dist: joserfc>=1.6.8
+Requires-Dist: joserfc>=1.7.5
 Requires-Dist: litellm>=1.93.0
 Requires-Dist: pillow>=12.3.0
 Requires-Dist: pydantic>=2.12.5

{openhands_sdk-1.49.3 → openhands_sdk-1.49.5}/openhands/sdk/agent/acp_agent.py

@@ -43,21 +43,34 @@ from acp.client.connection import ClientSideConnection
 from acp.exceptions import RequestError as ACPRequestError
 from acp.helpers import image_block, text_block
 from acp.schema import (
+    AcpMcpServer,
     AgentMessageChunk,
     AgentThoughtChunk,
     AllowedOutcome,
+    CreateElicitationResponse,
+    CreateTerminalResponse,
+    DeclineElicitationResponse,
+    ElicitationMode,
     EnvVariable,
     HttpHeader,
     HttpMcpServer,
     ImageContentBlock,
+    KillTerminalResponse,
     McpServerStdio,
+    PermissionOption,
     PromptResponse,
+    ReadTextFileResponse,
+    ReleaseTerminalResponse,
     RequestPermissionResponse,
     SseMcpServer,
+    TerminalOutputResponse,
     TextContentBlock,
     ToolCallProgress,
     ToolCallStart,
+    ToolCallUpdate,
     UsageUpdate,
+    WaitForTerminalExitResponse,
+    WriteTextFileResponse,
 )
 from acp.transports import default_environment
 from pydantic import (
@@ -617,14 +630,23 @@ async def _apply_acp_model(
     Codex, callers may still pass a combined Canvas id such as ``gpt-5.5/high``;
     codex-acp exposes reasoning effort as a separate config option, so split it
     only on the config-options mechanism.
+
+    agent-client-protocol 0.12.1 dropped the UNSTABLE ``models`` extension from
+    the ACP schema and removed ``ClientSideConnection.set_session_model``. A live
+    0.12 connection therefore has no legacy RPC to call, so the ``else`` branch
+    only invokes it when the connection actually exposes the method (test
+    doubles do; real 0.12 connections do not) and otherwise no-ops rather than
+    raising ``AttributeError``.
     """
     if via_config_option:
         for config_id, value in _model_config_options(agent_name, model):
             await conn.set_config_option(
                 config_id=config_id, value=value, session_id=session_id
             )
-    else:
-        await conn.set_session_model(model_id=model, session_id=session_id)
+    elif hasattr(conn, "set_session_model"):
+        await conn.set_session_model(  # type: ignore[attr-defined]
+            model_id=model, session_id=session_id
+        )
 
 
 def _usable_models(infos: Iterable[ACPModelInfo]) -> list[ACPModelInfo]:
@@ -689,7 +711,7 @@ def _extract_session_models(
 
 
 # The ACP MCP server union accepted by new_session() / load_session().
-_ACPMcpServer = HttpMcpServer | SseMcpServer | McpServerStdio
+_ACPMcpServer = HttpMcpServer | SseMcpServer | McpServerStdio | AcpMcpServer
 
 
 def _remote_mcp_headers(server: MCPServer, name: str) -> list[HttpHeader]:
@@ -1579,11 +1601,11 @@ class _OpenHandsACPBridge:
 
     async def request_permission(
         self,
-        options: list[Any],
         session_id: str,  # noqa: ARG002
-        tool_call: Any,
+        tool_call: ToolCallUpdate,
+        options: list[PermissionOption],
         **kwargs: Any,  # noqa: ARG002
-    ) -> Any:
+    ) -> RequestPermissionResponse:
         """Auto-approve all permission requests from the ACP server."""
         # Pick the first option (usually "allow once")
         option_id = options[0].option_id if options else "allow_once"
@@ -1596,52 +1618,74 @@ class _OpenHandsACPBridge:
             outcome=AllowedOutcome(outcome="selected", option_id=option_id),
         )
 
+    async def create_elicitation(
+        self,
+        message: str,  # noqa: ARG002
+        mode: ElicitationMode,  # noqa: ARG002
+        **kwargs: Any,  # noqa: ARG002
+    ) -> CreateElicitationResponse:
+        """Decline elicitation requests; the headless bridge has no user to ask.
+
+        Added to the ``Client`` protocol in agent-client-protocol 0.12.x. None
+        of the pinned ACP providers elicit during a headless turn, so this is a
+        defensive default rather than an exercised code path.
+        """
+        return DeclineElicitationResponse(action="decline")
+
+    async def complete_elicitation(
+        self,
+        elicitation_id: str,  # noqa: ARG002
+        **kwargs: Any,  # noqa: ARG002
+    ) -> None:
+        """No-op completion for an elicitation the bridge always declines."""
+        return None
+
     # fs/terminal methods — raise NotImplementedError; ACP server handles its own
     async def write_text_file(
-        self, content: str, path: str, session_id: str, **kwargs: Any
-    ) -> None:
+        self, session_id: str, path: str, content: str, **kwargs: Any
+    ) -> WriteTextFileResponse | None:
         raise NotImplementedError("ACP server handles file operations")
 
     async def read_text_file(
         self,
-        path: str,
         session_id: str,
-        limit: int | None = None,
+        path: str,
         line: int | None = None,
+        limit: int | None = None,
         **kwargs: Any,
-    ) -> Any:
+    ) -> ReadTextFileResponse:
         raise NotImplementedError("ACP server handles file operations")
 
     async def create_terminal(
         self,
-        command: str,
         session_id: str,
+        command: str,
         args: list[str] | None = None,
+        env: list[EnvVariable] | None = None,
         cwd: str | None = None,
-        env: Any = None,
         output_byte_limit: int | None = None,
         **kwargs: Any,
-    ) -> Any:
+    ) -> CreateTerminalResponse:
         raise NotImplementedError("ACP server handles terminal operations")
 
     async def terminal_output(
         self, session_id: str, terminal_id: str, **kwargs: Any
-    ) -> Any:
+    ) -> TerminalOutputResponse:
         raise NotImplementedError("ACP server handles terminal operations")
 
     async def release_terminal(
         self, session_id: str, terminal_id: str, **kwargs: Any
-    ) -> None:
+    ) -> ReleaseTerminalResponse | None:
         raise NotImplementedError("ACP server handles terminal operations")
 
     async def wait_for_terminal_exit(
         self, session_id: str, terminal_id: str, **kwargs: Any
-    ) -> Any:
+    ) -> WaitForTerminalExitResponse:
         raise NotImplementedError("ACP server handles terminal operations")
 
     async def kill_terminal(
         self, session_id: str, terminal_id: str, **kwargs: Any
-    ) -> None:
+    ) -> KillTerminalResponse | None:
         raise NotImplementedError("ACP server handles terminal operations")
 
     async def ext_method(

{openhands_sdk-1.49.3 → openhands_sdk-1.49.5}/openhands/sdk/context/view/properties/tool_call_matching.py

@@ -64,8 +64,9 @@ class ToolCallMatchingProperty(ViewPropertyBase):
     ) -> ManipulationIndices:
         """Calculate manipulation indices for tool call matching.
 
-        This property is maintained by ensuring there are no manipulation indices
-        between action events and their paired observation event.
+        Indices between an action and its matching observation are protected.
+        Observation-like events without a pending action do not affect boundaries;
+        property enforcement separately removes orphaned and duplicate observations.
         """
         # Start with a complete set of manipulation indices, then we'll remove those
         # between actions and their paired observations.
@@ -84,13 +85,7 @@ class ToolCallMatchingProperty(ViewPropertyBase):
                 case ActionEvent():
                     pending_tool_call_ids.add(event.tool_call_id)
                 case ObservationBaseEvent():
-                    # Intentionally use remove(), not discard(): a second
-                    # observation-like event for the same tool_call_id means the
-                    # view has already violated the 1 action -> 1 result
-                    # invariant that downstream LLM APIs expect. That case must
-                    # be fixed by de-duplicating the view before serialization,
-                    # not by silently tolerating it here.
-                    pending_tool_call_ids.remove(event.tool_call_id)
+                    pending_tool_call_ids.discard(event.tool_call_id)
 
             if pending_tool_call_ids:
                 # The enumeration index corresponds to the position of the event, but we

{openhands_sdk-1.49.3 → openhands_sdk-1.49.5}/openhands/sdk/conversation/secret_registry.py

@@ -11,6 +11,7 @@ from pydantic import BaseModel, Field, PrivateAttr, SecretStr
 
 from openhands.sdk.logger import get_logger
 from openhands.sdk.secret import SecretSource, SecretValue, StaticSecret
+from openhands.sdk.utils.masking import PreserveDataUrls, SkipSecretMasking
 from openhands.sdk.utils.models import OpenHandsModel
 
 
@@ -20,8 +21,14 @@ logger = get_logger(__name__)
 FAILED_LOOKUP_RETRY_SECONDS: Final[float] = 60.0
 
 
-def _mask_value(value: Any, mask: Callable[[str], str]) -> Any:
-    """Recursively mask every ``str`` reachable from ``value``."""
+def _mask_value(
+    value: Any,
+    mask: Callable[[str], str],
+    *,
+    skip_secret_masking: bool = False,
+    preserve_data_urls: bool = False,
+) -> Any:
+    """Recursively mask strings, respecting opaque payload field metadata."""
     match value:
         case Enum():
             # A str-subclass enum is a str, but masking it would downgrade the
@@ -29,20 +36,56 @@ def _mask_value(value: Any, mask: Callable[[str], str]) -> Any:
             # vocabulary is fixed, so it can never hold a secret anyway.
             return value
         case str():
+            if skip_secret_masking:
+                return value
+            if preserve_data_urls and value.startswith("data:") and ";base64," in value:
+                return value
             return mask(value)
         case BaseModel():
             return _mask_model(value, mask)
         case list():
-            return [_mask_value(item, mask) for item in value]
+            return [
+                _mask_value(
+                    item,
+                    mask,
+                    skip_secret_masking=skip_secret_masking,
+                    preserve_data_urls=preserve_data_urls,
+                )
+                for item in value
+            ]
         case tuple():
-            items = [_mask_value(item, mask) for item in value]
+            items = [
+                _mask_value(
+                    item,
+                    mask,
+                    skip_secret_masking=skip_secret_masking,
+                    preserve_data_urls=preserve_data_urls,
+                )
+                for item in value
+            ]
             # Rebuild a NamedTuple through its own constructor; tuple(items)
             # would downgrade it the same way masking an Enum member does.
             return type(value)(*items) if hasattr(value, "_fields") else tuple(items)
         case set() | frozenset():
-            return type(value)(_mask_value(item, mask) for item in value)
+            return type(value)(
+                _mask_value(
+                    item,
+                    mask,
+                    skip_secret_masking=skip_secret_masking,
+                    preserve_data_urls=preserve_data_urls,
+                )
+                for item in value
+            )
         case dict():
-            return {key: _mask_value(item, mask) for key, item in value.items()}
+            return {
+                key: _mask_value(
+                    item,
+                    mask,
+                    skip_secret_masking=skip_secret_masking,
+                    preserve_data_urls=preserve_data_urls,
+                )
+                for key, item in value.items()
+            }
         case _:
             return value
 
@@ -53,10 +96,21 @@ def _mask_model[ModelT: BaseModel](model: ModelT, mask: Callable[[str], str]) ->
     ``model_copy`` is used rather than a validate round-trip so private
     attributes survive and no field is re-coerced.
     """
-    updates = {
-        name: _mask_value(getattr(model, name), mask)
-        for name in type(model).model_fields
-    }
+    updates = {}
+    for name, field in type(model).model_fields.items():
+        metadata = field.metadata
+        skip_secret_masking = any(
+            isinstance(item, SkipSecretMasking) for item in metadata
+        )
+        preserve_data_urls = any(
+            isinstance(item, PreserveDataUrls) for item in metadata
+        )
+        updates[name] = _mask_value(
+            getattr(model, name),
+            mask,
+            skip_secret_masking=skip_secret_masking,
+            preserve_data_urls=preserve_data_urls,
+        )
     return model.model_copy(update=updates)
 
 

{openhands_sdk-1.49.3 → openhands_sdk-1.49.5}/openhands/sdk/extensions/installation/metadata.py

@@ -150,7 +150,7 @@ class InstallationMetadata(BaseModel):
             return cls()
 
         try:
-            return cls.model_validate_json(metadata_path.read_text())
+            return cls.model_validate_json(metadata_path.read_text(encoding="utf-8"))
         except Exception as e:
             logger.warning(f"Failed to load installed extension metadata: {e}")
             return cls()
@@ -159,7 +159,7 @@ class InstallationMetadata(BaseModel):
         """Save metadata to the installed extensions directory."""
         metadata_path = self.get_metadata_path(installed_dir)
         metadata_path.parent.mkdir(parents=True, exist_ok=True)
-        metadata_path.write_text(self.model_dump_json(indent=2))
+        metadata_path.write_text(self.model_dump_json(indent=2), encoding="utf-8")
 
     def validate_tracked(self, installed_dir: Path) -> list[InstallationInfo]:
         """Validate tracked extensions exist on disk.

{openhands_sdk-1.49.3 → openhands_sdk-1.49.5}/openhands/sdk/llm/message.py

@@ -1,7 +1,7 @@
 import json
 from abc import abstractmethod
 from collections.abc import Sequence
-from typing import Any, ClassVar, Literal
+from typing import Annotated, Any, ClassVar, Literal
 
 from litellm import ChatCompletionMessageToolCall, ResponseFunctionToolCall
 from litellm.types.responses.main import (
@@ -16,6 +16,7 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator, model_valida
 from openhands.sdk.logger import get_logger
 from openhands.sdk.utils import DEFAULT_TEXT_CONTENT_LIMIT, maybe_truncate
 from openhands.sdk.utils.deprecation import handle_deprecated_model_fields
+from openhands.sdk.utils.masking import PreserveDataUrls
 
 
 logger = get_logger(__name__)
@@ -203,7 +204,7 @@ class TextContent(BaseContent):
 
 class ImageContent(BaseContent):
     type: Literal["image"] = "image"
-    image_urls: list[str]
+    image_urls: Annotated[list[str], PreserveDataUrls()]
 
     def to_llm_dict(self) -> list[dict[str, str | dict[str, str]]]:
         """Convert to LLM API format."""

{openhands_sdk-1.49.3 → openhands_sdk-1.49.5}/openhands/sdk/llm/utils/model_features.py

@@ -109,6 +109,7 @@ def _normalized_supported_openai_params(model: str | None) -> frozenset[str]:
 
 
 REASONING_EFFORT_MODEL_OVERRIDES = {
+    "gpt-5.2-codex": "gpt-5.2-codex",
     "kimi-k3": "moonshot/kimi-k3",
 }
 
@@ -188,9 +189,15 @@ SUPPORTS_STOP_WORDS_FALSE_MODELS: list[str] = [
 ]
 
 # Models that should use the OpenAI Responses API path by default
+# NOTE: model_matches uses case-insensitive substring matching, so a bare family
+# token like "gpt-5" / "gpt-6" covers all variants (mini, sol, luna, astra, ...).
 RESPONSES_API_MODELS: list[str] = [
     # OpenAI GPT-5 family (includes mini variants)
     "gpt-5",
+    # OpenAI GPT-6 family (gpt-6-sol, gpt-6-luna, gpt-6-astra, ...). These reject
+    # function tools + reasoning_effort on /v1/chat/completions; /v1/responses
+    # supports both. See saas-deploy #1144.
+    "gpt-6",
     # OpenAI Codex (uses Responses API)
     "codex-mini-latest",
 ]