Merge branch 'main' into vasco/tmux-panels

Author: VascoSch92

.github/workflows/version-bump-prs.yml

@@ -337,7 +337,7 @@ jobs:
                   echo "- [OpenHands-CLI](https://github.com/OpenHands/openhands-cli/pulls?q=is%3Apr+bump-sdk-$VERSION)" >> $GITHUB_STEP_SUMMARY
 
             - name: Notify Slack
-              uses: slackapi/slack-github-action@v2.1.1
+              uses: slackapi/slack-github-action@v3.0.1
               with:
                   method: chat.postMessage
                   token: ${{ secrets.SLACK_BOT_TOKEN }}

AGENTS.md

@@ -106,6 +106,7 @@ When reviewing code, provide constructive feedback:
 - `SettingsFieldSchema` intentionally does not export a `required` flag. If a consumer needs nullability semantics, inspect the underlying Python typing rather than inferring from SDK defaults.
 - `AgentSettings.tools` is part of the exported settings schema so the schema stays aligned with the settings payload that round-trips through `AgentSettings` and drives `create_agent()`.
 - `AgentSettings.mcp_config` now uses FastMCP's typed `MCPConfig` at runtime. When serializing settings back to plain data (e.g. `model_dump()` or `create_agent()`), keep the output compact with `exclude_none=True, exclude_defaults=True` so callers still see the familiar `.mcp.json`-style dict shape.
+- Anthropic malformed tool-use/tool-result history errors (for example, missing or duplicated ``tool_result`` blocks) are intentionally mapped to a dedicated `LLMMalformedConversationHistoryError` and caught separately in `Agent.step()`, so recovery can still use condensation while logs preserve that this was malformed history rather than a true context-window overflow.
 - AgentSkills progressive disclosure goes through `AgentContext.get_system_message_suffix()` into `<available_skills>`, and `openhands.sdk.context.skills.to_prompt()` truncates each prompt description to 1024 characters because the AgentSkills specification caps `description` at 1-1024 characters.
 - Workspace-wide uv resolver guardrails belong in the repository root `[tool.uv]` table. When `exclude-newer` is configured there, `uv lock` persists it into the root `uv.lock` `[options]` section as both an absolute cutoff and `exclude-newer-span`, and `uv sync --frozen` continues to use that locked workspace state.
 - `pr-review-by-openhands` delegates to `OpenHands/extensions/plugins/pr-review@main`. Repo-specific reviewer instructions live in `.agents/skills/custom-codereview-guide.md`, and because task-trigger matching is substring-based, that `/codereview` skill is also auto-injected for the workflow's `/codereview-roasted` prompt.

examples/01_standalone_sdk/40_acp_agent_example.py

@@ -19,7 +19,7 @@
 from openhands.sdk.conversation import Conversation
 
 
-agent = ACPAgent(acp_command=["npx", "-y", "@zed-industries/claude-agent-acp"])
+agent = ACPAgent(acp_command=["npx", "-y", "@agentclientprotocol/claude-agent-acp"])
 
 try:
     cwd = os.getcwd()

openhands-agent-server/openhands/agent_server/api.py

@@ -35,6 +35,7 @@
     mark_initialization_complete,
     server_details_router,
 )
+from openhands.agent_server.settings_router import settings_router
 from openhands.agent_server.skills_router import skills_router
 from openhands.agent_server.sockets import sockets_router
 from openhands.agent_server.tool_preload_service import get_tool_preload_service
@@ -213,6 +214,7 @@ def _add_api_routes(app: FastAPI, config: Config) -> None:
     api_router.include_router(skills_router)
     api_router.include_router(hooks_router)
     api_router.include_router(llm_router)
+    api_router.include_router(settings_router)
     app.include_router(api_router)
     app.include_router(sockets_router)
 

openhands-agent-server/openhands/agent_server/docker/Dockerfile

@@ -113,7 +113,7 @@ RUN set -eux; \
     PATH="$ACP_NODE_DIR/bin:$PATH"; \
     node --version; \
     npm install -g \
