hud 0.6.13.dev2__tar.gz → 0.6.14__tar.gz

{hud-0.6.13.dev2 → hud-0.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: hud
-Version: 0.6.13.dev2
+Version: 0.6.14
 Summary: SDK for the HUD platform.
 Project-URL: Homepage, https://github.com/hud-evals/hud-python
 Project-URL: Bug Tracker, https://github.com/hud-evals/hud-python/issues
@@ -47,6 +47,7 @@ Requires-Dist: pillow>=11.0.0
 Requires-Dist: prompt-toolkit==3.0.51
 Requires-Dist: pydantic-settings<3,>=2.2
 Requires-Dist: pydantic<3,>=2.10
+Requires-Dist: python-dotenv<2,>=1.0
 Requires-Dist: questionary==2.1.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.9.0

{hud-0.6.13.dev2 → hud-0.6.14}/hud/__init__.py

@@ -11,6 +11,7 @@ from .clients import connect
 from .environment import Environment
 from .eval import (
     Chat,
+    ComposeProject,
     DockerRuntime,
     Grade,
     HostedRuntime,
@@ -23,6 +24,7 @@ from .eval import (
     RuntimeGPU,
     RuntimeLimits,
     RuntimeResources,
+    RuntimeTPU,
     SubprocessRuntime,
     SyncPlan,
     Task,
@@ -35,6 +37,7 @@ from .version import __version__
 
 __all__ = [
     "Chat",
+    "ComposeProject",
     "DockerRuntime",
     "Environment",
     "Grade",
@@ -48,6 +51,7 @@ __all__ = [
     "RuntimeGPU",
     "RuntimeLimits",
     "RuntimeResources",
+    "RuntimeTPU",
     "SubprocessRuntime",
     "SyncPlan",
     "Task",

{hud-0.6.13.dev2 → hud-0.6.14}/hud/agents/claude/sdk/agent.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 import json
 import logging
 import shlex
+from contextlib import AsyncExitStack
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, cast
 
@@ -22,7 +23,7 @@ from hud.settings import settings
 from hud.types import Step
 
 if TYPE_CHECKING:
-    from hud.capabilities import RFBClient, SSHClient
+    from hud.capabilities import SSHClient
     from hud.eval.run import Run
 
 logger = logging.getLogger(__name__)
@@ -70,98 +71,112 @@ def build_remote_invocation(shell: str, run_cmd: str) -> RemoteInvocation:
 class ClaudeSDKAgent(Agent):
     """Runs ``claude`` CLI over SSH inside the env workspace.
 
-    Stateless w.r.t. the env: driven by ``await agent(run)``. SSH and RFB are
-    opened live off the run (we
-    drive them); MCP servers are read as raw bindings and written into the CLI's
-    MCP config (the CLI connects to them itself).
+    Stateless w.r.t. the env: driven by ``await agent(run)``. SSH is opened
+    live off the run. Environment MCP bindings are used directly; computer MCP
+    servers are bridged over the run's SSH connection.
     """
 
     config: ClaudeSDKConfig
 
     def __init__(self, config: ClaudeSDKConfig | None = None) -> None:
         self.config = config or ClaudeSDKConfig()
-        self._ssh: SSHClient | None = None
-        self._mcp_servers: dict[str, dict[str, Any]] = {}
-        self._shell = "bash"
 
     async def __call__(self, run: Run) -> None:
-        self._mcp_servers = {}
+        mcp_servers: dict[str, dict[str, Any]] = {}
         manifest = run.client.manifest
         bindings = manifest.bindings if manifest is not None else []
         families = {c.protocol.split("/", 1)[0] for c in bindings}
 
         if "ssh" not in families:
             raise RuntimeError("ClaudeSDKAgent requires an SSH capability")
-        self._ssh = cast("SSHClient", await run.client.open("ssh"))
-        self._shell = self._ssh.capability.params.get("shell", "bash")
-
-        for cap in bindings:
-            family = cap.protocol.split("/", 1)[0]
-            if family == "mcp":
-                token = cap.params.get("auth_token")
-                transport = "http" if cap.params["transport"] == "streamable-http" else "sse"
-                server_config: dict[str, Any] = {"type": transport, "url": cap.url}
-                if token:
-                    server_config["headers"] = {"Authorization": f"Bearer {token}"}
-                self._mcp_servers[cap.name] = server_config
-            elif family == "rfb":
-                from hud.agents.claude.sdk.computer_mcp import serve_computer_mcp
-
-                rfb = cast("RFBClient", await run.client.open("rfb"))
-                port = await serve_computer_mcp(rfb, self.config.screenshot_encoding)
-                self._mcp_servers["computer-use"] = {
-                    "type": "http",
-                    "url": f"http://127.0.0.1:{port}/mcp",
-                }
-
-        await self._exec(
-            run,
-            prompt=run.prompt_text,
-            max_steps=self.config.max_steps,
-            system_prompt=self.config.system_prompt,
-        )
+        ssh = cast("SSHClient", await run.client.open("ssh"))
+        shell = ssh.capability.params.get("shell", "bash")
+
+        rfb_bindings = [cap for cap in bindings if cap.protocol.split("/", 1)[0] == "rfb"]
+        async with AsyncExitStack() as resources:
+            for cap in bindings:
+                family = cap.protocol.split("/", 1)[0]
+                if family == "mcp":
+                    token = cap.params.get("auth_token")
+                    transport = "http" if cap.params["transport"] == "streamable-http" else "sse"
+                    server_config: dict[str, Any] = {"type": transport, "url": cap.url}
+                    if token:
+                        server_config["headers"] = {"Authorization": f"Bearer {token}"}
+                    if cap.name in mcp_servers:
+                        raise RuntimeError(f"duplicate MCP server name {cap.name!r}")
+                    mcp_servers[cap.name] = server_config
+                elif family == "rfb":
+                    from hud.agents.claude.sdk.computer_mcp import bridge_computer_mcp
+
+                    server_name = (
+                        "computer-use" if len(rfb_bindings) == 1 else f"computer-use-{cap.name}"
+                    )
+                    if server_name in mcp_servers:
+                        raise RuntimeError(f"duplicate MCP server name {server_name!r}")
+                    routed = run.client.binding(cap.name)
+                    mcp_servers[server_name] = await resources.enter_async_context(
+                        bridge_computer_mcp(
+                            ssh,
+                            routed,
+                            self.config.screenshot_encoding,
+                            shell=shell,
+                        )
+                    )
+
+            await self._exec(
+                run,
+                ssh=ssh,
+                shell=shell,
+                mcp_servers=mcp_servers,
+                prompt=run.prompt_text,
+                max_steps=self.config.max_steps,
+                system_prompt=self.config.system_prompt,
+            )
 
     async def _exec(
         self,
         run: Run,
         *,
+        ssh: SSHClient,
+        shell: str,
+        mcp_servers: dict[str, dict[str, Any]],
         prompt: str,
         max_steps: int = -1,
         system_prompt: str | None = None,
     ) -> None:
-        assert self._ssh is not None
+        mcp_config_path = await self._write_mcp_config(ssh, mcp_servers)
 
-        mcp_config_path = await self._write_mcp_config()
-
-        await self._ssh.write_text(".hud_prompt.txt", prompt)
+        await ssh.write_text(".hud_prompt.txt", prompt)
 
         run_cmd = self._build_cli_command(
+            shell=shell,
             prompt=prompt,
             max_steps=max_steps,
             system_prompt=system_prompt,
             mcp_config_path=mcp_config_path,
         )
 
-        invocation = build_remote_invocation(self._shell, run_cmd)
+        invocation = build_remote_invocation(shell, run_cmd)
         if invocation.script_name is not None:
             assert invocation.script_body is not None
             # cmd.exe mangles inline quotes, so the command rides a batch file.
-            await self._ssh.write_text(invocation.script_name, invocation.script_body)
+            await ssh.write_text(invocation.script_name, invocation.script_body)
 
         full_cmd = invocation.command
         logger.info("SSH exec claude CLI (%d chars)", len(full_cmd))
         logger.info("Full command: %s", full_cmd)
 
-        completed = await self._ssh.conn.run(full_cmd, check=False)
+        completed = await ssh.run(full_cmd, check=False)
         stdout = completed.stdout if isinstance(completed.stdout, str) else ""
         stderr = completed.stderr if isinstance(completed.stderr, str) else ""
+        returncode = completed.returncode
 
-        logger.info("exit=%s stdout=%d stderr=%d", completed.exit_status, len(stdout), len(stderr))
+        logger.info("returncode=%s stdout=%d stderr=%d", returncode, len(stdout), len(stderr))
 
-        if completed.exit_status != 0 and not stdout.strip():
-            error = stderr or f"claude CLI exited with status {completed.exit_status}"
+        if returncode != 0 and not stdout.strip():
+            error = stderr or f"claude CLI exited with return code {returncode}"
             run.trace.status = "error"
-            run.trace.extra.update({"exit_status": completed.exit_status, "stderr": stderr})
+            run.trace.extra.update({"returncode": returncode, "stderr": stderr})
             run.record(Step(source="system", error=error))
             return
 
@@ -192,27 +207,31 @@ class ClaudeSDKAgent(Agent):
 
         return env
 
-    async def _write_mcp_config(self) -> str | None:
+    async def _write_mcp_config(
+        self,
+        ssh: SSHClient,
+        mcp_servers: dict[str, dict[str, Any]],
+    ) -> str | None:
         """Write MCP config into the workspace and return its path."""
-        if not self._mcp_servers or self._ssh is None:
+        if not mcp_servers:
             return None
-        mcp_json = json.dumps({"mcpServers": self._mcp_servers}, indent=2)
+        mcp_json = json.dumps({"mcpServers": mcp_servers}, indent=2)
         path = ".hud_mcp_config.json"
-        await self._ssh.write_text(path, mcp_json)
+        await ssh.write_text(path, mcp_json)
         logger.info("Wrote MCP config")
         return path
 
     def _build_cli_command(
         self,
         *,
+        shell: str,
         prompt: str,
         max_steps: int,
         system_prompt: str | None,
         mcp_config_path: str | None = None,
     ) -> str:
         env_vars = self._build_env_vars()
-        is_win = self._shell in WINDOWS_SHELLS
-        self._win_redirect = False
+        is_win = shell in WINDOWS_SHELLS
 
         # Raw args list (no shell quoting) — used directly for Windows Python launcher.
         base_args: list[str] = [

hud-0.6.14/hud/agents/claude/sdk/computer_mcp.py

@@ -0,0 +1,282 @@
+"""MCP server that exposes computer-use over VNC.
+
+Single tool ``computer`` backed by ``ClaudeComputerTool`` / ``RFBTool``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import logging
+import os
+import secrets
+import shlex
+import sys
+from contextlib import asynccontextmanager
+from pathlib import PurePosixPath
+from typing import TYPE_CHECKING, Any
+
+import asyncssh
+import fastmcp
+from pydantic import TypeAdapter
+
+from hud.capabilities import Capability
+from hud.capabilities.rfb import RFBClient, ScreenshotEncoding, WebPScreenshotEncoding
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Mapping
+
+    from hud.capabilities import SSHClient
+
+_DEFAULT_SCREENSHOT_ENCODING = WebPScreenshotEncoding()
+RFB_CAPABILITY_ENV = "HUD_RFB_CAPABILITY"
+SCREENSHOT_ENCODING_ENV = "HUD_SCREENSHOT_ENCODING"
+_PROCESS_CLOSE_TIMEOUT_S = 5.0
+_BRIDGE_READY_TIMEOUT_S = 5.0
+_REMOTE_TMP = PurePosixPath("/") / "tmp"
+
+logger = logging.getLogger(__name__)
+
+
+def create_computer_mcp(
+    rfb: RFBClient,
+    screenshot_encoding: ScreenshotEncoding = _DEFAULT_SCREENSHOT_ENCODING,
+) -> fastmcp.FastMCP:
+    """Build a FastMCP server with one ``computer`` tool backed by ``rfb``."""
+
+    mcp = fastmcp.FastMCP("computer-use")
+
+    @mcp.tool()
+    async def computer(
+        action: str,
+        coordinate: str | None = None,
+        text: str | None = None,
+        scroll_direction: str | None = None,
+        scroll_amount: int | None = None,
+        start_coordinate: str | None = None,
+        duration: float | None = None,
+        repeat: int | None = None,
+        region: str | None = None,
+    ) -> list[Any]:
+        """Control a remote screen — screenshot, click, type, key, scroll, move, drag, wait, zoom.
+
+        Actions: screenshot, left_click, right_click, middle_click, double_click,
+        triple_click, mouse_move, move, type, key, scroll, left_click_drag, drag,
+        wait, hold_key, cursor_position, zoom, left_mouse_down, left_mouse_up.
+
+        Returns the resulting screenshot image so you can see the screen state.
+        """
+        import mcp.types as mcp_types
+
+        from hud.agents.claude.tools.computer import ClaudeComputerTool
+        from hud.agents.tools.base import AgentToolSpec
+
+        arguments: dict[str, Any] = {"action": action}
+        if coordinate is not None:
+            try:
+                arguments["coordinate"] = json.loads(coordinate)
+            except json.JSONDecodeError:
+                arguments["coordinate"] = coordinate
+        if text is not None:
+            arguments["text"] = text
+        if scroll_direction is not None:
+            arguments["scroll_direction"] = scroll_direction
+        if scroll_amount is not None:
+            arguments["scroll_amount"] = scroll_amount
+        if start_coordinate is not None:
+            try:
+                arguments["start_coordinate"] = json.loads(start_coordinate)
+            except json.JSONDecodeError:
+                arguments["start_coordinate"] = start_coordinate
+        if duration is not None:
+            arguments["duration"] = duration
+        if repeat is not None:
+            arguments["repeat"] = repeat
+        if region is not None:
+            try:
+                arguments["region"] = json.loads(region)
+            except json.JSONDecodeError:
+                arguments["region"] = region
+
+        spec = AgentToolSpec(api_type="computer", api_name="computer")
+        tool = ClaudeComputerTool(
+            spec=spec,
+            client=rfb,
+            screenshot_encoding=screenshot_encoding,
+        )
+        result = await tool.execute(arguments)
+
+        # Return content blocks directly so the CLI/model sees real images.
+        blocks: list[Any] = []
+        for block in result.content:
+            if isinstance(block, mcp_types.ImageContent):
+                blocks.append(
+                    mcp_types.ImageContent(
+                        type="image",
+                        data=block.data,
+                        mimeType=block.mimeType,
+                    ),
+                )
+            elif isinstance(block, mcp_types.TextContent):
+                blocks.append(mcp_types.TextContent(type="text", text=block.text))
+        if not blocks:
+            blocks.append(mcp_types.TextContent(type="text", text="ok"))
+        if result.isError:
+            blocks.insert(0, mcp_types.TextContent(type="text", text="ERROR"))
+        return blocks
+
+    return mcp
+
+
+def _required_env(environ: Mapping[str, str], name: str) -> str:
+    try:
+        return environ[name]
+    except KeyError as exc:
+        raise RuntimeError(f"missing required environment variable {name}") from exc
+
+
+async def run_computer_mcp(environ: Mapping[str, str] = os.environ) -> None:
+    """Run computer-use over stdio in a controller-side child process."""
+    raw_manifest = json.loads(_required_env(environ, RFB_CAPABILITY_ENV))
+    if not isinstance(raw_manifest, dict):
+        raise ValueError(f"{RFB_CAPABILITY_ENV} must contain a JSON object")
+    capability = Capability.from_manifest(raw_manifest)
+    if capability.protocol.split("/", 1)[0] != "rfb":
+        raise ValueError(f"{RFB_CAPABILITY_ENV} must describe an RFB capability")
+    screenshot_encoding = TypeAdapter(ScreenshotEncoding).validate_json(
+        _required_env(environ, SCREENSHOT_ENCODING_ENV)
+    )
+
+    rfb = await RFBClient.connect(capability)
+    try:
+        await create_computer_mcp(rfb, screenshot_encoding).run_async(
+            transport="stdio",
+            show_banner=False,
+        )
+    finally:
+        await rfb.close()
+
+
+@asynccontextmanager
+async def bridge_computer_mcp(
+    ssh: SSHClient,
+    capability: Capability,
+    screenshot_encoding: ScreenshotEncoding = _DEFAULT_SCREENSHOT_ENCODING,
+    *,
+    shell: str,
+) -> AsyncIterator[dict[str, Any]]:
+    """Bridge a controller-side computer MCP process into a remote POSIX shell."""
+    if shell in {"cmd", "powershell"}:
+        raise RuntimeError("ClaudeSDKAgent computer use requires a POSIX workspace")
+
+    token = secrets.token_hex(16)
+    request_path = str(_REMOTE_TMP / f"hud-computer-{token}.request")
+    response_path = str(_REMOTE_TMP / f"hud-computer-{token}.response")
+    bridge = await ssh.create_process(_bridge_command(request_path, response_path))
+    local: asyncio.subprocess.Process | None = None
+    tasks: list[asyncio.Task[None]] = []
+    try:
+        ready = await asyncio.wait_for(bridge.stderr.readline(), _BRIDGE_READY_TIMEOUT_S)
+        if ready != b"ready\n":
+            detail = ready.decode("utf-8", "replace").strip()
+            raise RuntimeError(detail or "computer MCP SSH bridge did not become ready")
+
+        environ = {
+            **os.environ,
+            RFB_CAPABILITY_ENV: json.dumps(capability.to_manifest(), separators=(",", ":")),
+            SCREENSHOT_ENCODING_ENV: screenshot_encoding.model_dump_json(),
+        }
+        local = await asyncio.create_subprocess_exec(
+            sys.executable,
+            "-m",
+            "hud.agents.claude.sdk.computer_mcp",
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=environ,
+        )
+        assert local.stdin is not None
+        assert local.stdout is not None
+        assert local.stderr is not None
+        tasks = [
+            asyncio.create_task(_copy_stream(bridge.stdout, local.stdin)),
+            asyncio.create_task(_copy_stream(local.stdout, bridge.stdin)),
+            asyncio.create_task(_log_stream(bridge.stderr, "SSH bridge")),
+            asyncio.create_task(_log_stream(local.stderr, "computer MCP")),
+        ]
+        yield _relay_config(request_path, response_path)
+    finally:
+        for task in tasks:
+            task.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+        bridge.stdin.close()
+        bridge.channel.close()
+        with contextlib.suppress(OSError, TimeoutError, asyncssh.Error):
+            await asyncio.wait_for(bridge.wait_closed(), _PROCESS_CLOSE_TIMEOUT_S)
+        if local is not None:
+            if local.stdin is not None:
+                local.stdin.close()
+            if local.returncode is None:
+                with contextlib.suppress(ProcessLookupError):
+                    local.terminate()
+            try:
+                await asyncio.wait_for(local.wait(), _PROCESS_CLOSE_TIMEOUT_S)
+            except TimeoutError:
+                with contextlib.suppress(ProcessLookupError):
+                    local.kill()
+                with contextlib.suppress(TimeoutError):
+                    await asyncio.wait_for(local.wait(), _PROCESS_CLOSE_TIMEOUT_S)
+
+
+def _bridge_command(request_path: str, response_path: str) -> str:
+    request = shlex.quote(request_path)
+    response = shlex.quote(response_path)
+    cleanup = shlex.quote(f"rm -f -- {request} {response}")
+    return (
+        "set -eu; umask 077; "
+        f"rm -f -- {request} {response}; mkfifo -- {request} {response}; "
+        f"trap {cleanup} EXIT HUP INT TERM; "
+        "printf 'ready\\n' >&2; "
+        f"cat {request} & reader=$!; cat > {response}; wait $reader"
+    )
+
+
+def _relay_config(request_path: str, response_path: str) -> dict[str, Any]:
+    request = shlex.quote(request_path)
+    response = shlex.quote(response_path)
+    script = f"cat {response} & reader=$!; cat > {request}; wait $reader"
+    return {"type": "stdio", "command": "sh", "args": ["-c", script]}
+
+
+async def _copy_stream(
+    reader: asyncio.StreamReader | asyncssh.SSHReader[bytes],
+    writer: asyncio.StreamWriter | asyncssh.SSHWriter[bytes],
+) -> None:
+    try:
+        while chunk := await reader.read(65536):
+            writer.write(chunk)
+            await writer.drain()
+    finally:
+        writer.close()
+
+
+async def _log_stream(
+    reader: asyncio.StreamReader | asyncssh.SSHReader[bytes],
+    source: str,
+) -> None:
+    while line := await reader.readline():
+        logger.warning("%s: %s", source, line.decode("utf-8", "replace").rstrip())
+
+
+if __name__ == "__main__":
+    asyncio.run(run_computer_mcp())
+
+
+__all__ = [
+    "RFB_CAPABILITY_ENV",
+    "SCREENSHOT_ENCODING_ENV",
+    "bridge_computer_mcp",
+    "create_computer_mcp",
+    "run_computer_mcp",
+]

{hud-0.6.13.dev2 → hud-0.6.14}/hud/agents/claude/tools/computer.py

@@ -222,12 +222,20 @@ class ClaudeComputerTool(RFBTool):
                 await self.type_text(text)
 
             case "key":
-                keys = _split_keys(arguments.get("text"))
-                if not keys:
+                text = arguments.get("text")
+                # xdotool syntax: space-separated sequential presses, + binds a chord
+                chords = (
+                    [chord for part in text.split() if (chord := _split_keys(part))]
+                    if isinstance(text, str)
+                    else []
+                )
+                if not chords:
                     return tool_err("`text` (key chord) is required for key")
                 repeat = arguments.get("repeat")
                 count = repeat if isinstance(repeat, int) and repeat > 0 else 1
-                await self.press_keys(keys, count=min(count, 100))
+                for _ in range(min(count, 100)):
+                    for chord in chords:
+                        await self.press_keys(chord)
 
             case "hold_key":
                 keys = _split_keys(arguments.get("text"))

{hud-0.6.13.dev2 → hud-0.6.14}/hud/agents/openai/tools/coding.py

@@ -2,11 +2,13 @@
 
 from __future__ import annotations
 
+import shlex
 from typing import Any, cast
 
 import mcp.types as mcp_types
 
 from hud.agents.tools import SSHTool
+from hud.agents.tools.ssh import MAX_SHELL_OUTPUT_LENGTH, bound_shell_output
 from hud.types import MCPToolResult
 
 from .base import OpenAIToolSpec
@@ -16,9 +18,6 @@ OPENAI_SHELL_SPEC = OpenAIToolSpec(
     api_name="shell",
 )
 
-MAX_SHELL_OUTPUT_LENGTH = 10 * 1024 * 1024
-TRUNCATION_MARKER = "[truncated]"
-
 
 class OpenAIShellTool(SSHTool):
     name = "shell"
@@ -75,21 +74,23 @@ class OpenAIShellTool(SSHTool):
         outputs: list[dict[str, Any]] = []
         display_outputs: list[str] = []
         is_error = False
-        env_arguments: dict[str, Any] = {}
+        timeout_seconds: float | None = None
         timeout_ms = arguments.get("timeout_ms")
         if isinstance(timeout_ms, int):
-            env_arguments["timeout_seconds"] = timeout_ms / 1000.0
+            timeout_seconds = timeout_ms / 1000.0
 
         for command in command_list:
-            if env_arguments.get("timeout_seconds"):
-                full_cmd = f"timeout {int(env_arguments['timeout_seconds'])} {command}"
-            else:
-                full_cmd = command
-            completed = await self.client.conn.run(full_cmd, check=False)
+            full_cmd = (
+                f"timeout {timeout_seconds:g}s bash -lc {shlex.quote(command)}"
+                if timeout_seconds
+                else command
+            )
+            completed = await self.client.run(full_cmd, check=False)
             stdout = completed.stdout if isinstance(completed.stdout, str) else ""
             stderr = completed.stderr if isinstance(completed.stderr, str) else ""
-            exit_code = completed.exit_status if completed.exit_status is not None else 1
-            stdout, stderr = _bound_output(stdout, stderr, max_output_length)
+            exit_code = completed.returncode
+            assert exit_code is not None
+            stdout, stderr = bound_shell_output(stdout, stderr, max_output_length)
             outputs.append(shell_output(stdout, stderr, exit_code))
             display_outputs.append(stdout + stderr)
             is_error = is_error or bool(exit_code)
@@ -118,31 +119,6 @@ def _shell_result(
     )
 
 
-def _bound_output(stdout: str, stderr: str, limit: int) -> tuple[str, str]:
-    total_length = len(stdout) + len(stderr)
-    if total_length <= limit:
-        return stdout, stderr
-
-    marker = TRUNCATION_MARKER[:limit]
-    available = limit - len(marker)
-    prefix_length = (available + 1) // 2
-    suffix_length = available // 2
-
-    stdout_prefix = stdout[:prefix_length]
-    stderr_prefix = stderr[: max(0, prefix_length - len(stdout))]
-    stderr_suffix = stderr[-suffix_length:] if suffix_length else ""
-    stdout_suffix_length = max(0, suffix_length - len(stderr))
-    stdout_suffix = stdout[-stdout_suffix_length:] if stdout_suffix_length else ""
-
-    if len(stdout_prefix) + len(stdout_suffix) < len(stdout):
-        stdout = stdout_prefix + marker + stdout_suffix
-        stderr = stderr_prefix + stderr_suffix
-    else:
-        stdout = stdout_prefix + stdout_suffix
-        stderr = stderr_prefix + marker + stderr_suffix
-    return stdout, stderr
-
-
 def shell_output(stdout: str, stderr: str, exit_code: int) -> dict[str, Any]:
     return {
         "stdout": stdout,