openhands-sdk 1.27.0__tar.gz → 1.28.0__tar.gz

{openhands_sdk-1.27.0 → openhands_sdk-1.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-sdk
-Version: 1.27.0
+Version: 1.28.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.27.0 → openhands_sdk-1.28.0}/openhands/sdk/agent/acp_agent.py

@@ -509,15 +509,19 @@ async def _maybe_set_session_model(
     use the protocol call for initial selection (codex-acp, gemini-cli) get a
     one-shot ``set_session_model`` call here.
 
+    For unknown/custom providers (e.g. Devin CLI), we fall back to the generic
+    ``set_config_option`` method with configId="model", which is a standard ACP
+    method that many custom ACP servers support.
+
     Runtime, mid-conversation switches go through
     :meth:`ACPAgent.set_acp_model` instead, which always uses
     ``set_session_model`` and is gated on the separate
     ``supports_runtime_model_switch`` capability flag.
 
-    Returns ``True`` only when this issued a ``set_session_model`` call — i.e.
+    Returns ``True`` only when this issued a model-setting call that succeeded — i.e.
     the override was actually pushed to the server via *this* path. ``False``
     when there is nothing to apply (no ``acp_model``) or the provider selects
-    its model another way (``_meta``) or not at all (unknown/custom server), so
+    its model another way (``_meta``) or the server rejected the call, so
     the caller can tell whether the live session is really running ``acp_model``.
     """
     if not acp_model:
@@ -526,6 +530,29 @@ async def _maybe_set_session_model(
     if provider is not None and provider.supports_set_session_model:
         await conn.set_session_model(model_id=acp_model, session_id=session_id)
         return True
+    # For unknown/custom providers, try the generic set_config_option method
+    # which is a standard ACP protocol method for setting configuration options
+    if provider is None:
+        try:
+            await conn.set_config_option(
+                config_id="model",
+                value=acp_model,
+                session_id=session_id,
+            )
+            logger.info(
+                "Set model %r on unknown/custom ACP server %s via set_config_option",
+                acp_model,
+                agent_name,
+            )
+            return True
+        except ACPRequestError as e:
+            logger.warning(
+                "Could not set model %r on unknown/custom ACP server %s via "
+                "set_config_option (%s); the session will use the server default",
+                acp_model,
+                agent_name,
+                e,
+            )
     return False
 
 
@@ -542,6 +569,10 @@ async def _reapply_session_model_on_resume(
     the ACP server's default. This issues ``set_session_model`` so the resumed
     live session matches the serialized ``acp_model``.
 
+    For unknown/custom providers (e.g. Devin CLI), we fall back to the generic
+    ``set_config_option`` method with configId="model", which is a standard ACP
+    method that many custom ACP servers support.
+
     The gating mirrors :meth:`ACPAgent.set_acp_model` (attempt for custom/unknown
     servers and known providers that support runtime switching; skip only known
     providers that don't), deliberately differing from the initial-selection
@@ -550,7 +581,7 @@ async def _reapply_session_model_on_resume(
     tolerated (logged) — like the ``load_session`` fallback above — so resume
     can't break; the session keeps the server default until the next switch.
 
-    Returns ``True`` only when ``set_session_model`` was issued and accepted, so
+    Returns ``True`` only when a model-setting call was issued and accepted, so
     the caller knows the resumed live session is actually running ``acp_model``.
     ``False`` when there is nothing to reapply, the provider doesn't support the
     switch, or the server rejected the call (swallowed) — in those cases the
@@ -563,7 +594,22 @@ async def _reapply_session_model_on_resume(
     if provider is not None and not provider.supports_runtime_model_switch:
         return False
     try:
-        await conn.set_session_model(model_id=acp_model, session_id=session_id)
+        if provider is not None:
+            # Known provider: use set_session_model
+            await conn.set_session_model(model_id=acp_model, session_id=session_id)
+        else:
+            # Unknown/custom provider: try set_config_option as fallback
+            await conn.set_config_option(
+                config_id="model",
+                value=acp_model,
+                session_id=session_id,
+            )
+            logger.info(
+                "Reapplied model %r on unknown/custom ACP server %s "
+                "via set_config_option",
+                acp_model,
+                agent_name,
+            )
         return True
     except ACPRequestError as e:
         logger.warning(
@@ -1589,10 +1635,10 @@ class ACPAgent(AgentBase):
         """Whether a live, mid-conversation model switch will be attempted.
 
         Tells a client whether to offer the inline picker's live-switch control.
-        Kept in lockstep with :meth:`set_acp_model`, which refuses the switch
-        only for a *known* provider that declares no support and otherwise
-        attempts it optimistically — so a custom/unknown ACP server that does
-        support ``session/set_model`` isn't needlessly blocked from the picker.
+        ``True`` only for known providers that explicitly declare support for
+        ``session/set_model``. Unknown/custom providers use ``set_config_option``
+        for *initial* model selection but that RPC is a generic config write, not
+        a guaranteed live-switch primitive, so the picker is hidden for them.
         ``False`` before a session exists (nothing to switch yet).
 
         See
@@ -1601,7 +1647,7 @@ class ACPAgent(AgentBase):
         if self._session_id is None:
             return False
         provider = detect_acp_provider_by_agent_name(self._agent_name)
-        return provider is None or provider.supports_runtime_model_switch
+        return provider is not None and provider.supports_runtime_model_switch
 
     def get_all_llms(self) -> Generator[LLM]:
         yield self.llm

{openhands_sdk-1.27.0 → openhands_sdk-1.28.0}/openhands/sdk/agent/agent.py

@@ -584,9 +584,10 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
                 "skipping hook check for legacy conversation state."
             )
 
