hud-python 0.5.24__tar.gz → 0.5.25__tar.gz

{hud_python-0.5.24 → hud_python-0.5.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hud-python
-Version: 0.5.24
+Version: 0.5.25
 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

{hud_python-0.5.24 → hud_python-0.5.25}/hud/agents/openai_chat.py

@@ -88,6 +88,14 @@ class OpenAIChatAgent(MCPAgent):
             )
 
         self.completion_kwargs = dict(self.config.completion_kwargs)
+
+        # If a specific checkpoint is requested, inject it into extra_body
+        # so the HUD gateway routes to the exact checkpoint for inference.
+        if self.config.checkpoint:
+            extra_body = self.completion_kwargs.get("extra_body") or {}
+            extra_body["checkpoint"] = self.config.checkpoint
+            self.completion_kwargs["extra_body"] = extra_body
+
         self.mcp_schemas: list[ChatCompletionToolParam] = []
         self.hud_console = HUDConsole(logger=logger)
 

hud_python-0.5.25/hud/agents/tests/test_integration_test_agent.py

@@ -0,0 +1,42 @@
+"""Tests for IntegrationTestRunner."""
+
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from hud.agents.misc import IntegrationTestRunner
+
+
+def test_runs_all_integration_test_calls(mock_eval_context) -> None:
+    """Runner executes each configured integration test call in order."""
+
+    async def _run() -> None:
+        mock_eval_context._integration_test_calls = [
+            ("tool_a", {"x": 1}),
+            ("tool_b", {"y": "ok"}),
+        ]
+
+        runner = IntegrationTestRunner.create()
+        result = await runner.run(mock_eval_context)
+
+        assert result.done is True
+        assert mock_eval_context.tool_calls == [
+            ("tool_a", {"x": 1}),
+            ("tool_b", {"y": "ok"}),
+        ]
+
+    asyncio.run(_run())
+
+
+def test_raises_when_no_integration_test_calls(mock_eval_context) -> None:
+    """Runner fails fast when no integration calls are configured."""
+
+    async def _run() -> None:
+        runner = IntegrationTestRunner.create()
+
+        with pytest.raises(ValueError, match="integration_test_tool"):
+            await runner.run(mock_eval_context)
+
+    asyncio.run(_run())

{hud_python-0.5.24 → hud_python-0.5.25}/hud/agents/types.py

@@ -119,6 +119,13 @@ class OpenAIChatConfig(BaseAgentConfig):
 
     model_name: str = "OpenAI Chat"
     model: str = Field(default="gpt-5-mini", validation_alias=_model_alias)
+    checkpoint: str | None = Field(
+        default=None,
+        description="Specific checkpoint name for inference routing. "
+        "When set, the HUD gateway routes to this exact checkpoint rather than "
+        "the model's current active checkpoint. Passed as 'checkpoint' in the "
+        "request body's extra_body.",
+    )
     openai_client: Any = None  # AsyncOpenAI
     api_key: str | None = None
     base_url: str | None = None

{hud_python-0.5.24 → hud_python-0.5.25}/hud/cli/dev.py

@@ -15,6 +15,7 @@ from pathlib import Path
 from typing import Any
 
 import typer
+from rich.markup import escape
 
 from hud.utils.hud_console import HUDConsole
 
