openhands-tools 1.28.1__tar.gz → 1.29.2__tar.gz

{openhands_tools-1.28.1 → openhands_tools-1.29.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-tools
-Version: 1.28.1
+Version: 1.29.2
 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

{openhands_tools-1.28.1 → openhands_tools-1.29.2}/openhands/tools/file_editor/editor.py

@@ -2,8 +2,9 @@ import base64
 import mimetypes
 import os
 import re
-import shutil
 import tempfile
+from collections.abc import Iterator
+from contextlib import contextmanager
 from pathlib import Path
 from typing import get_args
 
@@ -43,6 +44,15 @@ logger = get_logger(__name__)
 IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"}
 
 
+def _is_encodable(text: str, encoding: str) -> bool:
+    """Return True if text can be encoded with the given encoding."""
+    try:
+        text.encode(encoding)
+    except UnicodeEncodeError:
+        return False
+    return True
+
+
 class FileEditor:
     """
     An filesystem editor tool that allows the agent to
@@ -463,12 +473,61 @@ class FileEditor:
         """
         self.validate_file(path)
         try:
-            # Use open with encoding instead of path.write_text
-            with open(path, "w", encoding=encoding) as f:
-                f.write(file_text)
+            self._atomic_write(path, file_text, encoding)
         except Exception as e:
             raise ToolError(f"Ran into {e} while trying to write to {path}") from None
 
+    def _atomic_write(self, path: Path, file_text: str, encoding: str) -> None:
+        """Write file_text to path atomically, never leaving a truncated file.
+
+        The content is written to a temporary file in the same directory which is
+        then Path.replace'd into place, so a failed write can never destroy the
+        original file. If the file's detected encoding cannot represent the new
+        content, fall back to UTF-8 so an edit may add characters (arrows, emoji,
+        CJK, ...) the original single-byte encoding lacks, instead of failing and
+        truncating the file. Note that the fallback transcodes the whole file to
+        UTF-8.
+        """
+        default = self._encoding_manager.default_encoding
+        if encoding != default and not _is_encodable(file_text, encoding):
+            logger.warning(
+                f"Detected encoding '{encoding}' cannot represent the new content "
+                f"for {path}; writing as '{default}' instead."
+            )
+            encoding = default
+
+        with self._temp_file(path, file_text, encoding) as tmp_path:
+            # Preserve the original file's permission bits when it already exists.
+            if path.exists():
+                os.chmod(tmp_path, os.stat(path).st_mode & 0o7777)
+            Path.replace(tmp_path, path)
+
+    @contextmanager
+    def _temp_file(self, path: Path, file_text: str, encoding: str) -> Iterator[Path]:
+        """Write file_text to a fresh temp file beside path and yield its Path.
+
+        The temp file is removed on any failure (write, chmod or replace), so the
+        original file is never destroyed and no stray temp file is left behind. The
+        unlink runs after the file is closed because Windows cannot delete an open
+        file.
+        """
+        tmp = tempfile.NamedTemporaryFile(
+            mode="w",
+            dir=path.parent,
+            prefix=f".{path.name}.",
+            suffix=".tmp",
+            encoding=encoding,
+            delete=False,
+        )
+        tmp_path = Path(tmp.name)
+        try:
+            with tmp:
+                tmp.write(file_text)
+            yield tmp_path
+        except BaseException:
+            tmp_path.unlink(missing_ok=True)
+            raise
+
     @with_encoding
     def insert(
         self,
@@ -501,33 +560,31 @@ class FileEditor:
 
         new_str_lines = new_str.split("\n")
 
-        # Create temporary file for the new content
-        with tempfile.NamedTemporaryFile(
-            mode="w", encoding=encoding, delete=False
-        ) as temp_file:
-            # Copy lines before insert point and save them for history
-            history_lines = []
-            with open(path, encoding=encoding) as f:
-                for i, line in enumerate(f, 1):
-                    if i > insert_line:
-                        break
-                    temp_file.write(line)
-                    history_lines.append(line)
-
-            # Insert new content
-            for line in new_str_lines:
-                temp_file.write(line + "\n")
-
-            # Copy remaining lines and save them for history
-            with open(path, encoding=encoding) as f:
-                for i, line in enumerate(f, 1):
-                    if i <= insert_line:
-                        continue
-                    temp_file.write(line)
-                    history_lines.append(line)
-
-        # Move temporary file to original location
-        shutil.move(temp_file.name, path)
+        # Build the new content in memory, then write it atomically. Routing the
+        # write through write_file reuses the same atomic, encoding-safe path as
+        # every other edit (no truncation, UTF-8 fallback for new characters).
+        new_lines: list[str] = []
+        history_lines: list[str] = []
+        with open(path, encoding=encoding) as f:
+            for i, line in enumerate(f, 1):
+                if i > insert_line:
+                    break
+                new_lines.append(line)
+                history_lines.append(line)
+
+        # Insert new content
+        for line in new_str_lines:
+            new_lines.append(line + "\n")
+
+        # Copy remaining lines and save them for history
+        with open(path, encoding=encoding) as f:
+            for i, line in enumerate(f, 1):
+                if i <= insert_line:
+                    continue
+                new_lines.append(line)
+                history_lines.append(line)
+
+        self.write_file(path, "".join(new_lines))
 
         # Read just the snippet range
         start_line = max(0, insert_line - SNIPPET_CONTEXT_WINDOW)

{openhands_tools-1.28.1 → openhands_tools-1.29.2}/openhands/tools/preset/default.py

@@ -3,9 +3,7 @@
 from pathlib import Path
 
 from openhands.sdk import Agent, agent_definition_to_factory, load_agents_from_dir
-from openhands.sdk.context.condenser import (
-    LLMSummarizingCondenser,
-)
+from openhands.sdk.context.condenser import default_condenser
 from openhands.sdk.context.condenser.base import CondenserBase
 from openhands.sdk.llm.llm import LLM
 from openhands.sdk.logger import get_logger
@@ -68,12 +66,8 @@ def get_default_tools(
 
 
 def get_default_condenser(llm: LLM) -> CondenserBase:
-    # Create a condenser to manage the context. The condenser will automatically
-    # truncate conversation history when it exceeds max_size, and replaces the dropped
-    # events with an LLM-generated summary.
-    condenser = LLMSummarizingCondenser(llm=llm, max_size=80, keep_first=4)
-
-    return condenser
+    # Shared with spawned sub-agents (see sdk default_condenser) so both stay in sync.
+    return default_condenser(llm)
 
 
 def get_default_agent(

{openhands_tools-1.28.1 → openhands_tools-1.29.2}/openhands/tools/task/manager.py

@@ -28,6 +28,7 @@ from openhands.sdk.conversation.state import (
     ConversationExecutionStatus,
     ConversationState,
 )
+from openhands.sdk.event.conversation_error import ConversationErrorEvent
 from openhands.sdk.hooks.config import HookConfig
 from openhands.sdk.logger import get_logger
 from openhands.sdk.security import ConfirmationPolicyBase
@@ -251,6 +252,11 @@ class TaskManager:
             if factory.definition.max_iteration_per_run
             else self.parent_conversation.max_iteration_per_run
         )
+        # Sub-agent budget: definition value, else inherit the parent's.
+        effective_max_budget = (
+            factory.definition.max_budget_per_run
+            or self.parent_conversation.max_budget_per_run
+        )
 
         with self._tasks_lock:
             task_id, conversation_id = self._generate_ids()
@@ -258,6 +264,7 @@ class TaskManager:
             sub_conversation = self._get_conversation(
                 description=description,
                 max_iteration_per_run=effective_max_iter,
+                max_budget_per_run=effective_max_budget,
                 task_id=task_id,
                 worker_agent=worker_agent,
                 conversation_id=conversation_id,
@@ -285,6 +292,7 @@ class TaskManager:
         conversation_id: uuid.UUID,
         worker_agent: Agent,
         hook_config: HookConfig | None = None,
+        max_budget_per_run: float | None = None,
     ) -> LocalConversation:
         parent = self.parent_conversation
         parent_visualizer = parent._visualizer
@@ -301,6 +309,7 @@ class TaskManager:
             persistence_dir=self._persistence_dir,
             conversation_id=conversation_id,
             max_iteration_per_run=max_iteration_per_run,
+            max_budget_per_run=max_budget_per_run,
             hook_config=hook_config,
             delete_on_close=True,
         )
@@ -346,9 +355,17 @@ class TaskManager:
         try:
             task.conversation.send_message(prompt, sender=parent_name)
             self._run_until_finished(task.id, task.conversation)
-            result = get_agent_final_response(task.conversation.state.events)
-            task.set_result(result)
-            logger.info(f"Task '{task.id}' completed.")
+            status = task.conversation.state.execution_status
+            if status == ConversationExecutionStatus.FINISHED:
+                result = get_agent_final_response(task.conversation.state.events)
+                task.set_result(result)
+                logger.info(f"Task '{task.id}' completed.")
+            else:
+                # Any non-FINISHED terminal status (run-limit, stuck, paused, ...)
+                # is surfaced as an error, not an empty "completed"; the detail
+                # keeps partial output so the parent can use/retry it.
+                task.set_error(self._run_stop_detail(task.conversation, status))
+                logger.warning(f"Task '{task.id}' stopped: status '{status.value}'.")
         except Exception as e:
             task.set_error(str(e))
             logger.warning(f"Task {task.id} failed with error: {e}")
@@ -358,6 +375,26 @@ class TaskManager:
 
         return task
 
+    @staticmethod
+    def _run_stop_detail(
+        conversation: LocalConversation,
+        status: ConversationExecutionStatus,
+    ) -> str:
+        """Why a sub-agent stopped without finishing (run-limit, stuck, paused, ...),
+        plus any partial output so the parent isn't left with nothing to use."""
+        errors = [
+            e
+            for e in conversation.state.events
+            if isinstance(e, ConversationErrorEvent)
+        ]
+        reason = (
+            errors[-1].detail
+            if errors
+            else f"Sub-agent stopped without finishing (status: {status.value})."
+        )
+        partial = get_agent_final_response(conversation.state.events)
+        return f"{reason}\nPartial result:\n{partial}" if partial else reason
+
     def _run_until_finished(
         self, task_id: str, conversation: LocalConversation
     ) -> None:

{openhands_tools-1.28.1 → openhands_tools-1.29.2}/openhands/tools/terminal/terminal/subprocess_terminal.py

@@ -137,6 +137,10 @@ class SubprocessTerminal(TerminalInterface):
 
         # Inherit environment variables from the parent process
         env = sanitized_env()
+        # Disable interactive pagers (git, man, systemctl, ...) so commands that
+        # auto-launch `less` on a TTY don't capture the PTY and wedge the session.
+        env.setdefault("GIT_PAGER", "cat")
+        env.setdefault("PAGER", "cat")
         env["PS1"] = self.PS1
         env["PS2"] = ""
         env["TERM"] = "xterm-256color"

{openhands_tools-1.28.1 → openhands_tools-1.29.2}/openhands/tools/terminal/terminal/tmux_terminal.py

@@ -67,6 +67,10 @@ class TmuxTerminal(TerminalInterface):
             return
 
         env = sanitized_env()
+        # Disable interactive pagers (git, man, systemctl, ...) so commands that
+        # auto-launch `less` on a TTY don't capture the pane and wedge the session.
+        env.setdefault("GIT_PAGER", "cat")
+        env.setdefault("PAGER", "cat")
         # Use a dedicated socket to isolate OpenHands sessions from the user's tmux
         self.server = libtmux.Server(socket_name=TMUX_SOCKET_NAME, environment=env)
         _shell_command = "/bin/bash"

{openhands_tools-1.28.1 → openhands_tools-1.29.2}/openhands/tools/terminal/terminal/windows_terminal.py

@@ -390,6 +390,12 @@ if ($toStop.Count -gt 0) {{ exit 0 }} else {{ exit 1 }}
         if self.process is None or self.process.poll() is not None:
             return False
 
+        # Kill descendants while they are still attached to the persistent
+        # PowerShell process. CTRL_BREAK can interrupt the waiting script first,
+        # leaving launched child processes alive but no longer discoverable as
+        # descendants of the shell.
+        terminated_children = self._terminate_child_processes()
+
         sent_ctrl_break = False
         ctrl_break_event = getattr(signal, "CTRL_BREAK_EVENT", None)
         if platform.system() == "Windows" and ctrl_break_event is not None:
@@ -402,7 +408,7 @@ if ($toStop.Count -gt 0) {{ exit 0 }} else {{ exit 1 }}
         if sent_ctrl_break:
             time.sleep(_INTERRUPT_GRACE_SECONDS)
 
-        terminated_children = self._terminate_child_processes()
+        terminated_children = self._terminate_child_processes() or terminated_children
         sent_ctrl_c_input = False
         if not sent_ctrl_break and not terminated_children:
             try:

{openhands_tools-1.28.1 → openhands_tools-1.29.2}/openhands/tools/workflow/definition.py

@@ -79,6 +79,12 @@ Available `wf` methods:
   max_concurrency=None, description=None)`
 - `await wf.reduce_agent(items, prompt, subagent_type="general-purpose",
   description=None)`
+- `await wf.pipeline(items, *stages)` — run each item through all stages with no
+  barrier between stages (a fast item reaches a later stage while a slow item is
+  still in an earlier one). The first stage gets the item; each later stage gets
+  the previous result. Stages may be sync or async. A stage that raises drops that
+  item to `None`. Prefer this over chained `map_agents` calls when per-item stages
+  are independent, since `map_agents` fully drains each stage before the next.
 - `wf.flatten(values)` — flatten one level of nesting (not recursive)
 
 `subagent_type` must be a sub-agent type registered in the parent application.

{openhands_tools-1.28.1 → openhands_tools-1.29.2}/openhands/tools/workflow/impl.py

@@ -23,6 +23,7 @@ logger = get_logger(__name__)
 
 _MAX_SCRIPT_CHARS = 20_000
 _MAX_REDUCE_INPUT_CHARS = 12_000
+_TRUNCATION_MARKER = "\n... [truncated workflow intermediate results]"
 _WORKFLOW_TIMEOUT_SECONDS = 3600.0  # 1 hour; prevents indefinitely hung workflows
 _UNSAFE_CALLS = frozenset(
     {
@@ -187,6 +188,40 @@ class WorkflowContext:
             )
         return [str(result) for result in results]
 
+    async def pipeline(
+        self,
+        items: Sequence[Any],
+        *stages: Callable[[Any], Any],
+    ) -> list[Any]:
+        """Run each item through all stages independently, with no barrier between
+        stages: a fast item can reach a later stage while a slow item is still in an
+        earlier one. The first stage receives the original item; each later stage
+        receives the previous stage's result. Stages may be sync or async. A stage
+        that raises drops that item to ``None`` and skips its remaining stages; other
+        items are unaffected.
+
+        Concurrency is bounded by the agent calls inside stages (which acquire the
+        shared semaphore), so pipeline adds no barrier of its own. Do not have a
+        stage re-acquire the semaphore directly; call ``run_agent``/``map_agents``.
+        """
+        if not stages:
+            raise ValueError("pipeline requires at least one stage")
+
+        async def run_chain(index: int, item: Any) -> Any:
+            value: Any = item
+            try:
+                for stage in stages:
+                    result = stage(value)
+                    value = await result if inspect.isawaitable(result) else result
+                return value
+            except Exception as exc:
+                logger.warning("pipeline: item %d failed: %s", index + 1, exc)
+                return None
+
+        return list(
+            await asyncio.gather(*(run_chain(i, item) for i, item in enumerate(items)))
+        )
+
     async def reduce_agent(
         self,
         items: Any,
@@ -248,18 +283,60 @@ def _render_template(
 
 
 def _format_value(value: Any) -> str:
-    if isinstance(value, str):
-        text = value
-    else:
-        text = jsonlib.dumps(value, indent=2, default=str)
+    """Serialize reduce input for the reducer prompt, bounded by
+    ``_MAX_REDUCE_INPUT_CHARS``. For lists/dicts, drop whole trailing elements
+    (keeping valid JSON) and report how many were omitted, instead of slicing
+    mid-token; everything else falls back to character truncation."""
+    if isinstance(value, (list, dict)):
+        return _truncate_structured(value)
+    text = value if isinstance(value, str) else jsonlib.dumps(value, default=str)
+    return _truncate_text(text)
+
+
+def _truncate_text(text: str) -> str:
     if len(text) <= _MAX_REDUCE_INPUT_CHARS:
         return text
-    # Character-boundary truncation can split mid-token in JSON; element-boundary
-    # truncation for list/dict inputs would be cleaner but is deferred post-MVP.
-    return (
-        text[:_MAX_REDUCE_INPUT_CHARS]
-        + "\n... [truncated workflow intermediate results]"
-    )
+    return text[:_MAX_REDUCE_INPUT_CHARS] + _TRUNCATION_MARKER
+
+
+def _truncate_structured(value: list | dict) -> str:
+    """Keep as many leading elements as fit, dropping whole elements so the JSON
+    stays valid. Always keeps at least one element; a single oversized element is
+    char-truncated as a last resort."""
+    full = jsonlib.dumps(value, indent=2, default=str)
+    if len(full) <= _MAX_REDUCE_INPUT_CHARS:
+        return full
+
+    is_dict = isinstance(value, dict)
+    items = list(value.items()) if is_dict else list(value)
+    total = len(items)
+
+    def render(kept: list) -> str:
+        body = jsonlib.dumps(dict(kept) if is_dict else kept, indent=2, default=str)
+        dropped = total - len(kept)
+        if not dropped:
+            return body
+        return (
+            f"{body}\n... [{dropped} of {total} items omitted to fit the "
+            "reduce input limit]"
+        )
+
+    # Greedy fill by per-element estimate, then correct against the actual
+    # combined serialization (which is larger than the sum of parts) so the
+    # result fits without slicing mid-token.
+    kept: list = []
+    used = 0
+    for item in items:
+        chunk = jsonlib.dumps(dict([item]) if is_dict else item, default=str)
+        if kept and used + len(chunk) > _MAX_REDUCE_INPUT_CHARS:
+            break
+        kept.append(item)
+        used += len(chunk)
+    while len(kept) > 1 and len(render(kept)) > _MAX_REDUCE_INPUT_CHARS:
+        kept.pop()
+
+    # Safety net: a single oversized element can still exceed the budget.
+    return _truncate_text(render(kept))
 
 
 def validate_workflow_script(script: str) -> None:

{openhands_tools-1.28.1 → openhands_tools-1.29.2}/openhands_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-tools
-Version: 1.28.1
+Version: 1.29.2
 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

{openhands_tools-1.28.1 → openhands_tools-1.29.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openhands-tools"
-version = "1.28.1"
+version = "1.29.2"
 description = "OpenHands Tools - Runtime tools for AI agents"
 
 requires-python = ">=3.12"