openhands-tools 1.53.0__tar.gz → 1.55.0__tar.gz

{openhands_tools-1.53.0 → openhands_tools-1.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-tools
-Version: 1.53.0
+Version: 1.55.0
 Summary: OpenHands Tools - Runtime tools for AI agents
 Project-URL: Source, https://github.com/OpenHands/software-agent-sdk
 Project-URL: Homepage, https://github.com/OpenHands/software-agent-sdk
@@ -12,6 +12,7 @@ Requires-Dist: tree-sitter>=0.24
 Requires-Dist: tree-sitter-bash>=0.23
 Requires-Dist: binaryornot>=0.6.0
 Requires-Dist: cachetools
+Requires-Dist: filelock>=3.20.1
 Requires-Dist: libtmux>=0.53.0
 Requires-Dist: pydantic>=2.13.5
 Requires-Dist: browser-use>=0.8.0

{openhands_tools-1.53.0 → openhands_tools-1.55.0}/openhands/tools/delegate/impl.py

@@ -13,6 +13,7 @@ from openhands.sdk.conversation.state import (
 )
 from openhands.sdk.logger import get_logger
 from openhands.sdk.subagent import get_agent_factory
+from openhands.sdk.subagent.scope import inherit_mcp_config
 from openhands.sdk.tool.tool import ToolExecutor
 from openhands.tools.delegate.definition import DelegateObservation
 
@@ -188,7 +189,9 @@ class DelegateExecutor(ToolExecutor):
                 worker_agent = factory.factory_func(sub_agent_llm)
 
                 # ensuring that the sub-agent LLM has stream deactivated
-                worker_agent = worker_agent.model_copy(
+                worker_agent = inherit_mcp_config(
+                    parent_conversation.agent, worker_agent
+                ).model_copy(
                     update={
                         "llm": worker_agent.llm.model_copy(update={"stream": False})
                     }
@@ -223,6 +226,8 @@ class DelegateExecutor(ToolExecutor):
                     "_parent_llm_call_context": (
                         parent_conversation.get_llm_call_context()
                     ),
+                    "mcp_tool_provider": parent_conversation._mcp_tool_provider,
+                    "_mcp_config_from_parent": True,
                 }
 
                 if factory.definition.max_iteration_per_run is not None:

{openhands_tools-1.53.0 → openhands_tools-1.55.0}/openhands/tools/file_editor/editor.py

@@ -414,11 +414,9 @@ class FileEditor:
             )
 
         file_content = self.read_file(path, start_line=start_line, end_line=end_line)
+        file_content = self._normalize_lines(file_content)
 
-        # Get the detected encoding
-        output = self._make_output(
-            "\n".join(file_content.splitlines()), str(path), start_line
-        )  # Remove extra newlines
+        output = self._make_output(file_content, str(path), start_line)
 
         # Prepend warning if we truncated the end_line
         if warning_message:
@@ -787,6 +785,17 @@ class FileEditor:
         except Exception as e:
             raise ToolError(f"Ran into {e} while trying to read {path}") from None
 
+    def _normalize_lines(self, content: str) -> str:
+        """Rejoin a template snippet without folding exotic line separators.
+
+        ``read_file`` returns a snippet whose lines are separated by ``\\n``. The
+        ranged ``view`` path used to round-trip it through ``str.splitlines()``,
+        which also breaks on form feeds and Unicode separators that the rest of
+        the editor treats as ordinary characters, shifting line numbers. Joining
+        on ``\\n`` instead keeps every other character intact.
+        """
+        return "\n".join(content.split("\n"))
+
     def _make_output(
         self,
         snippet_content: str,
@@ -815,14 +824,17 @@ class FileEditor:
             truncate_notice=TEXT_FILE_CONTENT_TRUNCATED_NOTICE,
         )
 
+        # Split on "\n" only, matching how read_file/_count_lines define lines, so that
+        # characters splitlines() treats as breaks (\x0c, \u2028, ...) keep line numbers
+        # consistent with insert/view_range. A terminating newline ends the last line
+        # rather than adding a blank one, so drop the empty field it produces.
+        lines = snippet_content.split("\n")
+        if lines[-1] == "":
+            lines.pop()
         snippet_content = "\n".join(
-            [
-                f"{i + start_line:6}\t{line}"
-                for i, line in enumerate(snippet_content.split("\n"))
-            ]
-        )
-        return (
-            f"Here's the result of running `cat -n` on {snippet_description}:\n"
-            + snippet_content
-            + "\n"
+            [f"{i + start_line:6}\t{line}" for i, line in enumerate(lines)]
         )
+        output = f"Here's the result of running `cat -n` on {snippet_description}:\n"
+        if snippet_content:
+            output += snippet_content + "\n"
+        return output

{openhands_tools-1.53.0 → openhands_tools-1.55.0}/openhands/tools/file_editor/utils/encoding.py

@@ -1,5 +1,6 @@
 """Encoding management for file operations."""
 
+import codecs
 import functools
 import inspect
 import os
@@ -22,7 +23,8 @@ BINARY_CONTROL_CHARS = re.compile(r"[\x00-\x08\x0e-\x1f\x7f]")
 # file's encoding. Short non-UTF-8 files fall below the detector's confidence
 # threshold and are reported as the default encoding, so the detected value
 # alone is not enough to recover them. Ordered most to least likely for source
-# files; the detector's own guess is tried first when it is one of these.
+# files; the detector's own guess is tried right after UTF-8 when it is one of
+# these.
 TEXT_DECODE_CANDIDATES = ("utf-8", "cp1252", "latin-1", "cp1251")
 
 # charset_normalizer reports some codecs under IANA names; map them to the
@@ -70,6 +72,16 @@ class EncodingManager:
         with open(path, "rb") as f:
             raw_data = f.read(sample_size)
 
+        if raw_data.startswith(codecs.BOM_UTF8):
+            return "utf-8-sig"
+
+        try:
+            raw_data.decode(self.default_encoding)
+        except UnicodeDecodeError:
+            pass
+        else:
+            return self.default_encoding
+
         # Use charset_normalizer instead of chardet
         results = charset_normalizer.detect(raw_data)
 
@@ -116,7 +128,11 @@ class EncodingManager:
 
     def _recover_encoding(self, path: Path) -> str | None:
         """Return a codec that decodes ``path`` to control-byte-free text."""
-        candidates = (self._best_guess_encoding(path), *TEXT_DECODE_CANDIDATES)
+        candidates = (
+            self.default_encoding,
+            self._best_guess_encoding(path),
+            *TEXT_DECODE_CANDIDATES,
+        )
         for candidate in dict.fromkeys(c for c in candidates if c):
             try:
                 text = path.read_text(encoding=candidate)

{openhands_tools-1.53.0 → openhands_tools-1.55.0}/openhands/tools/task/definition.py

@@ -244,8 +244,9 @@ class TaskToolSet(ToolDefinition[TaskAction, TaskObservation]):
                 confirmation policy requires user approval.  Receives
                 `(task_id, pending_actions)` and must return `True` to
                 approve or `False` to reject.
-            sub_agent_scope: Which of this agent's capabilities the sub-agents
-                it offers and starts must stay within.
+            sub_agent_scope: Whether the sub-agents it offers and starts must
+                stay within this agent's tools. Sub-agents always inherit this
+                agent's MCP servers.
 
         Returns:
             List containing a single TaskTool.
@@ -264,8 +265,7 @@ class TaskToolSet(ToolDefinition[TaskAction, TaskObservation]):
             agent_types_info = get_factory_info(lambda d: d.name in registered)
         else:
             agent_types_info = (
-                "- None: every registered agent uses tools or MCP servers "
-                "this agent does not have."
+                "- None: every registered agent uses tools this agent does not have."
             )
 
         task_tool_examples = "\n".join(

{openhands_tools-1.53.0 → openhands_tools-1.55.0}/openhands/tools/task/manager.py

@@ -35,7 +35,11 @@ from openhands.sdk.logger import get_logger
 from openhands.sdk.observability.laminar import detached_delegate_context
 from openhands.sdk.security import ConfirmationPolicyBase
 from openhands.sdk.subagent.registry import AgentFactory, get_agent_factory
-from openhands.sdk.subagent.scope import SubAgentScope, scope_delegation_tools
+from openhands.sdk.subagent.scope import (
+    SubAgentScope,
+    inherit_mcp_config,
+    scope_delegation_tools,
+)
 
 
 if TYPE_CHECKING:
@@ -225,6 +229,8 @@ class TaskManager:
                     _parent_llm_call_context=(
                         self.parent_conversation.get_llm_call_context()
                     ),
+                    mcp_tool_provider=self.parent_conversation._mcp_tool_provider,
+                    _mcp_config_from_parent=True,
                     delete_on_close=True,
                     observability_metadata=self._delegate_observability_metadata(
                         task_id=resume, subagent_type=subagent_type, link=link
@@ -328,6 +334,8 @@ class TaskManager:
                 max_budget_per_run=max_budget_per_run,
                 hook_config=hook_config,
                 _parent_llm_call_context=parent.get_llm_call_context(),
+                mcp_tool_provider=parent._mcp_tool_provider,
+                _mcp_config_from_parent=True,
                 delete_on_close=True,
                 prompt_cache_key=str(parent.state.id),
                 observability_metadata=self._delegate_observability_metadata(
@@ -391,7 +399,7 @@ class TaskManager:
             )
 
         # ensuring that the sub-agent LLM has stream deactivated
-        sub_agent = sub_agent.model_copy(
+        sub_agent = inherit_mcp_config(parent.agent, sub_agent).model_copy(
             update={
                 "llm": sub_agent.llm.model_copy(update={"stream": False}),
                 "tools": scope_delegation_tools(sub_agent.tools, self._sub_agent_scope),

{openhands_tools-1.53.0 → openhands_tools-1.55.0}/openhands/tools/task_tracker/definition.py

@@ -1,9 +1,9 @@
 import json
 from collections.abc import Sequence
 from pathlib import Path
-from typing import TYPE_CHECKING, ClassVar, Literal
+from typing import TYPE_CHECKING, ClassVar, Literal, get_args
 
-from pydantic import BaseModel, Field, ValidationError
+from pydantic import BaseModel, Field, ValidationError, field_validator
 
 
 if TYPE_CHECKING:
@@ -28,6 +28,14 @@ logger = get_logger(__name__)
 # Type alias for task tracker status
 TaskTrackerStatusType = Literal["todo", "in_progress", "done"]
 
+# Models trained on other agents' todo tools send these names for our statuses.
+_STATUS_ALIASES: dict[str, TaskTrackerStatusType] = {
+    "pending": "todo",
+    "to_do": "todo",
+    "completed": "done",
+    "complete": "done",
+}
+
 
 class TaskItem(BaseModel):
     title: str = Field(..., description="A brief title for the task.")
@@ -38,6 +46,16 @@ class TaskItem(BaseModel):
         "One of 'todo', 'in_progress', or 'done'.",
     )
 
+    @field_validator("status", mode="before")
+    @classmethod
+    def _normalize_status(cls, value: object) -> object:
+        if not isinstance(value, str):
+            return value
+        normalized = value.strip().lower().replace("-", "_").replace(" ", "_")
+        if normalized in get_args(TaskTrackerStatusType):
+            return normalized
+        return _STATUS_ALIASES.get(normalized, value)
+
 
 class TaskTrackerAction(Action):
     """An action where the agent writes or updates a task list for task management."""
@@ -406,6 +424,7 @@ class TaskTrackerTool(ToolDefinition[TaskTrackerAction, TaskTrackerObservation])
     catalog_description: ClassVar[str] = (
         "Keep a running task list to organise multi-step work."
     )
+    conversation_local: ClassVar[bool] = True
 
     @classmethod
     def create(cls, conv_state: "ConversationState") -> Sequence["TaskTrackerTool"]:

{openhands_tools-1.53.0 → openhands_tools-1.55.0}/openhands/tools/terminal/constants.py

@@ -30,12 +30,26 @@ TIMEOUT_MESSAGE_TEMPLATE: Final[str] = (
 # How long to wait with no new output before considering it a no-change timeout
 NO_CHANGE_TIMEOUT_SECONDS: Final[int] = 30
 
-# How often to poll for new output in seconds
+# How often to poll for new output in seconds, once a command has run for a while
 POLL_INTERVAL: Final[float] = 0.5
+# Shortest poll interval, used right after a command is sent
+MIN_POLL_INTERVAL: Final[float] = 0.02
 HISTORY_LIMIT: Final[int] = 10_000
 
 TMUX_SOCKET_NAME: Final[str] = "openhands"
 
+# tmux user option recording the PID of the process that created a socket.
+# Startup cleanup reads it so it does not kill the live sessions of a sibling
+# agent-server that shares one externally supplied TMUX_TMPDIR.
+TMUX_SOCKET_OWNER_OPTION: Final[str] = "@openhands_socket_owner_pid"
+
+# Cross-process lock file, inside the tmux socket directory, that serializes
+# socket creation with the agent-server's startup cleanup. A socket only exists
+# between creation and the recording of its owner, so both operations take this
+# lock to keep cleanup from reclaiming a socket that a live process is still
+# setting up.
+TMUX_SOCKET_CREATION_LOCK: Final[str] = ".openhands-socket-creation.lock"
+
 # Tmux session dimensions (columns x rows). Keep the viewport wide enough for
 # common command output while leaving scrollback retention to HISTORY_LIMIT.
 # Output wider than TMUX_SESSION_WIDTH columns will wrap; this is an accepted