openhands-tools 1.58.2__tar.gz → 1.60.0__tar.gz

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-tools
-Version: 1.58.2
+Version: 1.60.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
@@ -14,7 +14,8 @@ 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: libtmux>=0.62.0
+Requires-Dist: psutil>=7.2.2
 Requires-Dist: pydantic>=2.13.5
 Requires-Dist: browser-use>=0.8.0
 Requires-Dist: func-timeout>=4.3.5

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands/tools/apply_patch/core.py

@@ -455,6 +455,10 @@ def load_files(paths: list[str], open_fn: Callable[[str], str]) -> dict[str, str
             FileNotFoundError
         ) as exc:  # pragma: no cover - exercised via higher-level tests
             raise DiffError(f"Delete File Error: Missing File: {path}") from exc
+        except (OSError, UnicodeDecodeError) as exc:
+            # An unreadable path (a directory, a denied file, bytes that are not
+            # UTF-8 text) must surface as a tool error, not escape the executor.
+            raise DiffError(f"Cannot read {path}: {exc}") from exc
     return orig
 
 

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands/tools/browser_use/server.py

@@ -1,4 +1,5 @@
 from browser_use.dom.markdown_extractor import extract_clean_markdown
+from browser_use.dom.service import DomService
 
 from openhands.sdk import get_logger
 from openhands.tools.browser_use.logging_fix import LogSafeBrowserUseServer
@@ -259,10 +260,27 @@ class CustomBrowserUseServer(LogSafeBrowserUseServer):
         if not self.browser_session:
             return "Error: No browser session active"
 