-        # Prepare LLM messages using the utility function
+        # Prepare LLM messages from the cached, incrementally-maintained view.
+        # See https://github.com/OpenHands/software-agent-sdk/issues/3053.
         _messages_or_condensation = prepare_llm_messages(
-            state.events, condenser=self.condenser, llm=self.llm
+            state.view, condenser=self.condenser, llm=self.llm
         )
 
         # Process condensation event before agent sampels another action
@@ -724,8 +725,10 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
                 "skipping hook check for legacy conversation state."
             )
 
+        # Prepare LLM messages from the cached, incrementally-maintained view.
+        # See https://github.com/OpenHands/software-agent-sdk/issues/3053.
         _messages_or_condensation = await aprepare_llm_messages(
-            state.events, condenser=self.condenser, llm=self.llm
+            state.view, condenser=self.condenser, llm=self.llm
         )
 
         if isinstance(_messages_or_condensation, Condensation):
@@ -955,6 +958,20 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
         thinking_blocks: list[ThinkingBlock | RedactedThinkingBlock] | None = None,
         responses_reasoning_item: ReasoningItemModel | None = None,
     ) -> None:
+        try:
+            json.loads(tool_call.arguments)
+        except json.JSONDecodeError:
+            tool_call = tool_call.model_copy(
+                update={
+                    "arguments": json.dumps(
+                        {
+                            "_openhands_malformed_tool_call": True,
+                            "error": error,
+                        }
+                    )
+                }
+            )
+
         tc_event = ActionEvent(
             source="agent",
             thought=thought or [],

{openhands_sdk-1.27.0 → openhands_sdk-1.28.0}/openhands/sdk/agent/utils.py

@@ -10,7 +10,7 @@ import shutil
 import subprocess
 import textwrap
 import types
-from collections.abc import Collection, Sequence
+from collections.abc import Collection
 from typing import (
     TYPE_CHECKING,
     Annotated,
@@ -24,7 +24,7 @@ from typing import (
 from openhands.sdk.context.condenser.base import CondenserBase
 from openhands.sdk.context.view import View
 from openhands.sdk.conversation.types import ConversationTokenCallbackType
-from openhands.sdk.event.base import Event, LLMConvertibleEvent
+from openhands.sdk.event.base import LLMConvertibleEvent
 from openhands.sdk.event.condenser import Condensation
 from openhands.sdk.llm import LLM, LLMResponse, Message
 from openhands.sdk.tool import Action, ToolDefinition
@@ -499,7 +499,7 @@ def normalize_tool_call(
 
 @overload
 def prepare_llm_messages(
-    events: Sequence[Event],
+    view: View,
     condenser: None = None,
     additional_messages: list[Message] | None = None,
     llm: LLM | None = None,
@@ -508,7 +508,7 @@ def prepare_llm_messages(
 
 @overload
 def prepare_llm_messages(
-    events: Sequence[Event],
+    view: View,
     condenser: CondenserBase,
     additional_messages: list[Message] | None = None,
     llm: LLM | None = None,
@@ -516,19 +516,25 @@ def prepare_llm_messages(
 
 
 def prepare_llm_messages(
-    events: Sequence[Event],
+    view: View,
     condenser: CondenserBase | None = None,
     additional_messages: list[Message] | None = None,
     llm: LLM | None = None,
 ) -> list[Message] | Condensation:
-    """Prepare LLM messages from conversation context.
+    """Prepare LLM messages from a conversation view.
 
     This utility function extracts the common logic for preparing conversation
     context that is shared between agent.step() and ask_agent() methods.
     It handles condensation internally and calls the callback when needed.
 
+    Callers should pass the cached `ConversationState.view`, which is
+    maintained incrementally as events are appended. This avoids paying the
+    O(n) `View.from_events` (with `enforce_properties`) cost on every step.
+    See https://github.com/OpenHands/software-agent-sdk/issues/3053.
+
     Args:
-        events: Sequence of events to prepare messages from
+        view: A `View` of the conversation history. The view is treated as
+            read-only — see `CondenserBase.condense` for the same contract.
         condenser: Optional condenser for handling context window limits
         additional_messages: Optional additional messages to append
         llm: Optional LLM instance from the agent, passed to condenser for
@@ -537,12 +543,7 @@ def prepare_llm_messages(
     Returns:
         List of messages ready for LLM completion, or a Condensation event
         if condensation is needed
-
-    Raises:
-        RuntimeError: If condensation is needed but no callback is provided
     """
-
-    view = View.from_events(events)
     llm_convertible_events: list[LLMConvertibleEvent] = view.events
 
     # If a condenser is registered, we need to give it an
@@ -622,7 +623,7 @@ def make_llm_completion(
 
 
 async def aprepare_llm_messages(
-    events: Sequence[Event],
+    view: View,
     condenser: CondenserBase | None = None,
     additional_messages: list[Message] | None = None,
     llm: LLM | None = None,
@@ -632,7 +633,6 @@ async def aprepare_llm_messages(
     Calls ``condenser.acondense()`` so that condensers backed by an LLM can
     use async completions without blocking the event loop.
     """
-    view = View.from_events(events)
     llm_convertible_events: list[LLMConvertibleEvent] = view.events
 
     if condenser is not None:

{openhands_sdk-1.27.0 → openhands_sdk-1.28.0}/openhands/sdk/context/condenser/llm_summarizing_condenser.py

@@ -177,9 +177,15 @@ class LLMSummarizingCondenser(RollingCondenser):
 
         # Do not pass extra_body explicitly. The LLM handles forwarding
         # litellm_extra_body only when it is non-empty.
-        llm_response = self.llm.completion(
-            messages=messages,
-        )
+        try:
+            llm_response = self.llm.completion(
+                messages=messages,
+            )
+        except Exception as e:
+            raise NoCondensationAvailableException(
+                f"Summarization LLM call failed: {e}"
+            ) from e
+
         # Extract summary from the LLMResponse message
         summary = None
         if llm_response.message.content:
@@ -364,7 +370,12 @@ class LLMSummarizingCondenser(RollingCondenser):
         )
 
         messages = [Message(role="user", content=[TextContent(text=prompt)])]
-        llm_response = await self.llm.acompletion(messages=messages)
+        try:
+            llm_response = await self.llm.acompletion(messages=messages)
+        except Exception as e:
+            raise NoCondensationAvailableException(
+                f"Summarization LLM call failed: {e}"
+            ) from e
 
         summary = None
         if llm_response.message.content:

{openhands_sdk-1.27.0 → openhands_sdk-1.28.0}/openhands/sdk/conversation/conversation.py

@@ -18,6 +18,7 @@ from openhands.sdk.hooks import HookConfig
 from openhands.sdk.logger import get_logger
 from openhands.sdk.plugin import PluginSource
 from openhands.sdk.secret import SecretValue
+from openhands.sdk.tool.client_tool import ClientToolSpec
 from openhands.sdk.workspace import LocalWorkspace, RemoteWorkspace
 
 
@@ -81,6 +82,7 @@ class Conversation:
         delete_on_close: bool = True,
         tags: dict[str, str] | None = None,
         user_id: str | None = None,
+        client_tools: list[ClientToolSpec] | None = None,
     ) -> "LocalConversation": ...
 
     @overload
@@ -106,6 +108,7 @@ class Conversation:
         delete_on_close: bool = True,
         tags: dict[str, str] | None = None,
         user_id: str | None = None,
+        client_tools: list[ClientToolSpec] | None = None,
     ) -> "RemoteConversation": ...
 
     def __new__(
@@ -131,6 +134,7 @@ class Conversation:
         delete_on_close: bool = True,
         tags: dict[str, str] | None = None,
         user_id: str | None = None,
+        client_tools: list[ClientToolSpec] | None = None,
     ) -> BaseConversation:
         from openhands.sdk.conversation.impl.local_conversation import LocalConversation
         from openhands.sdk.conversation.impl.remote_conversation import (
@@ -185,6 +189,7 @@ class Conversation:
                 delete_on_close=delete_on_close,
                 tags=effective_tags if effective_tags else None,
                 user_id=user_id,
+                client_tools=client_tools,
             )
 
         return LocalConversation(
@@ -204,4 +209,5 @@ class Conversation:
             delete_on_close=delete_on_close,
             tags=tags,
             user_id=user_id,
+            client_tools=client_tools,
         )

{openhands_sdk-1.27.0 → openhands_sdk-1.28.0}/openhands/sdk/conversation/impl/local_conversation.py

@@ -2,6 +2,7 @@ import asyncio
 import atexit
 import contextlib
 import copy
+import json
 import uuid
 from collections.abc import Mapping
 from pathlib import Path
@@ -68,6 +69,7 @@ from openhands.sdk.subagent import (
     register_file_agents,
     register_plugin_agents,
 )
+from openhands.sdk.tool.client_tool import ClientToolSpec
 from openhands.sdk.tool.schema import Action, Observation
 from openhands.sdk.utils.cipher import Cipher
 from openhands.sdk.workspace import LocalWorkspace
@@ -148,6 +150,7 @@ class LocalConversation(BaseConversation):
         cipher: Cipher | None = None,
         tags: dict[str, str] | None = None,
         user_id: str | None = None,
+        client_tools: list[ClientToolSpec] | None = None,
         **_: object,
     ):
         """Initialize the conversation.
@@ -189,6 +192,11 @@ class LocalConversation(BaseConversation):
                    (lost) on serialization.
             tags: Optional key-value tags for the conversation. Keys must be
                   lowercase alphanumeric, values up to 256 characters.
+            client_tools: Optional list of client-defined tool specs. Each spec
+                  is registered and injected into the agent so it can call the
+                  tool; the executor returns an acknowledgment and the real
+                  execution is expected to be handled by a callback/consumer
+                  (e.g. a frontend) observing the emitted ActionEvent.
         """
         super().__init__()  # Initialize with span tracking
         # Mark cleanup as initiated as early as possible to avoid races or partially
@@ -206,6 +214,32 @@ class LocalConversation(BaseConversation):
         self._pending_hook_config = hook_config  # Will be combined with plugin hooks
         self._agent_ready = False  # Agent initialized lazily after plugins loaded
 
+        # Create-or-resume: factory inspects BASE_STATE to decide
+        desired_id = conversation_id or uuid.uuid4()
+
+        # Resolve client-defined tools, then register them and inject the matching
+        # Tool specs into the agent so the agent can call them. Execution is
+        # deferred to a consumer of the emitted ActionEvent (e.g. a frontend); the
+        # executor only acks. Specs come either from the caller (`client_tools`)
+        # or, when resuming a persisted conversation without re-supplying them,
+        # from the persisted agent's tool specs — mirroring the server resume
+        # path so a fresh process can re-register the dynamic tools.
+        resolved_client_tools = list(client_tools or [])
+        if not resolved_client_tools and persistence_dir is not None:
+            resolved_client_tools = self._recover_persisted_client_tools(
+                persistence_dir, desired_id
+            )
+        if resolved_client_tools:
+            from openhands.sdk.tool.client_tool import register_client_tools
+
+            client_tool_specs = register_client_tools(resolved_client_tools)
+            existing_names = {t.name for t in agent.tools}
+            new_tools = [
+                ts for ts in client_tool_specs if ts.name not in existing_names
+            ]
+            if new_tools:
+                agent = agent.model_copy(update={"tools": [*agent.tools, *new_tools]})
+
         self.agent = agent
         if isinstance(workspace, (str, Path)):
             # LocalWorkspace accepts both str and Path via BeforeValidator
@@ -217,9 +251,6 @@ class LocalConversation(BaseConversation):
         ws_path = Path(self.workspace.working_dir)
         if not ws_path.exists():
             ws_path.mkdir(parents=True, exist_ok=True)
-
-        # Create-or-resume: factory inspects BASE_STATE to decide
-        desired_id = conversation_id or uuid.uuid4()
         self._state = ConversationState.create(
             id=desired_id,
             agent=agent,
@@ -344,6 +375,44 @@ class LocalConversation(BaseConversation):
         self._start_observability_span(str(desired_id), user_id=user_id)
         self.delete_on_close = delete_on_close
 
+    def _recover_persisted_client_tools(
+        self,
+        persistence_base_dir: str | Path,
+        conversation_id: ConversationID,
+    ) -> list[ClientToolSpec]:
+        """Recover client tool specs from a persisted conversation's base state.
+
+        When a persisted conversation is resumed in a fresh process, the dynamic
+        client tools are absent from the global registry and the caller may not
+        re-supply ``client_tools``. Without recovery, the persisted agent's
+        client tools would appear "removed" and resume would fail. We read the
+        persisted agent tool specs and pull out the embedded ``ClientToolSpec``s
+        so they can be re-registered and re-injected. Returns an empty list when
+        there is no persisted state yet (fresh conversation).
+        """
+        from pydantic import ValidationError
+
+        from openhands.sdk.conversation.persistence_const import BASE_STATE
+        from openhands.sdk.tool.client_tool import extract_client_tool_specs
+        from openhands.sdk.tool.spec import Tool
+
+        base_path = (
+            Path(self.get_persistence_dir(persistence_base_dir, conversation_id))
+            / BASE_STATE
+        )
+        try:
+            data = json.loads(base_path.read_text())
+        except (FileNotFoundError, json.JSONDecodeError):
+            return []
+        raw_tools = (data.get("agent") or {}).get("tools") or []
+        tools: list[Tool] = []
+        for raw_tool in raw_tools:
+            try:
+                tools.append(Tool.model_validate(raw_tool))
+            except ValidationError:
+                continue
+        return extract_client_tool_specs(tools)
+
     @property
     def id(self) -> ConversationID:
         """Get the unique ID of the conversation."""
@@ -1798,7 +1867,7 @@ class LocalConversation(BaseConversation):
         )
 
         messages = prepare_llm_messages(
-            self.state.events, additional_messages=[user_message]
+            self.state.view, additional_messages=[user_message]
         )
 
         # Get or create the specialized ask-agent LLM

{openhands_sdk-1.27.0 → openhands_sdk-1.28.0}/openhands/sdk/conversation/impl/remote_conversation.py

@@ -53,6 +53,7 @@ from openhands.sdk.security.analyzer import SecurityAnalyzerBase
 from openhands.sdk.security.confirmation_policy import (
     ConfirmationPolicyBase,
 )
+from openhands.sdk.tool.client_tool import ClientTool, ClientToolSpec
 from openhands.sdk.utils.redact import http_error_log_content
 from openhands.sdk.workspace import LocalWorkspace, RemoteWorkspace
 
@@ -671,6 +672,7 @@ class RemoteConversation(BaseConversation):
         delete_on_close: bool = False,
         tags: dict[str, str] | None = None,
         user_id: str | None = None,
+        client_tools: list[ClientToolSpec] | None = None,
         **_: object,
     ) -> None:
         """Remote conversation proxy that talks to an agent server.
@@ -700,6 +702,10 @@ class RemoteConversation(BaseConversation):
             tags: Optional key-value tags for the conversation. Keys must be
                   lowercase alphanumeric, values up to 256 characters.
             user_id: Optional user ID to associate with observability traces
+            client_tools: Optional list of client-defined tool specs. These tools
+                      have no server-side executor — when the agent calls them an
+                      ActionEvent is emitted over the WebSocket and the client
+                      handles execution via callbacks.
         """
         super().__init__()  # Initialize base class with span tracking
         self.agent = agent
@@ -713,6 +719,12 @@ class RemoteConversation(BaseConversation):
         self._terminal_status_queue: Queue[str] = Queue()
         self._run_armed = threading.Event()
 
+        # Client tool specs the server already has persisted for this
+        # conversation (populated when re-attaching to an existing one). These
+        # must be registered locally before the initial event sync so that
+        # persisted ``ClientAction_*`` events can be deserialized.
+        attached_client_tools: list[ClientToolSpec] = []
+
         should_create = conversation_id is None
         if conversation_id is not None:
             # Try to attach to existing conversation
@@ -726,11 +738,18 @@ class RemoteConversation(BaseConversation):
                 # Conversation doesn't exist, we'll create it
                 should_create = True
             else:
-                agent_payload = resp.json().get("agent")
+                info = resp.json()
+                agent_payload = info.get("agent")
                 if agent_payload is not None:
                     remote_agent = _validate_remote_agent(agent_payload)
                     if remote_agent.agent_kind != agent.agent_kind:
                         raise ValueError(_agent_kind_mismatch_message(conversation_id))
+                # Capture persisted client tool specs so we can register their
+                # dynamic action types before RemoteState syncs events.
+                for raw_spec in info.get("client_tools") or []:
+                    attached_client_tools.append(
+                        ClientToolSpec.model_validate(raw_spec)
+                    )
                 # Conversation exists, use the provided ID
                 self._id = conversation_id
 
@@ -765,6 +784,12 @@ class RemoteConversation(BaseConversation):
                 "plugins": [p.model_dump() for p in plugins] if plugins else None,
                 # Include hook_config for server-side hooks
                 "hook_config": hook_config.model_dump() if hook_config else None,
+                # Include client-defined tool specs (no server-side executor)
+                "client_tools": (
+                    [s.model_dump(mode="json") for s in client_tools]
+                    if client_tools
+                    else []
+                ),
                 # Include tags if provided
                 "tags": tags or {},
             }
@@ -797,6 +822,18 @@ class RemoteConversation(BaseConversation):
 
             workspace.register_conversation(str(self._id))
 
+        # Register client tool action types locally so WebSocket/persisted
+        # events with ClientAction_* action_type can be deserialized by the
+        # event loop. This must cover both the specs the caller passed in and
+        # the specs the server already had persisted (when re-attaching), so a
+        # plain reattach by conversation_id can still sync persisted events.
+        seen_client_tool_names: set[str] = set()
+        for spec in [*(client_tools or []), *attached_client_tools]:
+            if spec.name in seen_client_tool_names:
+                continue
+            seen_client_tool_names.add(spec.name)
+            ClientTool.from_spec(spec)
+
         # Initialize the remote state
         self._state = RemoteState(
             self._client,

{openhands_sdk-1.27.0 → openhands_sdk-1.28.0}/openhands/sdk/conversation/request.py

@@ -27,6 +27,7 @@ from openhands.sdk.security.confirmation_policy import (
     NeverConfirm,
 )
 from openhands.sdk.subagent.schema import AgentDefinition
+from openhands.sdk.tool.client_tool import ClientToolSpec
 from openhands.sdk.utils.models import kind_of
 from openhands.sdk.workspace import LocalWorkspace
 
@@ -138,6 +139,16 @@ class StartConversationRequest(BaseModel):
             "to register the tools for this conversation."
         ),
     )
+    client_tools: list[ClientToolSpec] = Field(
+        default_factory=list,
+        description=(
+            "Tools defined by the client via JSON spec. These tools have "
+            "no server-side executor — when the agent calls them, an "
+            "ActionEvent is emitted over the WebSocket and the client "
+            "handles execution. The SDK returns an acknowledgment "
+            "observation immediately."
+        ),
+    )
     agent_definitions: list[AgentDefinition] = Field(
         default_factory=list,
         description=(

{openhands_sdk-1.27.0 → openhands_sdk-1.28.0}/openhands/sdk/llm/exceptions/classifier.py

@@ -5,6 +5,7 @@ from litellm.exceptions import (
     AuthenticationError,
     BadRequestError,
     ContextWindowExceededError,
+    InternalServerError,
     OpenAIError,
     PermissionDeniedError,
 )
@@ -48,6 +49,9 @@ MALFORMED_HISTORY_PATTERNS: list[str] = [
     ),
     # Moonshot / Kimi variant
     "must be followed by tool messages responding to each 'tool_call_id'",
+    # OpenAI-compatible providers may reject replayed assistant tool calls whose
+    # arguments are not valid JSON.
+    "failed to parse tool call arguments as json",
 ]
 
 
@@ -58,7 +62,10 @@ def is_context_window_exceeded(exception: Exception) -> bool:
     # Check for litellm/openai exception types that may contain context window errors.
     # APIConnectionError can wrap provider-specific errors (e.g., Minimax) that include
     # context window messages in their error text.
-    if not isinstance(exception, (BadRequestError, OpenAIError, APIConnectionError)):
+    if not isinstance(
+        exception,
+        (BadRequestError, OpenAIError, APIConnectionError, InternalServerError),
+    ):
         return False
 
     s = str(exception).lower()
@@ -69,7 +76,10 @@ def looks_like_malformed_conversation_history_error(exception: Exception) -> boo
     if isinstance(exception, LLMMalformedConversationHistoryError):
         return True
 
-    if not isinstance(exception, (BadRequestError, OpenAIError, APIConnectionError)):
+    if not isinstance(
+        exception,
+        (BadRequestError, OpenAIError, APIConnectionError, InternalServerError),
+    ):
         return False
 
     s = str(exception).lower()