openhands-sdk 1.7.2__py3-none-any.whl → 1.7.4__py3-none-any.whl

openhands/sdk/conversation/impl/remote_conversation.py

@@ -28,6 +28,7 @@ from openhands.sdk.conversation.visualizer import (
     DefaultConversationVisualizer,
 )
 from openhands.sdk.event.base import Event
+from openhands.sdk.event.conversation_error import ConversationErrorEvent
 from openhands.sdk.event.conversation_state import (
     FULL_STATE_KEY,
     ConversationStateUpdateEvent,
@@ -488,7 +489,28 @@ class RemoteConversation(BaseConversation):
         self._hook_processor = None
         self._cleanup_initiated = False
 
-        if conversation_id is None:
+        should_create = conversation_id is None
+        if conversation_id is not None:
+            # Try to attach to existing conversation
+            resp = _send_request(
+                self._client,
+                "GET",
+                f"/api/conversations/{conversation_id}",
+                acceptable_status_codes={404},
+            )
+            if resp.status_code == 404:
+                # Conversation doesn't exist, we'll create it
+                should_create = True
+            else:
+                # Conversation exists, use the provided ID
+                self._id = conversation_id
+
+        if should_create:
+            # Import here to avoid circular imports
+            from openhands.sdk.tool.registry import get_tool_module_qualnames
+
+            tool_qualnames = get_tool_module_qualnames()
+            logger.debug(f"Sending tool_module_qualnames to server: {tool_qualnames}")
             payload = {
                 "agent": agent.model_dump(
                     mode="json", context={"expose_secrets": True}
@@ -500,6 +522,8 @@ class RemoteConversation(BaseConversation):
                 "workspace": LocalWorkspace(
                     working_dir=self.workspace.working_dir
                 ).model_dump(),
+                # Include tool module qualnames for dynamic registration on server
+                "tool_module_qualnames": tool_qualnames,
             }
             if stuck_detection_thresholds is not None:
                 # Convert to StuckDetectionThresholds if dict, then serialize
@@ -510,6 +534,9 @@ class RemoteConversation(BaseConversation):
                 else:
                     threshold_config = stuck_detection_thresholds
                 payload["stuck_detection_thresholds"] = threshold_config.model_dump()
+            # Include conversation_id if provided (for creating with specific ID)
+            if conversation_id is not None:
+                payload["conversation_id"] = str(conversation_id)
             resp = _send_request(
                 self._client, "POST", "/api/conversations", json=payload
             )
@@ -521,11 +548,6 @@ class RemoteConversation(BaseConversation):
                     "Invalid response from server: missing conversation id"
                 )
             self._id = uuid.UUID(cid)
-        else:
-            # Attach to existing
-            self._id = conversation_id
-            # Validate it exists
-            _send_request(self._client, "GET", f"/api/conversations/{self._id}")
 
         # Initialize the remote state
         self._state = RemoteState(self._client, str(self._id))
@@ -711,12 +733,8 @@ class RemoteConversation(BaseConversation):
 
         if resp.status_code == 409:
             logger.info("Conversation is already running; skipping run trigger")
-            if blocking:
-                # Still wait for the existing run to complete
-                self._wait_for_run_completion(poll_interval, timeout)
-            return
-
-        logger.info(f"run() triggered successfully: {resp}")
+        else:
+            logger.info(f"run() triggered successfully: {resp}")
 
         if blocking:
             self._wait_for_run_completion(poll_interval, timeout)
@@ -733,7 +751,9 @@ class RemoteConversation(BaseConversation):
             timeout: Maximum time in seconds to wait.
 
         Raises:
-            ConversationRunError: If the wait times out.
+            ConversationRunError: If the run fails, the conversation disappears,
+                or the wait times out. Transient network errors, 429s, and 5xx
+                responses are retried until timeout.
         """
         start_time = time.monotonic()
 
@@ -749,28 +769,89 @@ class RemoteConversation(BaseConversation):
                 )
 
             try:
-                resp = _send_request(
-                    self._client,
-                    "GET",
-                    f"/api/conversations/{self._id}",
-                    timeout=30,
-                )
-                info = resp.json()
-                status = info.get("execution_status")
-
-                if status != ConversationExecutionStatus.RUNNING.value:
+                status = self._poll_status_once()
+            except Exception as exc:
+                self._handle_poll_exception(exc)
+            else:
+                if self._handle_conversation_status(status):
                     logger.info(
-                        f"Run completed with status: {status} (elapsed: {elapsed:.1f}s)"
+                        "Run completed with status: %s (elapsed: %.1fs)",
+                        status,
+                        elapsed,
                     )
                     return
 
-            except Exception as e:
-                # Log but continue polling - transient network errors shouldn't
-                # stop us from waiting for the run to complete
-                logger.warning(f"Error polling status (will retry): {e}")
-
             time.sleep(poll_interval)
 
+    def _poll_status_once(self) -> str | None:
+        """Fetch the current execution status from the remote conversation."""
+        resp = _send_request(
+            self._client,
+            "GET",
+            f"/api/conversations/{self._id}",
+            timeout=30,
+        )
+        info = resp.json()
+        return info.get("execution_status")
+
+    def _handle_conversation_status(self, status: str | None) -> bool:
+        """Handle non-running statuses; return True if the run is complete."""
+        if status == ConversationExecutionStatus.RUNNING.value:
+            return False
+        if status == ConversationExecutionStatus.ERROR.value:
+            detail = self._get_last_error_detail()
+            raise ConversationRunError(
+                self._id,
+                RuntimeError(detail or "Remote conversation ended with error"),
+            )
+        if status == ConversationExecutionStatus.STUCK.value:
+            raise ConversationRunError(
+                self._id,
+                RuntimeError("Remote conversation got stuck"),
+            )
+        return True
+
+    def _handle_poll_exception(self, exc: Exception) -> None:
+        """Classify polling exceptions into retryable vs terminal failures."""
+        if isinstance(exc, httpx.HTTPStatusError):
+            status_code = exc.response.status_code
+            reason = exc.response.reason_phrase
+            if status_code == 404:
+                raise ConversationRunError(
+                    self._id,
+                    RuntimeError(
+                        "Remote conversation not found (404). "
+                        "The runtime may have been deleted."
+                    ),
+                ) from exc
+            if 400 <= status_code < 500 and status_code != 429:
+                raise ConversationRunError(
+                    self._id,
+                    RuntimeError(f"Polling failed with HTTP {status_code} {reason}"),
+                ) from exc
+            logger.warning(
+                "Error polling status (will retry): HTTP %d %s",
+                status_code,
+                reason,
+            )
+            return
+        if isinstance(exc, httpx.RequestError):
+            logger.warning(f"Error polling status (will retry): {exc}")
+            return
+        raise ConversationRunError(self._id, exc) from exc
+
+    def _get_last_error_detail(self) -> str | None:
+        """Return the most recent ConversationErrorEvent detail, if available."""
+        events = self._state.events
+        for idx in range(len(events) - 1, -1, -1):
+            event = events[idx]
+            if isinstance(event, ConversationErrorEvent):
+                detail = event.detail.strip()
+                code = event.code.strip()
+                if detail and code:
+                    return f"{code}: {detail}"
+                return detail or code or None
+
     def set_confirmation_policy(self, policy: ConfirmationPolicyBase) -> None:
         payload = {"policy": policy.model_dump()}
         _send_request(

openhands/sdk/conversation/state.py

@@ -133,7 +133,6 @@ class ConversationState(OpenHandsModel):
         default_factory=FIFOLock
     )  # FIFO lock for thread safety
 
-    # ===== Public "events" facade (Sequence[Event]) =====
     @property
     def events(self) -> EventLog:
         return self._events
@@ -200,12 +199,17 @@ class ConversationState(OpenHandsModel):
                     f"but persisted state has {state.id}"
                 )
 
-            # Reconcile agent config with deserialized one
-            resolved = agent.resolve_diff_from_deserialized(state.agent)
-
-            # Attach runtime handles and commit reconciled agent (may autosave)
+            # Attach event log early so we can read history
             state._fs = file_store
             state._events = EventLog(file_store, dir_path=EVENTS_DIR)
+
+            # Reconcile agent config with deserialized one
+            # Pass event log so tool usage can be checked on-the-fly if needed
+            resolved = agent.resolve_diff_from_deserialized(
+                state.agent, events=state._events
+            )
+
+            # Commit reconciled agent (may autosave)
             state._autosave_enabled = True
             state.agent = resolved
 

openhands/sdk/llm/llm.py

@@ -158,7 +158,6 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
     top_p: float | None = Field(default=1.0, ge=0, le=1)
     top_k: float | None = Field(default=None, ge=0)
 
-    custom_llm_provider: str | None = Field(default=None)
     max_input_tokens: int | None = Field(
         default=None,
         ge=1,
@@ -342,7 +341,7 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
     _telemetry: Telemetry | None = PrivateAttr(default=None)
 
     model_config: ClassVar[ConfigDict] = ConfigDict(
-        extra="forbid", arbitrary_types_allowed=True
+        extra="ignore", arbitrary_types_allowed=True
     )
 
     # =========================================================================

openhands/sdk/llm/options/chat_options.py

@@ -51,9 +51,12 @@ def select_chat_options(
     # Extended thinking models
     if get_features(llm.model).supports_extended_thinking:
         if llm.extended_thinking_budget:
+            # Anthropic throws errors if thinking budget equals or exceeds max output
+            # tokens -- force the thinking budget lower if there's a conflict
+            budget_tokens = min(llm.extended_thinking_budget, llm.max_output_tokens - 1)
             out["thinking"] = {
                 "type": "enabled",
-                "budget_tokens": llm.extended_thinking_budget,
+                "budget_tokens": budget_tokens,
             }
             # Enable interleaved thinking
             # Merge default header with any user-provided headers; user wins on conflict

openhands/sdk/llm/utils/model_features.py

@@ -152,6 +152,7 @@ FORCE_STRING_SERIALIZER_MODELS: list[str] = [
 # in the message input
 SEND_REASONING_CONTENT_MODELS: list[str] = [
     "kimi-k2-thinking",
+    "openrouter/minimax-m2",  # MiniMax-M2 via OpenRouter (interleaved thinking)
     "deepseek/deepseek-reasoner",
 ]
 

openhands/sdk/llm/utils/verified_models.py

@@ -50,7 +50,7 @@ VERIFIED_OPENHANDS_MODELS = [
     "gpt-5.1-codex",
     "gpt-5.1",
     "gemini-3-pro-preview",
-    "deekseek-chat",
+    "deepseek-chat",
     "kimi-k2-thinking",
     "devstral-medium-2512",
     "devstral-2512",

openhands/sdk/mcp/tool.py

@@ -186,7 +186,9 @@ class MCPToolDefinition(ToolDefinition[MCPToolAction, MCPToolObservation]):
         # Use exclude_none to avoid injecting nulls back to the call
         # Exclude DiscriminatedUnionMixin fields (e.g., 'kind') as they're
         # internal to OpenHands and not part of the MCP tool schema
-        exclude_fields = set(DiscriminatedUnionMixin.model_fields.keys())
+        exclude_fields = set(DiscriminatedUnionMixin.model_fields.keys()) | set(
+            DiscriminatedUnionMixin.model_computed_fields.keys()
+        )
         sanitized = validated.model_dump(exclude_none=True, exclude=exclude_fields)
         return MCPToolAction(data=sanitized)
 

openhands/sdk/tool/registry.py

@@ -29,6 +29,7 @@ Returns: A sequence of ToolDefinition instances. Most of the time this will be a
 
 _LOCK = RLock()
 _REG: dict[str, Resolver] = {}
+_MODULE_QUALNAMES: dict[str, str] = {}  # Maps tool name to module qualname
 
 
 def _resolver_from_instance(name: str, tool: ToolDefinition) -> Resolver:
@@ -137,11 +138,22 @@ def register_tool(
             "(3) a callable factory returning a Sequence[ToolDefinition]"
         )
 
+    # Track the module qualname for this tool
+    module_qualname = None
+    if isinstance(factory, type):
+        module_qualname = factory.__module__
+    elif callable(factory):
+        module_qualname = getattr(factory, "__module__", None)
+    elif isinstance(factory, ToolDefinition):
+        module_qualname = factory.__class__.__module__
+
     with _LOCK:
         # TODO: throw exception when registering duplicate name tools
         if name in _REG:
             logger.warning(f"Duplicate tool name registerd {name}")
         _REG[name] = resolver
+        if module_qualname:
+            _MODULE_QUALNAMES[name] = module_qualname
 
 
 def resolve_tool(
@@ -159,3 +171,14 @@ def resolve_tool(
 def list_registered_tools() -> list[str]:
     with _LOCK:
         return list(_REG.keys())
+
+
+def get_tool_module_qualnames() -> dict[str, str]:
+    """Get a mapping of tool names to their module qualnames.
+
+    Returns:
+        A dictionary mapping tool names to module qualnames (e.g.,
+        {"glob": "openhands.tools.glob.definition"}).
+    """
+    with _LOCK:
+        return dict(_MODULE_QUALNAMES)

openhands/sdk/tool/schema.py

@@ -121,9 +121,12 @@ class Schema(DiscriminatedUnionMixin):
         # so it is fully compatible with MCP tool schema
         result = _process_schema_node(full_schema, full_schema.get("$defs", {}))
 
-        # Remove 'kind' from properties if present (discriminator field, not for LLM)
-        EXCLUDE_FIELDS = DiscriminatedUnionMixin.model_fields.keys()
-        for f in EXCLUDE_FIELDS:
+        # Remove discriminator fields from properties (not for LLM)
+        # Need to exclude both regular fields and computed fields (like 'kind')
+        exclude_fields = set(DiscriminatedUnionMixin.model_fields.keys()) | set(
+            DiscriminatedUnionMixin.model_computed_fields.keys()
+        )
+        for f in exclude_fields:
             if "properties" in result and f in result["properties"]:
                 result["properties"].pop(f)
                 # Also remove from required if present