-      @zed-industries/claude-agent-acp \
+      @agentclientprotocol/claude-agent-acp \
       @zed-industries/codex-acp \
       @google/gemini-cli; \
     # Create wrappers in /usr/local/bin that prepend ACP's Node 22 to PATH.

openhands-agent-server/openhands/agent_server/settings_router.py

@@ -0,0 +1,19 @@
+from functools import lru_cache
+
+from fastapi import APIRouter
+
+from openhands.sdk.settings import AgentSettings, SettingsSchema
+
+
+settings_router = APIRouter(prefix="/settings", tags=["Settings"])
+
+
+@lru_cache(maxsize=1)
+def _get_agent_settings_schema() -> SettingsSchema:
+    return AgentSettings.export_schema()
+
+
+@settings_router.get("/schema", response_model=SettingsSchema)
+async def get_agent_settings_schema() -> SettingsSchema:
+    """Return the schema used to render AgentSettings-based settings forms."""
+    return _get_agent_settings_schema()

openhands-agent-server/openhands/agent_server/tool_router.py

@@ -3,13 +3,17 @@
 from fastapi import APIRouter
 
 from openhands.sdk.tool.registry import list_registered_tools
-from openhands.tools.preset.default import register_default_tools
+from openhands.tools.preset.default import (
+    register_builtins_agents,
+    register_default_tools,
+)
 from openhands.tools.preset.gemini import register_gemini_tools
 from openhands.tools.preset.planning import register_planning_tools
 
 
 tool_router = APIRouter(prefix="/tools", tags=["Tools"])
 register_default_tools(enable_browser=True)
+register_builtins_agents(enable_browser=True)
 register_gemini_tools(enable_browser=True)
 register_planning_tools()
 

openhands-sdk/openhands/sdk/agent/acp_agent.py

@@ -297,7 +297,7 @@ def __init__(self) -> None:
         # signal that the ACP subprocess is still actively working.  Set by
         # ACPAgent.step() to keep the agent-server's idle timer alive.
         self.on_activity: Any = None  # Callable[[], None] | None
-        self._last_activity_signal: float = 0.0
+        self._last_activity_signal: float = float("-inf")
         # Telemetry state from UsageUpdate (persists across turns)
         self._last_cost: float = 0.0  # last cumulative cost seen
         self._last_cost_by_session: dict[str, float] = {}