-        # Extract clean markdown using the new method
+        target_id = self.browser_session.agent_focus_target_id
+        if not target_id:
+            return "Error: No active page"
+
+        # Read a fresh DOM tree. The session path reuses the tree cached by the
+        # last browser_get_state, which is stale after clicks, timers or
+        # history navigation. A separate DomService leaves that cache and its
+        # element indices untouched.
+        profile = self.browser_session.browser_profile
+        dom_service = DomService(
+            browser_session=self.browser_session,
+            cross_origin_iframes=profile.cross_origin_iframes,
+            paint_order_filtering=profile.paint_order_filtering,
+            max_iframes=profile.max_iframes,
+            max_iframe_depth=profile.max_iframe_depth,
+        )
         try:
             content, content_stats = await extract_clean_markdown(
-                browser_session=self.browser_session, extract_links=extract_links
+                dom_service=dom_service,
+                target_id=target_id,
+                extract_links=extract_links,
             )
         except Exception as e:
             logger.exception(

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands/tools/child_conversation/definition.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, ClassVar, Literal, Self
 from pydantic import Field
 from rich.text import Text
 
+from openhands.sdk.event.types import UnmaskedID
 from openhands.sdk.tool.registry import register_tool
 from openhands.sdk.tool.tool import (
     Action,
@@ -36,7 +37,8 @@ class StartChildConversationAction(Action):
         default="worktree",
         description=(
             "'worktree' gives the child its own git worktree and branch when the "
-            "workspace is a git repository; 'shared' runs it in the same directory."
+            "workspace has a usable git base commit; otherwise it shares the "
+            "directory. 'shared' always runs it in the same directory."
         ),
     )
 
@@ -54,8 +56,8 @@ class StartChildConversationAction(Action):
 class StartChildConversationObservation(Observation):
     """Result of a child conversation launch."""
 
-    conversation_id: str | None = None
-    parent_conversation_id: str | None = None
+    conversation_id: UnmaskedID | None = None
+    parent_conversation_id: UnmaskedID | None = None
     status: str | None = None
     title: str | None = None
     url: str | None = None
@@ -92,7 +94,8 @@ _DESCRIPTION = (
     "conversation's history, so include the goal, relevant paths, constraints "
     "and the expected deliverable. Use `title` to name it. `isolation` controls "
     "the workspace: `worktree` (default) gives the child its own git worktree "
-    "and branch when the workspace is a git repository; the worktree starts "
+    "and branch when the workspace has a usable git base commit; otherwise "
+    "it shares the directory and reports `shared` isolation. The worktree starts "
     "from the repository's default branch, not from this conversation's branch "
     "or uncommitted changes, so use `shared` when the child must see them. "
     "`shared` runs it in the same directory; backends that manage workspaces "

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands/tools/file_editor/editor.py

@@ -486,8 +486,12 @@ class FileEditor:
         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.
+        UTF-8. Editing through a symlink writes to the link's target: a rename
+        onto the link path would replace the link with a regular file.
         """
+        if path.is_symlink():
+            path = path.resolve()
+
         default = self._encoding_manager.default_encoding
         if encoding != default and not _is_encodable(file_text, encoding):
             logger.warning(
@@ -572,6 +576,11 @@ class FileEditor:
                 new_lines.append(line)
                 history_lines.append(line)
 
+        # A final line without a trailing newline would fuse with the inserted
+        # content; terminate it first so the insert starts on its own line.
+        if new_lines and not new_lines[-1].endswith("\n"):
+            new_lines[-1] += "\n"
+
         # Insert new content
         for line in new_str_lines:
             new_lines.append(line + "\n")

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands/tools/glob/impl.py

@@ -168,17 +168,14 @@ class GlobExecutor(ToolExecutor[GlobAction, GlobObservation]):
             env=sanitized_env(),
         )
 
-        # Parse output into file paths
-        file_paths = []
+        # Parse output into file paths (ripgrep already sorted by --sortr=modified)
+        lines = []
         if result.stdout:
-            for line in result.stdout.strip().split("\n"):
-                if line:
-                    file_paths.append(str(Path(line).resolve()))
-                    # Limit to first 100 files
-                    if len(file_paths) >= 100:
-                        break
-
-        truncated = len(file_paths) >= 100
+            lines = [line for line in result.stdout.strip().split("\n") if line]
+
+        # Limit to the first 100 files; truncated only if matches were actually dropped
+        truncated = len(lines) > 100
+        file_paths = [str(Path(line).resolve()) for line in lines[:100]]
 
         return file_paths, truncated
 

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands/tools/task/definition.py

@@ -17,6 +17,7 @@ from pydantic.json_schema import SkipJsonSchema
 from rich.text import Text
 
 from openhands.sdk import ImageContent, TextContent
+from openhands.sdk.event.types import UnmaskedID
 from openhands.sdk.logger import get_logger
 from openhands.sdk.subagent import (
     AgentDefinition,
@@ -75,7 +76,7 @@ class TaskAction(Action):
 class TaskObservation(Observation):
     """Observation from a task execution."""
 
-    task_id: str = Field(description="The unique identifier of the task.")
+    task_id: UnmaskedID = Field(description="The unique identifier of the task.")
     subagent: str = Field(description="The subagent of the task.")
     status: str = Field(description="The status of the task.")
 

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands/tools/task_tracker/definition.py

@@ -284,138 +284,11 @@ class TaskTrackerExecutor(ToolExecutor[TaskTrackerAction, TaskTrackerObservation
             pass
 
 
-# Tool definition with detailed description
-TASK_TRACKER_DESCRIPTION = """This tool provides structured task management capabilities for development workflows.
-It enables systematic tracking of work items, progress monitoring, and efficient
-organization of complex development activities.
+TASK_TRACKER_DESCRIPTION = """Maintain a visible task list for complex, multi-phase work, multiple requirements, or an explicit request for a plan. Skip tracking for trivial, atomic, few-step tasks and informational discussion; implement those directly. When uncertain, favor tracking.
 
-The tool maintains visibility into project status and helps communicate
-progress effectively to users.
+At project start, capture requirements as precise, actionable tasks and break complex work into manageable units. View the current list before editing; plan replaces the full list, so preserve relevant tasks and progress. Update the list as work progresses, remove obsolete tasks, and add discovered issues or dependencies.
 
-## Application Guidelines
-
-Utilize this tool in the following situations:
-
-1. Multi-phase development work - When projects involve multiple sequential or
-   parallel activities
-2. Complex implementation tasks - Work requiring systematic planning and
-   coordination across multiple components
-3. Explicit user request for task organization - When users specifically ask
-   for structured task management
-4. Multiple concurrent requirements - When users present several work items
-   that need coordination
-5. Project initiation - Capture and organize user requirements at project start
-6. Work commencement - Update task status to in_progress before beginning
-   implementation. Maintain focus by limiting active work to one task
-7. Task completion - Update status to done and identify any additional work
-   that emerged during implementation
-
-## Situations Where Tool Usage Is Unnecessary
-
-Avoid using this tool when:
-
-1. Single atomic tasks that require no decomposition
-2. Trivial operations where tracking adds no organizational value
-3. Simple activities completable in minimal steps
-4. Pure information exchange or discussion
-
-Note: For single straightforward tasks, proceed with direct implementation
-rather than creating tracking overhead.
-
-## Usage Scenarios
-
-**Scenario A: Feature Development with Validation**
-User request: "Build a user authentication system with login/logout functionality.
-Don't forget to include input validation and error handling!"
-
-Response approach: I'll implement a user authentication system with comprehensive
-validation. Let me organize this work systematically.
-
-*Task breakdown includes:*
-1. Design authentication API endpoints and data models
-2. Implement user login/logout controllers with session management
-3. Add client-side form validation and error display
-4. Create backend input sanitization and security checks
-5. Implement comprehensive error handling for edge cases
-6. Perform integration testing and fix any issues
-
-**Scenario B: Codebase Refactoring**
-User request: "I need to update all instances of the method 'fetchData' to
-'retrieveInformation' throughout the entire project"
-
-Response approach: Let me first analyze your codebase to identify all locations
-where 'fetchData' appears.
-
-*After code analysis*
-
-I've located 12 occurrences of 'fetchData' across 6 files in your project.
-I'll create a systematic plan to update these references.
-
-*Organized task list includes specific file-by-file updates*
-
-**Scenario C: Multi-feature Development**
-User request: "Set up a blog platform with these components: admin dashboard,
-article management, comment system, and user profiles."
-
-Response approach: I'll help build your blog platform. Let me break down these
-components into manageable implementation phases.
-
-*Creates structured plan with each feature decomposed into specific development tasks*
-
-## Counter-examples - Direct Implementation Preferred
-
-**Counter-example A: Simple inquiry**
-User request: "What's the syntax for a for loop in JavaScript?"
-
-Response approach: Here's how to write a for loop in JavaScript:
-
-```javascript
-for (let i = 0; i < array.length; i++) {
-    console.log(array[i]);
-}
-```
-
-*No task tracking needed - single informational response*
-
-**Counter-example B: Minor modification**
-User request: "Please add a docstring to the processPayment function explaining
-its parameters."
-
-Response approach: I'll add a docstring to explain the processPayment function.
-
-*Direct edit without task tracking for simple modification*
-
-## Status Management and Workflow
-
-1. **Status Values**: Track work using these states:
-   - todo: Not yet initiated
-   - in_progress: Currently active (maintain single focus)
-   - done: Successfully completed
-
-2. **Workflow Practices**:
-   - Update status dynamically as work progresses
-   - Mark completion immediately upon task finish
-   - Limit active work to ONE task at any given time
-   - Complete current activities before initiating new ones
-   - Remove obsolete tasks from tracking entirely
-
-3. **Completion Criteria**:
-   - Mark tasks as done only when fully achieved
-   - Keep status as in_progress if errors, blocks, or partial completion exist
-   - Create new tasks for discovered issues or dependencies
-   - Never mark done when:
-       - Test suites are failing
-       - Implementation remains incomplete
-       - Unresolved errors persist
-       - Required resources are unavailable
-
-4. **Task Organization**:
-   - Write precise, actionable descriptions
-   - Decompose complex work into manageable units
-   - Use descriptive, clear naming conventions
-
-When uncertain, favor using this tool. Proactive task management demonstrates
-systematic approach and ensures comprehensive requirement fulfillment."""  # noqa: E501
+Statuses: todo = not started; in_progress = active; done = fully achieved. Mark a task in_progress before starting, keep at most one task in_progress, and finish it before starting another. Mark it done promptly only when completely successful. Leave incomplete, blocked, or failing work in_progress; never mark done while tests fail, errors remain, implementation is partial, or required resources are unavailable."""  # noqa: E501
 
 
 class TaskTrackerTool(ToolDefinition[TaskTrackerAction, TaskTrackerObservation]):

openhands_tools-1.60.0/openhands/tools/terminal/env.py

@@ -0,0 +1,88 @@
+"""Environment helpers for terminal backends."""
+
+import codecs
+import locale
+import os
+import re
+from collections.abc import Mapping
+
+from openhands.sdk.logger import get_logger
+from openhands.sdk.utils import sanitized_env
+
+
+logger = get_logger(__name__)
+
+ENV_VAR_NAME_RE = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
+UTF8_FALLBACK_LOCALE = "C.UTF-8"
+
+
+def normalize_terminal_env(
+    extra_env: Mapping[str, str] | None,
+) -> dict[str, str] | None:
+    """Validate and copy client-provided terminal environment variables."""
+    if extra_env is None:
+        return None
+
+    normalized: dict[str, str] = {}
+    for key, value in extra_env.items():
+        if not isinstance(key, str) or not ENV_VAR_NAME_RE.match(key):
+            raise ValueError(f"Invalid terminal environment variable name: {key!r}")
+        if not isinstance(value, str):
+            raise TypeError(
+                "Terminal environment variable values must be strings: "
+                f"{key!r}={value!r}"
+            )
+        normalized[key] = value
+    return normalized
+
+
+def build_terminal_env(extra_env: Mapping[str, str] | None = None) -> dict[str, str]:
+    """Return the sanitized process environment plus client-provided overrides."""
+    env = sanitized_env()
+    normalized = normalize_terminal_env(extra_env)
+    if normalized:
+        env.update(normalized)
+        env = sanitized_env(env)
+    return env
+
+
+def has_utf8_locale(environ: Mapping[str, str]) -> bool:
+    """Apply tmux's check: TMUX is set, or the first non-empty of LC_ALL,
+    LC_CTYPE, LANG names UTF-8."""
+    if "TMUX" in environ:
+        return True
+    for name in ("LC_ALL", "LC_CTYPE", "LANG"):
+        value = environ.get(name)
+        if value:
+            return "utf-8" in value.lower() or "utf8" in value.lower()
+    return False
+
+
+def ensure_utf8_locale() -> tuple[str, str | None] | None:
+    """Fall back to a UTF-8 locale when the process has none.
+
+    Outside a UTF-8 locale, tmux replaces non-ASCII characters in format output
+    with ``_``, which breaks libtmux's parsing of the ``␞`` separator. As in
+    PEP 538, only LC_CTYPE is set unless LC_ALL overrides it.
+
+    Return the variable that was set and its previous value, or None.
+    """
+    if has_utf8_locale(os.environ):
+        return None
+    # libtmux decodes tmux output with the encoding Python picked at startup,
+    # so a locale set now cannot help if that encoding is not UTF-8.
+    encoding = locale.getpreferredencoding(False)
+    if codecs.lookup(encoding).name != "utf-8":
+        logger.warning(
+            "tmux needs a UTF-8 locale, but Python decodes %s; start the "
+            "process with a UTF-8 locale or PYTHONUTF8=1",
+            encoding,
+        )
+        return None
+    name = "LC_ALL" if os.environ.get("LC_ALL") else "LC_CTYPE"
+    previous = os.environ.get(name)
+    os.environ[name] = UTF8_FALLBACK_LOCALE
+    logger.warning(
+        "No UTF-8 locale set; using %s=%s for tmux", name, UTF8_FALLBACK_LOCALE
+    )
+    return name, previous

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands/tools/terminal/terminal/tmux_pane_pool.py

@@ -26,6 +26,7 @@ from openhands.tools.terminal.constants import (
 )
 from openhands.tools.terminal.env import (
     build_terminal_env,
+    ensure_utf8_locale,
     normalize_terminal_env,
 )
 from openhands.tools.terminal.terminal.process_priority import (
@@ -123,6 +124,8 @@ class TmuxPanePool:
         if self._initialized:
             return
 
+        # Before building env, so the shells get the same locale as tmux.
+        ensure_utf8_locale()
         env = build_terminal_env(self.env)
         session_name = f"openhands-pool-{self.username}-{uuid.uuid4()}"
         # Stale handles must not reach another pool after tmux restarts.

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands/tools/terminal/terminal/tmux_terminal.py

@@ -25,6 +25,7 @@ from openhands.tools.terminal.constants import (
 )
 from openhands.tools.terminal.env import (
     build_terminal_env,
+    ensure_utf8_locale,
     normalize_terminal_env,
 )
 from openhands.tools.terminal.metadata import CmdOutputMetadata
@@ -214,6 +215,8 @@ class TmuxTerminal(TerminalInterface):
         if self._initialized:
             return
 
+        # Before building env, so the shell gets the same locale as tmux.
+        ensure_utf8_locale()
         env = build_terminal_env(self._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.

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands/tools/terminal/terminal/windows_terminal.py

@@ -12,6 +12,8 @@ import time
 from collections import deque
 from collections.abc import Mapping
 
+import psutil
+
 from openhands.sdk.logger import get_logger
 from openhands.tools.terminal.constants import (
     CMD_OUTPUT_PS1_BEGIN,
@@ -348,7 +350,13 @@ class WindowsTerminal(TerminalInterface):
         self._command_running_event.clear()
 
     def _terminate_child_processes(self) -> bool:
-        """Terminate descendants of the persistent PowerShell process."""
+        """Terminate descendants of the persistent PowerShell process.
+
+        Enumerating descendants and killing them through ``psutil`` avoids the
+        WMI query (``Get-CimInstance``) that used to back this method: on a
+        loaded Windows runner that query can exceed the subprocess timeout, so
+        the child that kept a timed-out command alive was never terminated.
+        """
         if (
             platform.system() != "Windows"
             or self.process is None
@@ -356,53 +364,29 @@ class WindowsTerminal(TerminalInterface):
         ):
             return False
 
-        script = f"""
-$root = {self.process.pid}
-$childrenByParent = @{{}}
-Get-CimInstance Win32_Process | ForEach-Object {{
-    $parentId = [int]$_.ParentProcessId
-    if (-not $childrenByParent.ContainsKey($parentId)) {{
-        $childrenByParent[$parentId] = New-Object System.Collections.Generic.List[int]
-    }}
-    $childrenByParent[$parentId].Add([int]$_.ProcessId)
-}}
-$toStop = New-Object System.Collections.Generic.List[int]
-function Add-Descendants([int]$processId) {{
-    if (-not $childrenByParent.ContainsKey($processId)) {{ return }}
-    foreach ($childId in $childrenByParent[$processId]) {{
-        if ($childId -eq $PID) {{ continue }}
-        $toStop.Add($childId)
-        Add-Descendants $childId
-    }}
-}}
-Add-Descendants $root
-for ($i = $toStop.Count - 1; $i -ge 0; $i--) {{
-    Stop-Process -Id $toStop[$i] -Force -ErrorAction SilentlyContinue
-}}
-if ($toStop.Count -gt 0) {{ exit 0 }} else {{ exit 1 }}
-"""
-        startupinfo = None
-        startupinfo_cls = getattr(subprocess, "STARTUPINFO", None)
-        if startupinfo_cls is not None:
-            startupinfo = startupinfo_cls()
-            startupinfo.dwFlags |= getattr(subprocess, "STARTF_USESHOWWINDOW", 0)
-        creationflags = getattr(subprocess, "CREATE_NO_WINDOW", 0)
-
         try:
-            result = subprocess.run(
-                [self.shell_path, "-NoLogo", "-NoProfile", "-Command", script],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                check=False,
-                timeout=5.0,
-                startupinfo=startupinfo,
-                creationflags=creationflags,
-            )
-            return result.returncode == 0
-        except (subprocess.TimeoutExpired, OSError) as exc:
-            logger.debug("Failed to terminate PowerShell child processes: %s", exc)
+            root = psutil.Process(self.process.pid)
+            children = root.children(recursive=True)
+        except (psutil.NoSuchProcess, psutil.AccessDenied) as exc:
+            logger.debug("Failed to enumerate PowerShell descendants: %s", exc)
             return False
 
+        if not children:
+            return False
+
+        # Kill leaves first so parents cannot reparent surviving grandchildren
+        # before they are terminated.
+        terminated = False
+        for child in reversed(children):
+            try:
+                child.kill()
+                terminated = True
+            except (psutil.NoSuchProcess, psutil.AccessDenied) as exc:
+                logger.debug("Failed to terminate child %s: %s", child.pid, exc)
+
+        psutil.wait_procs(children, timeout=_INTERRUPT_GRACE_SECONDS)
+        return terminated
+
     def interrupt(self) -> bool:
         """Interrupt the active command if the process is still alive."""
         if self.process is None or self.process.poll() is not None:

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-tools
-Version: 1.58.2
+Version: 1.60.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
@@ -14,7 +14,8 @@ 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: libtmux>=0.62.0
+Requires-Dist: psutil>=7.2.2
 Requires-Dist: pydantic>=2.13.5
 Requires-Dist: browser-use>=0.8.0
 Requires-Dist: func-timeout>=4.3.5

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/openhands_tools.egg-info/requires.txt

@@ -5,7 +5,8 @@ tree-sitter-bash>=0.23
 binaryornot>=0.6.0
 cachetools
 filelock>=3.20.1
-libtmux>=0.53.0
+libtmux>=0.62.0
+psutil>=7.2.2
 pydantic>=2.13.5
 browser-use>=0.8.0
 func-timeout>=4.3.5

{openhands_tools-1.58.2 → openhands_tools-1.60.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openhands-tools"
-version = "1.58.2"
+version = "1.60.0"
 description = "OpenHands Tools - Runtime tools for AI agents"
 
 requires-python = ">=3.12"
@@ -12,7 +12,8 @@ dependencies = [
     "binaryornot>=0.6.0",
     "cachetools",
     "filelock>=3.20.1",
-    "libtmux>=0.53.0",
+    "libtmux>=0.62.0",
+    "psutil>=7.2.2",
     "pydantic>=2.13.5",
     "browser-use>=0.8.0",
     "func-timeout>=4.3.5",

openhands_tools-1.58.2/openhands/tools/terminal/env.py

@@ -1,39 +0,0 @@
-"""Environment helpers for terminal backends."""
-
-import re
-from collections.abc import Mapping
-
-from openhands.sdk.utils import sanitized_env
-
-
-ENV_VAR_NAME_RE = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
-
-
-def normalize_terminal_env(
-    extra_env: Mapping[str, str] | None,
-) -> dict[str, str] | None:
-    """Validate and copy client-provided terminal environment variables."""
-    if extra_env is None:
-        return None
-
-    normalized: dict[str, str] = {}
-    for key, value in extra_env.items():
-        if not isinstance(key, str) or not ENV_VAR_NAME_RE.match(key):
-            raise ValueError(f"Invalid terminal environment variable name: {key!r}")
-        if not isinstance(value, str):
-            raise TypeError(
-                "Terminal environment variable values must be strings: "
-                f"{key!r}={value!r}"
-            )
-        normalized[key] = value
-    return normalized
-
-
-def build_terminal_env(extra_env: Mapping[str, str] | None = None) -> dict[str, str]:
-    """Return the sanitized process environment plus client-provided overrides."""
-    env = sanitized_env()
-    normalized = normalize_terminal_env(extra_env)
-    if normalized:
-        env.update(normalized)
-        env = sanitized_env(env)
-    return env