@@ -49,41 +50,42 @@ def show_dev_server_info(
 
     # Server section
     hud_console.section_title("Server")
-    hud_console.info(f"{hud_console.sym.ITEM} {server_name}")
+    hud_console.print(f"{hud_console.sym.ITEM} {escape(server_name)}")
     if transport == "http":
-        hud_console.info(f"{hud_console.sym.ITEM} http://localhost:{port}/mcp")
+        hud_console.print(f"{hud_console.sym.ITEM} http://localhost:{port}/mcp")
     else:
-        hud_console.info(f"{hud_console.sym.ITEM} (stdio)")
+        hud_console.print(f"{hud_console.sym.ITEM} (stdio)")
 
     # Quick Links (only for HTTP mode)
     if transport == "http":
         hud_console.section_title("Quick Links")
-        hud_console.info(f"{hud_console.sym.ITEM} Docs: http://localhost:{port}/docs")
-        hud_console.info(f"{hud_console.sym.ITEM} Cursor:")
+        hud_console.print(f"{hud_console.sym.ITEM} Docs: http://localhost:{port}/docs")
+        hud_console.print(f"{hud_console.sym.ITEM} Cursor:")
         # Display the Cursor link on its own line to prevent wrapping
         hud_console.link(cursor_deeplink)
 
         # Show eval endpoint if in Docker mode
         if docker_mode:
-            hud_console.info(
+            hud_console.print(
                 f"{hud_console.sym.ITEM} Eval API: http://localhost:{port}/eval (POST)"
             )
 
         # Show debugging URLs from telemetry
         if telemetry:
             if "live_url" in telemetry:
-                hud_console.info(f"{hud_console.sym.ITEM} Live URL: {telemetry['live_url']}")
+                url = escape(telemetry["live_url"])
+                hud_console.print(f"{hud_console.sym.ITEM} Live URL: {url}")
             if "vnc_url" in telemetry:
-                hud_console.info(f"{hud_console.sym.ITEM} VNC URL: {telemetry['vnc_url']}")
+                hud_console.print(f"{hud_console.sym.ITEM} VNC URL: {escape(telemetry['vnc_url'])}")
             if "cdp_url" in telemetry:
-                hud_console.info(f"{hud_console.sym.ITEM} CDP URL: {telemetry['cdp_url']}")
+                hud_console.print(f"{hud_console.sym.ITEM} CDP URL: {escape(telemetry['cdp_url'])}")
 
         # Check for VNC (browser environment)
         if env_dir and (env_dir / "environment" / "server.py").exists():
             try:
                 content = (env_dir / "environment" / "server.py").read_text()
                 if "x11vnc" in content.lower() or "vnc" in content.lower():
-                    hud_console.info(f"{hud_console.sym.ITEM} VNC: http://localhost:8080/vnc.html")
+                    hud_console.print(f"{hud_console.sym.ITEM} VNC: http://localhost:8080/vnc.html")
             except Exception:  # noqa: S110
                 pass
 
@@ -91,13 +93,13 @@ def show_dev_server_info(
         if inspector or interactive:
             hud_console.info("")
             if inspector:
-                hud_console.info(f"{hud_console.sym.SUCCESS} Inspector launching...")
+                hud_console.print(f"{hud_console.sym.SUCCESS} Inspector launching...")
             if interactive:
-                hud_console.info(f"{hud_console.sym.SUCCESS} Interactive mode enabled")
+                hud_console.print(f"{hud_console.sym.SUCCESS} Interactive mode enabled")
 
     hud_console.info("")
     if hot_reload_enabled:
-        hud_console.info(f"{hud_console.sym.SUCCESS} Hot-reload enabled")
+        hud_console.print(f"{hud_console.sym.SUCCESS} Hot-reload enabled")
     else:
         hud_console.info("Hot-reload disabled")
         hud_console.dim_info("Tip", "Pass --watch/-w to enable hot-reload")
@@ -230,7 +232,7 @@ async def run_mcp_module(
         hud_console.error(f"Failed to import module '{module_name}'")
         hud_console.info(f"Error: {e}")
         hud_console.info("")
-        hud_console.info("[bold cyan]Troubleshooting:[/bold cyan]")
+        hud_console.print("[bold cyan]Troubleshooting:[/bold cyan]")
         hud_console.info("  • Verify module exists and is importable")
         hud_console.info("  • Check for __init__.py in module directory")
         hud_console.info("  • Check for import errors in the module")
@@ -238,7 +240,7 @@ async def run_mcp_module(
             import traceback
 
             hud_console.info("")
-            hud_console.info("[bold cyan]Full traceback:[/bold cyan]")
+            hud_console.print("[bold cyan]Full traceback:[/bold cyan]")
             hud_console.info(traceback.format_exc())
         sys.exit(1)
 
@@ -271,14 +273,14 @@ async def run_mcp_module(
         available = [k for k in dir(module) if not k.startswith("_")]
         hud_console.info(f"Available in module: {available}")
         hud_console.info("")
-        hud_console.info("[bold cyan]Expected structure:[/bold cyan]")
+        hud_console.print("[bold cyan]Expected structure:[/bold cyan]")
         hud_console.info("  from hud.environment import Environment")
         hud_console.info("  env = Environment('my-env')  # or mcp = ...")
         raise AttributeError(f"Module '{module_name}' must define 'mcp', 'env', or 'environment'")
 
     # Only show full header on first run, brief message on reload
     if is_reload:
-        hud_console.info(f"{hud_console.sym.SUCCESS} Reloaded")
+        hud_console.print(f"{hud_console.sym.SUCCESS} Reloaded")
         # Run server without showing full UI
     else:
         # Show full header on first run
@@ -344,7 +346,7 @@ async def run_mcp_module(
         env_dir = cwd.parent / "environment"
         if env_dir.exists() and (env_dir / "server.py").exists():
             hud_console.info("")
-            hud_console.info(
+            hud_console.print(
                 f"{hud_console.sym.FLOW} Don't forget to start the environment "
                 "backend in another terminal:"
             )
@@ -976,11 +978,11 @@ def run_mcp_dev_server(
         if module is None:
             hud_console.error("Could not auto-detect module in current directory")
             hud_console.info("")
-            hud_console.info("[bold cyan]Expected:[/bold cyan]")
+            hud_console.print("[bold cyan]Expected:[/bold cyan]")
             hud_console.info("  • __init__.py file in current directory")
             hud_console.info("  • Module must define 'mcp' or 'env' variable")
             hud_console.info("")
-            hud_console.info("[bold cyan]Examples:[/bold cyan]")
+            hud_console.print("[bold cyan]Examples:[/bold cyan]")
             hud_console.info("  hud dev controller")
             hud_console.info("  cd controller && hud dev")
             hud_console.info("  hud dev --docker  # For Docker-based environments")

{hud_python-0.5.24 → hud_python-0.5.25}/hud/cli/flows/dev.py

@@ -6,6 +6,8 @@ import json
 import logging
 from typing import Any
 
+from rich.markup import escape
+
 from hud.settings import settings
 from hud.shared.requests import make_request
 from hud.utils.hud_console import hud_console
@@ -136,13 +138,13 @@ def show_dev_ui(
     # Show other info below
     label = "Base image" if is_docker else "Server"
     hud_console.info("")
-    hud_console.info(f"{hud_console.sym.ITEM} {label}: {server_name}")
-    hud_console.info(f"{hud_console.sym.ITEM} Cursor:")
+    hud_console.print(f"{hud_console.sym.ITEM} {escape(label)}: {escape(server_name)}")
+    hud_console.print(f"{hud_console.sym.ITEM} Cursor:")
     # Display the Cursor link on its own line to prevent wrapping
     hud_console.link(cursor_deeplink)
     hud_console.info("")
     if hot_reload_enabled:
-        hud_console.info(f"{hud_console.sym.SUCCESS} Hot-reload enabled")
+        hud_console.print(f"{hud_console.sym.SUCCESS} Hot-reload enabled")
     else:
         hud_console.info("Hot-reload disabled")
         hud_console.dim_info("Tip", "Pass --watch/-w to enable hot-reload")

{hud_python-0.5.24 → hud_python-0.5.25}/hud/cli/list_func.py

@@ -6,6 +6,7 @@ from datetime import datetime
 
 import typer
 import yaml
+from rich.markup import escape
 from rich.table import Table
 
 from hud.utils.hud_console import HUDConsole
@@ -59,8 +60,8 @@ def list_environments(
         else:
             hud_console.info("No environments found in local registry.")
             hud_console.info("")
-            hud_console.info("Pull environments with: [cyan]hud pull <org/name:tag>[/cyan]")
-            hud_console.info("Build environments with: [cyan]hud build[/cyan]")
+            hud_console.print("Pull environments with: [cyan]hud pull <org/name:tag>[/cyan]")
+            hud_console.print("Build environments with: [cyan]hud build[/cyan]")
         return
 
     # Collect all environments using the registry helper
@@ -131,8 +132,8 @@ def list_environments(
     if not environments:
         hud_console.info("No environments found matching criteria.")
         hud_console.info("")
-        hud_console.info("Pull environments with: [cyan]hud pull <org/name:tag>[/cyan]")
-        hud_console.info("Build environments with: [cyan]hud build[/cyan]")
+        hud_console.print("Pull environments with: [cyan]hud pull <org/name:tag>[/cyan]")
+        hud_console.print("Build environments with: [cyan]hud build[/cyan]")
         return
 
     # Create table
@@ -179,16 +180,16 @@ def list_environments(
         example_env = environments[0]
         example_ref = f"{example_env['name']}:{example_env['tag']}"
 
-        hud_console.info(f"Run an environment: [cyan]hud run {example_ref}[/cyan]")
-        hud_console.info(f"Analyze tools: [cyan]hud analyze {example_ref}[/cyan]")
-        hud_console.info(f"Debug server: [cyan]hud debug {example_ref}[/cyan]")
+        hud_console.print(f"Run an environment: [cyan]hud run {escape(example_ref)}[/cyan]")
+        hud_console.print(f"Analyze tools: [cyan]hud analyze {escape(example_ref)}[/cyan]")
+        hud_console.print(f"Debug server: [cyan]hud debug {escape(example_ref)}[/cyan]")
 
-    hud_console.info("Pull more environments: [cyan]hud pull <org/name:tag>[/cyan]")
-    hud_console.info("Build new environments: [cyan]hud build[/cyan]")
+    hud_console.print("Pull more environments: [cyan]hud pull <org/name:tag>[/cyan]")
+    hud_console.print("Build new environments: [cyan]hud build[/cyan]")
 
     if verbose:
         hud_console.info("")
-        hud_console.info(f"[dim]Registry location: {env_dir}[/dim]")
+        hud_console.print(f"[dim]Registry location: {escape(str(env_dir))}[/dim]")
 
 
 def list_command(

{hud_python-0.5.24 → hud_python-0.5.25}/hud/cli/remove.py

@@ -162,7 +162,7 @@ def remove_all_environments(
 
     hud_console.info("")
     hud_console.info("Note: Docker images may still exist locally.")
-    hud_console.info("To remove them, use: [cyan]docker image prune[/cyan]")
+    hud_console.print("To remove them, use: [cyan]docker image prune[/cyan]")
 
 
 def remove_command(

{hud_python-0.5.24 → hud_python-0.5.25}/hud/cli/tests/test_build.py

@@ -60,12 +60,12 @@ class TestIncrementVersion:
     def test_increment_minor(self):
         """Test incrementing minor version."""
         assert increment_version("1.2.3", "minor") == "1.3.0"
-        assert increment_version("0.5.24", "minor") == "0.6.0"
+        assert increment_version("0.5.25", "minor") == "0.6.0"
 
     def test_increment_major(self):
         """Test incrementing major version."""
         assert increment_version("1.2.3", "major") == "2.0.0"
-        assert increment_version("0.5.24", "major") == "1.0.0"
+        assert increment_version("0.5.25", "major") == "1.0.0"
 
     def test_increment_with_v_prefix(self):
         """Test incrementing version with v prefix."""

{hud_python-0.5.24 → hud_python-0.5.25}/hud/eval/context.py

@@ -356,6 +356,12 @@ class EvalContext(Environment):
             quiet=quiet,
         )
 
+        # v5 validation overrides any environment-level integration calls.
+        if task.validation is not None:
+            ctx._integration_test_calls = [
+                (call.name, call.arguments or {}) for call in task.validation
+            ]
+
         # Store task info for scenario execution
         ctx._task = task
 

{hud_python-0.5.24 → hud_python-0.5.25}/hud/eval/tests/test_context.py

@@ -187,3 +187,141 @@ class TestEvalContextFromEnvironment:
         assert ctx.variants == {"model": "gpt-4o"}
         assert ctx.group_id == "group-123"
         assert ctx.index == 5
+
+
+class TestEvalContextFromTask:
+    """Tests for EvalContext.from_task factory."""
+
+    def test_v5_validation_populates_integration_calls(self) -> None:
+        """Task.validation is mapped to integration test calls for replay."""
+        from hud.environment import Environment
+        from hud.eval.task import Task
+        from hud.types import MCPToolCall
+
+        env = Environment("test-env")
+        validation_calls = [
+            MCPToolCall(name="tool_a", arguments={"x": 1}),
+            MCPToolCall(name="tool_b", arguments={"y": "ok"}),
+        ]
+        task = Task(
+            env=env,
+            scenario="demo",
+            args={},
+            validation=validation_calls,
+        )
+
+        ctx = EvalContext.from_task(task)
+        assert ctx._integration_test_calls == [
+            ("tool_a", {"x": 1}),
+            ("tool_b", {"y": "ok"}),
+        ]
+
+    def test_v5_validation_overrides_environment_integration_calls(self) -> None:
+        """Task.validation takes precedence over env-level integration calls."""
+        from hud.environment import Environment
+        from hud.eval.task import Task
+        from hud.types import MCPToolCall
+
+        env = Environment("test-env")
+        env._integration_test_calls = [("old_tool", {"stale": True})]
+
+        task = Task(
+            env=env,
+            scenario="demo",
+            args={},
+            validation=[MCPToolCall(name="new_tool", arguments={"fresh": True})],
+        )
+
+        ctx = EvalContext.from_task(task)
+        assert ctx._integration_test_calls == [("new_tool", {"fresh": True})]
+
+    def test_v5_empty_validation_clears_environment_integration_calls(self) -> None:
+        """Task.validation=[] still overrides env-level integration calls."""
+        from hud.environment import Environment
+        from hud.eval.task import Task
+
+        env = Environment("test-env")
+        env._integration_test_calls = [("old_tool", {"stale": True})]
+
+        task = Task(
+            env=env,
+            scenario="demo",
+            args={},
+            validation=[],
+        )
+
+        ctx = EvalContext.from_task(task)
+
+        assert ctx._integration_test_calls == []
+
+    def test_v4_integration_test_tool_remains_supported(self) -> None:
+        """Legacy integration_test_tool still populates integration calls."""
+        from hud.eval.task import Task
+
+        task = Task.from_v4(
+            {
+                "prompt": "test",
+                "mcp_config": {"server": {"url": "http://localhost"}},
+                "evaluate_tool": {"name": "check", "arguments": {}},
+                "integration_test_tool": [
+                    {"name": "legacy_tool", "arguments": {"v": 1}},
+                ],
+            }
+        )
+
+        ctx = EvalContext.from_task(task)
+        assert ctx._integration_test_calls == [("legacy_tool", {"v": 1})]
+
+    def test_v5_validation_replays_with_integration_runner(self) -> None:
+        """IntegrationTestRunner executes v5 Task.validation calls via EvalContext.from_task."""
+        import asyncio
+
+        from mcp import types as mcp_types
+
+        from hud.agents.misc import IntegrationTestRunner
+        from hud.environment import Environment
+        from hud.eval.task import Task
+        from hud.types import MCPToolCall, MCPToolResult
+
+        executed_calls: list[tuple[str, dict[str, object]]] = []
+
+        async def _run() -> None:
+            env = Environment("test-env")
+            validation_calls = [
+                MCPToolCall(name="tool_a", arguments={"x": 1}),
+                MCPToolCall(name="tool_b", arguments={"y": "ok"}),
+            ]
+            task = Task(
+                env=env,
+                scenario="demo",
+                args={},
+                validation=validation_calls,
+            )
+
+            ctx = EvalContext.from_task(task)
+
+            async def fake_call_tool(call, /, **kwargs):
+                if isinstance(call, tuple):
+                    name = str(call[0])
+                    arguments = dict(call[1]) if len(call) > 1 else {}
+                else:
+                    name = str(call)
+                    arguments = {}
+                executed_calls.append((name, arguments))
+                return MCPToolResult(
+                    content=[mcp_types.TextContent(type="text", text="ok")],
+                    isError=False,
+                )
+
+            ctx.call_tool = fake_call_tool  # type: ignore[method-assign]
+
+            runner = IntegrationTestRunner.create()
+            result = await runner.run(ctx)
+            assert result.done is True
+
+        asyncio.run(_run())
+
+        assert executed_calls == [
+            ("tool_a", {"x": 1}),
+            ("tool_b", {"y": "ok"}),
+        ]

{hud_python-0.5.24 → hud_python-0.5.25}/hud/tools/coding/session.py

@@ -153,18 +153,20 @@ class BashSession:
         assert self._process.stdout
         assert self._process.stderr
 
-        # Send command with sentinel for exit code capture
-        # Platform-specific syntax for command chaining and exit code
+        # Send command with sentinel for exit code capture.
+        # Use a newline before the sentinel echo (not ";" or "&") so that:
+        # 1. Heredoc delimiters aren't corrupted (e.g. EOF; echo '...' wouldn't match EOF)
+        # 2. The echo is a standalone command, avoiding syntax errors from leading ";"
         if sys.platform == "win32":
             if capture_exit_code:
-                cmd_line = f"{command} & echo {self._sentinel}%errorlevel%\n"
+                cmd_line = f"{command}\necho {self._sentinel}%errorlevel%\n"
             else:
-                cmd_line = f"{command} & echo {self._sentinel}\n"
+                cmd_line = f"{command}\necho {self._sentinel}\n"
         else:
             if capture_exit_code:
-                cmd_line = f"{command}; echo '{self._sentinel}'$?\n"
+                cmd_line = f"{command}\necho '{self._sentinel}'$?\n"
             else:
-                cmd_line = f"{command}; echo '{self._sentinel}'\n"
+                cmd_line = f"{command}\necho '{self._sentinel}'\n"
 
         self._process.stdin.write(cmd_line.encode())
         await self._process.stdin.drain()

{hud_python-0.5.24 → hud_python-0.5.25}/hud/tools/coding/tests/test_bash.py

@@ -73,6 +73,87 @@ class TestBashSession:
         assert result.error == ""
 
 
+class TestBashSessionHeredoc:
+    """Tests for heredoc handling in ClaudeBashSession."""
+
+    @pytest.mark.asyncio
+    async def test_sentinel_on_own_line_after_heredoc(self):
+        """Sentinel echo must be on its own line so heredoc terminators aren't corrupted."""
+        session = _BashSession()
+        session._started = True
+
+        mock_process = MagicMock()
+        mock_process.returncode = None
+        mock_process.stdin = MagicMock()
+        mock_process.stdin.write = MagicMock()
+        mock_process.stdin.drain = AsyncMock()
+        mock_process.stdout = MagicMock()
+        mock_process.stdout.readuntil = AsyncMock(return_value=b"hello\n<<exit>>\n")
+        mock_process.stderr = MagicMock()
+        mock_process.stderr.read = AsyncMock(return_value=b"")
+
+        session._process = mock_process
+
+        heredoc_cmd = "python3 << 'EOF'\nprint('hello')\nEOF"
+        await session.run(heredoc_cmd)
+
+        written = mock_process.stdin.write.call_args[0][0].decode()
+
+        # EOF must be followed by newline, then the echo — never "EOF;" or "EOF echo"
+        assert "EOF\necho '<<exit>>'\n" in written
+        assert "EOF;" not in written
+        assert "EOF echo" not in written
+
+    @pytest.mark.asyncio
+    async def test_heredoc_integration(self):
+        """Integration test: a real heredoc command completes without hanging."""
+        from hud.tools.coding.bash import ClaudeBashSession
+
+        session = ClaudeBashSession()
+        session._timeout = 5.0  # fail fast if sentinel is broken
+        await session.start()
+        try:
+            result = await session.run("cat << 'EOF'\nhello from heredoc\nEOF")
+            assert result.output is not None
+            assert "hello from heredoc" in result.output
+        finally:
+            session.stop()
+
+    @pytest.mark.asyncio
+    async def test_heredoc_with_python_integration(self):
+        """Integration test: python heredoc executes and returns output."""
+        from hud.tools.coding.bash import ClaudeBashSession
+
+        session = ClaudeBashSession()
+        session._timeout = 5.0
+        await session.start()
+        try:
+            result = await session.run("python3 << 'PYEOF'\nprint('result:', 2 + 2)\nPYEOF")
+            assert result.output is not None
+            assert "result: 4" in result.output
+        finally:
+            session.stop()
+
+    @pytest.mark.asyncio
+    async def test_command_after_heredoc_still_works(self):
+        """Integration test: session is usable for further commands after a heredoc."""
+        from hud.tools.coding.bash import ClaudeBashSession
+
+        session = ClaudeBashSession()
+        session._timeout = 5.0
+        await session.start()
+        try:
+            r1 = await session.run("cat << 'EOF'\nfirst\nEOF")
+            assert r1.output is not None
+            assert "first" in r1.output
+
+            r2 = await session.run("echo second")
+            assert r2.output is not None
+            assert "second" in r2.output
+        finally:
+            session.stop()
+
+
 class TestBashTool:
     """Tests for BashTool."""