@@ -537,7 +537,7 @@ class ACPAgent(AgentBase):
         ...,
         description=(
             "Command to start the ACP server, e.g."
-            " ['npx', '-y', '@zed-industries/claude-agent-acp']"
+            " ['npx', '-y', '@agentclientprotocol/claude-agent-acp']"
         ),
     )
     acp_args: list[str] = Field(

openhands-sdk/openhands/sdk/agent/agent.py

@@ -51,6 +51,7 @@
 from openhands.sdk.llm.exceptions import (
     FunctionCallValidationError,
     LLMContextWindowExceedError,
+    LLMMalformedConversationHistoryError,
 )
 from openhands.sdk.logger import get_logger
 from openhands.sdk.observability.laminar import (
@@ -516,6 +517,30 @@ def step(
             )
             on_event(error_message)
             return
+        except LLMMalformedConversationHistoryError as e:
+            # The provider rejected the current message history as structurally
+            # invalid (for example, broken tool_use/tool_result pairing). Route
+            # this into condensation recovery, but keep the logs distinct from
+            # true context-window exhaustion so upstream event-stream bugs remain
+            # visible.
+            if (
+                self.condenser is not None
+                and self.condenser.handles_condensation_requests()
+            ):
+                logger.warning(
+                    "LLM raised malformed conversation history error, "
+                    "triggering condensation retry with condensed history: "
+                    f"{e}"
+                )
+                on_event(CondensationRequest())
+                return
+            logger.warning(
+                "LLM raised malformed conversation history error but no "
+                "condenser can handle condensation requests. This usually "
+                "indicates an upstream event-stream or resume bug: "
+                f"{e}"
+            )
+            raise e
         except LLMContextWindowExceedError as e:
             # If condenser is available and handles requests, trigger condensation
             if (
@@ -820,6 +845,7 @@ def _get_action_event(
 
         # Validate arguments
         security_risk: risk.SecurityRisk = risk.SecurityRisk.UNKNOWN
+        parsed_args: dict | None = None
         try:
             # Try parsing arguments as-is first.  Raw newlines / tabs are
             # legal JSON whitespace and many models emit them between tokens
@@ -828,13 +854,14 @@ def _get_action_event(
             # Fall back to sanitization only when the raw string is invalid
             # (handles models that emit raw control chars *inside* strings).
             try:
-                arguments = json.loads(tool_call.arguments)
+                parsed_args = json.loads(tool_call.arguments)
             except json.JSONDecodeError:
                 sanitized_args = sanitize_json_control_chars(tool_call.arguments)
-                arguments = json.loads(sanitized_args)
+                parsed_args = json.loads(sanitized_args)
 
             # Fix malformed arguments (e.g., JSON strings for list/dict fields)
-            arguments = fix_malformed_tool_arguments(arguments, tool.action_type)
+            assert isinstance(parsed_args, dict)
+            arguments = fix_malformed_tool_arguments(parsed_args, tool.action_type)
             security_risk = self._extract_security_risk(
                 arguments,
                 tool.name,
@@ -849,10 +876,14 @@ def _get_action_event(
 
             action: Action = tool.action_from_arguments(arguments)
         except (json.JSONDecodeError, ValidationError, ValueError) as e:
-            err = (
-                f"Error validating args {tool_call.arguments} for tool "
-                f"'{tool.name}': {e}"
+            # Build concise error message with parameter names only (not values)
+            keys = list(parsed_args.keys()) if isinstance(parsed_args, dict) else None
+            params = (
+                f"Parameters provided: {keys}"
+                if keys is not None
+                else "Arguments: unparseable JSON"
             )
+            err = f"Error validating tool '{tool.name}': {e}. {params}"
             # Persist assistant function_call so next turn has matching call_id
             tc_event = ActionEvent(
                 source="agent",

openhands-sdk/openhands/sdk/context/view/view.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from functools import cached_property
 from logging import getLogger
 from typing import overload
 
@@ -28,18 +27,15 @@ class View(BaseModel):
     in deciding whether further condensation is needed.
     """
 
-    events: list[LLMConvertibleEvent]
+    events: list[LLMConvertibleEvent] = Field(default_factory=list)
 
     unhandled_condensation_request: bool = False
     """Whether there is an unhandled condensation request in the view."""
 
-    condensations: list[Condensation] = Field(default_factory=list)
-    """A list of condensations that were processed to produce the view."""
-
     def __len__(self) -> int:
         return len(self.events)
 
-    @cached_property
+    @property
     def manipulation_indices(self) -> ManipulationIndices:
         """The indices where the view events can be manipulated without violating the
         properties expected by LLM APIs.
@@ -75,26 +71,10 @@ def __getitem__(
         else:
             raise ValueError(f"Invalid key type: {type(key)}")
 
-    @staticmethod
-    def unhandled_condensation_request_exists(
-        events: Sequence[Event],
-    ) -> bool:
-        """Check if there is an unhandled condensation request in the list of events.
-
-        An unhandled condensation request is defined as a CondensationRequest event
-        that appears after the most recent Condensation event in the list.
-        """
-        for event in reversed(events):
-            if isinstance(event, Condensation):
-                return False
-            if isinstance(event, CondensationRequest):
-                return True
-        return False
-
-    @staticmethod
     def enforce_properties(
-        current_view_events: list[LLMConvertibleEvent], all_events: Sequence[Event]
-    ) -> list[LLMConvertibleEvent]:
+        self,
+        all_events: Sequence[Event],
+    ) -> None:
         """Enforce all properties on the list of current view events.
 
         Repeatedly applies each property's enforcement mechanism until the list of view
@@ -103,62 +83,78 @@ def enforce_properties(
         Since enforcement is intended as a fallback to inductively maintaining the
         properties via the associated manipulation indices, any time a property must be
         enforced a warning is logged.
+
+        Modifies the view in-place.
         """
         for property in ALL_PROPERTIES:
-            events_to_forget = property.enforce(current_view_events, all_events)
+            events_to_forget = property.enforce(self.events, all_events)
             if events_to_forget:
                 logger.warning(
                     f"Property {property.__class__} enforced, "
                     f"{len(events_to_forget)} events dropped."
                 )
-                return View.enforce_properties(
-                    [
-                        event
-                        for event in current_view_events
-                        if event.id not in events_to_forget
-                    ],
-                    all_events,
-                )
-        return current_view_events
 
-    @staticmethod
-    def from_events(events: Sequence[Event]) -> View:
-        """Create a view from a list of events, respecting the semantics of any
-        condensation events.
-        """
-        output: list[LLMConvertibleEvent] = []
-        condensations: list[Condensation] = []
+                self.events = [
+                    event for event in self.events if event.id not in events_to_forget
+                ]
+                break
 
-        # Generate the LLMConvertibleEvent objects the agent can send to the LLM by
-        # removing un-sendable events and applying condensations in order.
-        for event in events:
-            # By the time we come across a Condensation event, the output list should
+        # If we get all the way through the loop without hitting a break, that means no
+        # properties needed to be enforced and we can keep the view as-is.
+        else:
+            return
+
+        # If we did hit a break in the loop, a property applied and now we need to check
+        # all the properties again to see if any are unblocked.
+        self.enforce_properties(all_events)
+
+    def append_event(self, event: Event) -> None:
+        """Append an event to the end of the view, applying any condensation semantics
+        as we do.
+
+        Modifies the view in-place.
+        """
+        match event:
+            # By the time we come across a Condensation event, the event list should
             # already reflect the events seen by the agent up to that point. We can
-            # therefore apply the condensation semantics directly to the output list.
-            if isinstance(event, Condensation):
-                condensations.append(event)
-                output = event.apply(output)
+            # therefore apply the condensation semantics directly to the stored events.
+            case Condensation():
+                self.events = event.apply(self.events)
+                self.unhandled_condensation_request = False
+
+            case CondensationRequest():
+                self.unhandled_condensation_request = True
 
-            elif isinstance(event, LLMConvertibleEvent):
-                output.append(event)
+            case LLMConvertibleEvent():
+                self.events.append(event)
 
             # If the event isn't related to condensation and isn't LLMConvertible, it
             # should not be in the resulting view. Examples include certain internal
             # events used for state tracking that the LLM does not need to see -- see,
             # for example, ConversationStateUpdateEvent, PauseEvent, and (relevant here)
             # CondensationRequest.
-            else:
+            case _:
                 logger.debug(
                     f"Skipping non-LLMConvertibleEvent of type {type(event)} "
-                    "in View.from_events"
+                    "in View.append_event"
                 )
 
-        output = View.enforce_properties(output, events)
+    @staticmethod
+    def from_events(events: Sequence[Event]) -> View:
+        """Create a view from a list of events, respecting the semantics of any
+        condensation events.
+        """
+        result: View = View()
+
+        # Generate the LLMConvertibleEvent objects the agent can send to the LLM by
+        # adding them one at a time to the result view. This ensures condensations are
+        # applied in the order they were generated and condensation requests are
+        # appropriately tracked.
+        for event in events:
+            result.append_event(event)
+
+        # Once all the events are loaded enforce the relevant properties to ensure
+        # the construction was done properly.
+        result.enforce_properties(events)
 
-        return View(
-            events=output,
-            unhandled_condensation_request=View.unhandled_condensation_request_exists(
-                events
-            ),
-            condensations=condensations,
-        )
+        return result