@mseep/open-computer-use 1.0.0

package/tests/fixtures/cli/claude_v0.9.2.0_stdout.json

@@ -0,0 +1,32 @@
+{
+  "metadata": {
+    "captured_from": "v0.9.2.0",
+    "source": "computer-use-server/mcp_tools.py:_format_sub_agent_result lines 819-845 input shape",
+    "captured_at": "2026-04-26",
+    "purpose": "Phase 5 TEST-03 — ClaudeAdapter.parse_result roundtrip; mirrors the shape claude CLI emits as the LAST line of --output-format json. The byte-compat invariant is enforced jointly with claude_v0.9.2.0_argv.json (the argv side) and the parse_result test in test_cli_adapters.py (the parse side)."
+  },
+  "happy_path": {
+    "stdout": "{\"type\": \"system\", \"subtype\": \"init\"}\n{\"type\": \"assistant\", \"message\": {\"role\": \"assistant\"}}\n{\"type\": \"result\", \"result\": \"Task done. Files written.\", \"total_cost_usd\": 0.1234, \"num_turns\": 7, \"is_error\": false, \"session_id\": \"abc-123-uuid\"}",
+    "stderr": "",
+    "returncode": 0,
+    "expected": {
+      "text": "Task done. Files written.",
+      "cost_usd": 0.1234,
+      "turns": 7,
+      "is_error": false,
+      "session_id": "abc-123-uuid"
+    }
+  },
+  "zero_cost_path": {
+    "stdout": "{\"type\": \"result\", \"result\": \"x\", \"total_cost_usd\": 0.0, \"num_turns\": 0, \"is_error\": false, \"session_id\": \"\"}",
+    "stderr": "",
+    "returncode": 0,
+    "expected": {
+      "text": "x",
+      "cost_usd": null,
+      "turns": null,
+      "is_error": false,
+      "session_id": null
+    }
+  }
+}

package/tests/fixtures/cli/codex_run.jsonl

@@ -0,0 +1,4 @@
+{"type": "turn.started", "turn_id": "t-1"}
+{"type": "item.started", "item": {"type": "message", "id": "m-1"}}
+{"type": "item.completed", "item": {"type": "message", "id": "m-1", "content": [{"type": "text", "text": "Hello from codex. The answer is 42."}]}}
+{"type": "turn.completed", "turn_id": "t-1", "usage": {"input_tokens": 1234, "output_tokens": 56}}

package/tests/fixtures/cli/opencode_run.jsonl

@@ -0,0 +1,6 @@
+{"type": "session-started", "session_id": "ignored-by-parser"}
+{"type": "step-start", "step": 1}
+{"type": "step-finish", "step": 1, "cost": 0.0042, "usage": {"input_tokens": 800, "output_tokens": 30}}
+{"type": "step-start", "step": 2}
+{"type": "step-finish", "step": 2, "cost": 0.0011}
+{"type": "assistant-message-completed", "text": "Hello from opencode. Answer: forty-two."}

package/tests/integration/README.md

@@ -0,0 +1,56 @@
+# Integration tests
+
+End-to-end tests against a real `computer-use-server` container that spawns real workspace containers via the host Docker socket. Mirrors the prod Compose/Helm setup 1-to-1 — no mocks at the HTTP boundary, no mocks at the Docker boundary.
+
+## What's covered
+
+| Concern | Test file | Why it matters |
+|---|---|---|
+| `MCP_API_KEY` auth (valid / missing / wrong) | `test_mcp_auth.py` | Refactoring out the `verify_mcp_auth` dependency would silently make `/mcp` public. Unit tests can't catch this — the dependency is wired at app construction. |
+| `tools/list` matches expected name set | `test_mcp_tools.py` | A typo (`bash_tool` → `bash_too1`) ships green today; this pins the surface. |
+| `tools/call bash_tool` end-to-end echo | `test_mcp_tools.py` | Catches workspace image misconfig, Docker socket missing, response wrapping regressions, sub-agent dispatch breakage. |
+| `/health` is unauthenticated and returns `healthy` | `test_mcp_tools.py` | k8s probes break if either changes. |
+| Workspace container has the prod labels (managed-by, chat-id, tool) | `test_workspace_lifecycle.py` | Drift in any of these labels breaks the cleanup cron's filter in prod. |
+| `/mnt/user-data/{uploads,outputs}` bind mounts | `test_workspace_lifecycle.py` | Compose USER_DATA_BASE_PATH must round-trip into the spawned container. |
+
+## How to run
+
+### From a clean checkout (test harness owns the stack)
+
+```bash
+# One-shot: build images, bring stack up, run tests, tear down.
+pytest tests/integration/ -v
+```
+
+First run rebuilds the orchestrator image (~3 min) and may pull the workspace image. Subsequent runs reuse the local cache.
+
+### Against an already-running stack (CI matrix, dev iteration)
+
+```bash
+docker compose -f docker-compose.test.yml up -d --build
+export OCU_TEST_BASE_URL=http://localhost:18081
+export OCU_TEST_MCP_API_KEY=test-token-do-not-use-in-prod
+pytest tests/integration/ -v
+# … iterate on a single test …
+pytest tests/integration/test_mcp_auth.py::test_invalid_token_returns_401 -v
+# tear down explicitly
+docker compose -f docker-compose.test.yml down -v --remove-orphans
+```
+
+## Cleanup
+
+Every integration test uses a `chat_id` that starts with the `itest-` prefix (see the `chat_id` fixture). The orchestrator names spawned workspace containers `owui-chat-<chat_id>`, so the session finalizer reaps orphans by container-name filter (`owui-chat-itest-*`) plus the prod label `managed-by=mcp-computer-use-orchestrator`. This deliberately avoids a production-side env knob just for cleanup — production code does not know tests exist.
+
+Worst-case manual cleanup, scoped to integration-test containers only:
+
+```bash
+docker ps -a --filter 'name=owui-chat-itest-' \
+            --filter 'label=managed-by=mcp-computer-use-orchestrator' -q \
+  | xargs -r docker rm -f
+```
+
+Do **not** filter only by `managed-by=mcp-computer-use-orchestrator` — that would also remove the developer's actively-running prod workspace containers on the same machine.
+
+## CI
+
+`.github/workflows/build.yml` runs this suite on every push to `main` and every PR. The job builds the workspace + server images locally (no GHCR pull), brings up the compose stack, runs pytest, and always tears down regardless of result.

package/tests/integration/conftest.py

@@ -0,0 +1,280 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""
+Integration test fixtures.
+
+These tests run against a *real* computer-use-server container started via
+docker-compose.test.yml. The orchestrator binds the host Docker socket and
+spawns real workspace containers, exactly like prod.
+
+Two ways to drive the stack:
+
+  1. Test harness owns lifecycle (default):
+     pytest brings the stack up at session start and tears it down at the end.
+     `make integration-test` or plain `pytest tests/integration/` from a clean
+     checkout. Slow on first run (image build), fast afterwards (cache reuse).
+
+  2. CI / external stack:
+     export OCU_TEST_BASE_URL=http://localhost:18081
+     export OCU_TEST_MCP_API_KEY=test-token-do-not-use-in-prod
+     Stack is assumed to be already up; pytest only runs assertions and
+     cleanup. Keeps build/test concerns separate in the CI matrix.
+
+In both modes the session finalizer reaps every workspace container whose
+name starts with `owui-chat-itest-` (the prefix every chat_id fixture uses)
+so a failing test does not leave orphans on the host between runs. No
+production-side env knob is needed — the prefix alone uniquely identifies
+test containers.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import time
+import uuid
+from pathlib import Path
+from typing import Iterator
+
+import httpx
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+COMPOSE_FILE = REPO_ROOT / "docker-compose.test.yml"
+
+# Constant matches docker-compose.test.yml — keep these in sync.
+DEFAULT_API_KEY = "test-token-do-not-use-in-prod"
+DEFAULT_BASE_URL = "http://localhost:18081"
+HEALTH_TIMEOUT_S = 60
+HEALTH_POLL_INTERVAL_S = 1.0
+COMPOSE_TIMEOUT_S = int(os.environ.get("OCU_TEST_COMPOSE_TIMEOUT_S", "900"))
+
+
+def _have_docker() -> bool:
+    try:
+        return subprocess.run(
+            ["docker", "version"], capture_output=True, timeout=5
+        ).returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def _wait_for_health(url: str, timeout: float) -> None:
+    deadline = time.monotonic() + timeout
+    last_err: Exception | None = None
+    while time.monotonic() < deadline:
+        try:
+            r = httpx.get(f"{url}/health", timeout=2.0)
+            if r.status_code == 200 and r.json().get("status") == "healthy":
+                return
+        except Exception as e:
+            last_err = e
+        time.sleep(HEALTH_POLL_INTERVAL_S)
+    raise RuntimeError(
+        f"orchestrator at {url}/health never became healthy in {timeout}s "
+        f"(last error: {last_err})"
+    )
+
+
+def _compose(cmd: list[str], env: dict | None = None) -> subprocess.CompletedProcess:
+    full = ["docker", "compose", "-f", str(COMPOSE_FILE), *cmd]
+    try:
+        return subprocess.run(
+            full,
+            capture_output=True,
+            text=True,
+            timeout=COMPOSE_TIMEOUT_S,
+            env={**os.environ, **(env or {})},
+        )
+    except subprocess.TimeoutExpired as exc:
+        return subprocess.CompletedProcess(
+            args=full,
+            returncode=124,
+            stdout=(exc.stdout or ""),
+            stderr=f"docker compose timed out after {COMPOSE_TIMEOUT_S}s",
+        )
+
+
+# Every integration test uses a chat_id that starts with this prefix (see the
+# `chat_id` fixture). The orchestrator's container naming convention is
+# `owui-chat-<chat_id>`, so prefixing the chat_id lets us reap orphans by
+# container-name filter — no production-side code change needed.
+TEST_CHAT_ID_PREFIX = "itest-"
+TEST_CONTAINER_NAME_PREFIX = f"owui-chat-{TEST_CHAT_ID_PREFIX}"
+
+
+def _reap_test_workspace_containers() -> int:
+    """Force-remove workspace containers spawned by this test session.
+
+    Identified by container-name prefix (`owui-chat-itest-`), which only ever
+    appears when tests run — no prod chat-id starts with `itest-`. This avoids
+    a production-side env knob just for test cleanup.
+
+    Belt-and-braces: tests usually end their own chat sessions, but a crashed
+    test or a SIGINT mid-suite would otherwise leak containers on the runner.
+    Returns count of containers actually removed.
+    """
+    import sys
+
+    try:
+        listing = subprocess.run(
+            ["docker", "ps", "-aq",
+             "--filter", f"name={TEST_CONTAINER_NAME_PREFIX}",
+             "--filter", "label=managed-by=mcp-computer-use-orchestrator"],
+            capture_output=True, text=True, timeout=30,
+        )
+    except subprocess.TimeoutExpired:
+        print("[conftest] WARN: docker ps timed out during reap", file=sys.stderr)
+        return 0
+    ids = [i for i in listing.stdout.strip().splitlines() if i]
+    if not ids:
+        return 0
+    try:
+        rm = subprocess.run(
+            ["docker", "rm", "-f", *ids],
+            capture_output=True, text=True, timeout=60,
+        )
+    except subprocess.TimeoutExpired:
+        print("[conftest] WARN: docker rm -f timed out during reap", file=sys.stderr)
+        return 0
+    if rm.returncode != 0:
+        # Don't raise — finalizer must not mask the underlying test failure.
+        print(
+            f"[conftest] WARN: docker rm -f failed (rc={rm.returncode}): "
+            f"{rm.stderr.strip()[:300]}",
+            file=sys.stderr,
+        )
+        try:
+            recheck = subprocess.run(
+                ["docker", "ps", "-aq",
+                 "--filter", f"name={TEST_CONTAINER_NAME_PREFIX}",
+                 "--filter", "label=managed-by=mcp-computer-use-orchestrator"],
+                capture_output=True, text=True, timeout=30,
+            )
+        except subprocess.TimeoutExpired:
+            print("[conftest] WARN: docker ps recheck timed out", file=sys.stderr)
+            return 0
+        remaining = len([i for i in recheck.stdout.strip().splitlines() if i])
+        return len(ids) - remaining
+    return len(ids)
+
+
+@pytest.fixture(scope="session")
+def orchestrator() -> Iterator[dict]:
+    """Yield {url, api_key} after ensuring the stack is healthy.
+
+    Skips the entire suite if Docker is unavailable — these tests are real
+    integration, not unit tests, and pretending otherwise hides regressions.
+    """
+    if not _have_docker():
+        pytest.skip("Docker daemon not reachable; integration tests require Docker")
+
+    external = os.environ.get("OCU_TEST_BASE_URL")
+    api_key = os.environ.get("OCU_TEST_MCP_API_KEY", DEFAULT_API_KEY)
+
+    if external:
+        # CI / dev opted to manage the stack themselves. Just wait + yield.
+        _wait_for_health(external, HEALTH_TIMEOUT_S)
+        try:
+            yield {"url": external, "api_key": api_key}
+        finally:
+            reaped = _reap_test_workspace_containers()
+            if reaped:
+                print(f"[conftest] reaped {reaped} orphan workspace containers")
+        return
+
+    # Owned-stack mode. Build + up + wait. Always teardown.
+    up = _compose(["up", "-d", "--build"])
+    if up.returncode != 0:
+        pytest.fail(f"docker compose up failed:\nSTDOUT:\n{up.stdout}\nSTDERR:\n{up.stderr}")
+
+    try:
+        _wait_for_health(DEFAULT_BASE_URL, HEALTH_TIMEOUT_S)
+        yield {"url": DEFAULT_BASE_URL, "api_key": api_key}
+    finally:
+        import sys
+        reaped = _reap_test_workspace_containers()
+        if reaped:
+            print(f"[conftest] reaped {reaped} orphan workspace containers")
+        down = _compose(["down", "-v", "--remove-orphans"])
+        if down.returncode != 0:
+            # Don't raise — we're in a finalizer and an exception here would
+            # mask the actual test failure. But do surface the daemon error so
+            # leftover networks/volumes on the runner are diagnosable.
+            print(
+                f"[conftest] WARN: docker compose down failed (rc={down.returncode}): "
+                f"{down.stderr.strip()[:300]}",
+                file=sys.stderr,
+            )
+
+
+@pytest.fixture()
+def client(orchestrator) -> Iterator[httpx.Client]:
+    """HTTP client preconfigured with auth + sensible timeout for tool calls."""
+    headers = {
+        "Authorization": f"Bearer {orchestrator['api_key']}",
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+    }
+    with httpx.Client(base_url=orchestrator["url"], headers=headers, timeout=120.0) as c:
+        yield c
+
+
+@pytest.fixture()
+def chat_id() -> str:
+    """A fresh chat-id per test — each gets its own workspace container.
+
+    The `itest-` prefix is load-bearing: the session finalizer uses it (via
+    `owui-chat-itest-*` container-name match) to find and reap orphans
+    without touching prod containers a developer may have running locally.
+    """
+    return f"{TEST_CHAT_ID_PREFIX}{uuid.uuid4().hex[:12]}"
+
+
+def mcp_request(method: str, params: dict | None = None, req_id: int = 1) -> dict:
+    """Build a JSON-RPC 2.0 request envelope matching the MCP spec."""
+    payload: dict = {"jsonrpc": "2.0", "id": req_id, "method": method}
+    if params is not None:
+        payload["params"] = params
+    return payload
+
+
+def parse_mcp_response(resp: httpx.Response) -> dict:
+    """Return the decoded JSON-RPC envelope from either an SSE or JSON body.
+
+    FastMCP's streamable_http_app picks the response format based on the
+    request's Accept header — we send both, and the server tends to reply
+    with text/event-stream. The single data: line carries the actual envelope.
+    """
+    import json
+
+    ctype = resp.headers.get("content-type", "")
+    body = resp.text
+    # Detect SSE only by Content-Type or by an `event:`/`data:` line at the
+    # *start* of a line. The original substring-anywhere check was too loose:
+    # a perfectly valid JSON-RPC payload like {"result":{"data":"x"}} contains
+    # the literal `"data:` and would be misrouted to the SSE branch.
+    is_sse = (
+        "text/event-stream" in ctype
+        or body.lstrip().startswith("event:")
+        or any(line.startswith("data:") for line in body.splitlines())
+    )
+    if is_sse and "text/event-stream" in ctype:
+        # Trust Content-Type when present — only then walk SSE frames.
+        for line in body.splitlines():
+            if line.startswith("data:"):
+                return json.loads(line[len("data:"):].strip())
+        raise AssertionError(f"SSE body had no data: line. Raw:\n{body[:500]}")
+    return json.loads(body)
+
+
+def call_mcp(client: httpx.Client, chat_id: str, method: str,
+             params: dict | None = None, req_id: int = 1) -> dict:
+    """POST /mcp with the X-Chat-Id header the orchestrator requires."""
+    resp = client.post(
+        "/mcp",
+        json=mcp_request(method, params, req_id),
+        headers={"X-Chat-Id": chat_id},
+    )
+    return {"status": resp.status_code, "headers": dict(resp.headers),
+            "envelope": parse_mcp_response(resp) if resp.status_code == 200 else None,
+            "body": resp.text}

package/tests/integration/pytest.ini

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: BUSL-1.1
+# Copyright (c) 2025 Open Computer Use Contributors
+#
+# Integration-only pytest config. The unit suite under tests/orchestrator/
+# uses default discovery; this file scopes timeouts and markers to the
+# integration directory only so a stray @pytest.mark.timeout(180) on a
+# unit test wouldn't accidentally inherit our slow-test budget.
+[pytest]
+testpaths = .
+addopts = -v --tb=short --strict-markers
+markers =
+    integration: real Docker + real HTTP; runs against docker-compose.test.yml
+timeout = 60

package/tests/integration/test_mcp_auth.py

@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""
+Auth contract: POST /mcp requires Bearer MCP_API_KEY when configured.
+
+Regression target: a refactor that drops the verify_mcp_auth dependency would
+make /mcp open to the world. Unit tests don't catch this because the dependency
+is wired at app construction time. This suite hits the real container.
+"""
+from __future__ import annotations
+
+import httpx
+import pytest
+
+from conftest import mcp_request
+
+
+def _init_payload() -> dict:
+    return mcp_request(
+        "initialize",
+        {
+            "protocolVersion": "2025-03-26",
+            "capabilities": {},
+            "clientInfo": {"name": "integration-test", "version": "0.0.0"},
+        },
+    )
+
+
+@pytest.mark.integration
+def test_valid_token_returns_200(orchestrator, chat_id):
+    """Sanity: the well-known good token from compose env is accepted."""
+    with httpx.Client(base_url=orchestrator["url"], timeout=10.0) as c:
+        r = c.post(
+            "/mcp",
+            json=_init_payload(),
+            headers={
+                "Authorization": f"Bearer {orchestrator['api_key']}",
+                "Content-Type": "application/json",
+                "Accept": "application/json, text/event-stream",
+                "X-Chat-Id": chat_id,
+            },
+        )
+    assert r.status_code == 200, f"expected 200, got {r.status_code}: {r.text[:300]}"
+
+
+@pytest.mark.integration
+def test_missing_authorization_returns_401(orchestrator, chat_id):
+    """No Authorization header → 401 with WWW-Authenticate: Bearer."""
+    with httpx.Client(base_url=orchestrator["url"], timeout=10.0) as c:
+        r = c.post(
+            "/mcp",
+            json=_init_payload(),
+            headers={
+                "Content-Type": "application/json",
+                "Accept": "application/json, text/event-stream",
+                "X-Chat-Id": chat_id,
+            },
+        )
+    # FastAPI/HTTPBearer returns 403 by default when auto_error=True and the
+    # header is missing; the codepath in app.py overrides to 401 explicitly.
+    # Either status proves auth is enforced; pin to 401 because that's what
+    # the code documents.
+    assert r.status_code == 401, (
+        f"expected 401 for missing auth header, got {r.status_code}: {r.text[:300]}"
+    )
+    assert "bearer" in r.headers.get("www-authenticate", "").lower()
+
+
+@pytest.mark.integration
+def test_invalid_token_returns_401(orchestrator, chat_id):
+    """Wrong token → 401, never 200."""
+    with httpx.Client(base_url=orchestrator["url"], timeout=10.0) as c:
+        r = c.post(
+            "/mcp",
+            json=_init_payload(),
+            headers={
+                "Authorization": "Bearer obviously-wrong-token",
+                "Content-Type": "application/json",
+                "Accept": "application/json, text/event-stream",
+                "X-Chat-Id": chat_id,
+            },
+        )
+    assert r.status_code == 401, (
+        f"expected 401 for bad token, got {r.status_code}: {r.text[:300]}"
+    )

package/tests/integration/test_mcp_tools.py

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""
+MCP protocol: tools/list shape + tools/call bash_tool end-to-end.
+
+Regression target: a typo in @mcp.tool() registration (bash_tool → bash_too1)
+or a refactor that breaks the streamable_http_app's response wrapping. Both
+land in prod silently today.
+"""
+from __future__ import annotations
+
+import pytest
+
+from conftest import call_mcp
+
+# Snapshot of tools registered in mcp_tools.py. Update intentionally when the
+# tool surface changes; a drift here means somebody renamed/added/removed a tool
+# and the team should agree before shipping.
+EXPECTED_TOOL_NAMES = {"bash_tool", "str_replace", "create_file", "view", "sub_agent"}
+
+
+def _initialize(client, chat_id) -> None:
+    """MCP requires initialize before any other method."""
+    r = call_mcp(client, chat_id, "initialize", {
+        "protocolVersion": "2025-03-26",
+        "capabilities": {},
+        "clientInfo": {"name": "integration-test", "version": "0.0.0"},
+    })
+    assert r["status"] == 200, f"initialize failed: {r['body'][:300]}"
+
+
+@pytest.mark.integration
+def test_tools_list_matches_expected_set(client, chat_id):
+    _initialize(client, chat_id)
+    r = call_mcp(client, chat_id, "tools/list", req_id=2)
+    assert r["status"] == 200, f"tools/list HTTP {r['status']}"
+
+    env = r["envelope"]
+    assert env["jsonrpc"] == "2.0"
+    assert env["id"] == 2
+    assert "result" in env, f"missing result: {env}"
+    tools = env["result"]["tools"]
+    names = {t["name"] for t in tools}
+
+    assert names == EXPECTED_TOOL_NAMES, (
+        f"tool set drifted.\n  expected: {sorted(EXPECTED_TOOL_NAMES)}\n  got:      {sorted(names)}"
+    )
+    # Each tool must declare a non-empty inputSchema. A registration that
+    # forgets the schema is technically valid for FastMCP but breaks clients.
+    for t in tools:
+        assert isinstance(t.get("inputSchema"), dict) and t["inputSchema"], (
+            f"tool {t['name']!r} has empty inputSchema"
+        )
+
+
+@pytest.mark.integration
+@pytest.mark.timeout(180)  # first call cold-starts a workspace container
+def test_bash_tool_echo_roundtrip(client, chat_id):
+    """The smallest possible real tool call. Catches:
+    - workspace image missing / unpullable
+    - Docker socket misconfigured
+    - container spawn racing /health
+    - response wrapping (content[0].text) regressions
+    """
+    _initialize(client, chat_id)
+
+    r = call_mcp(client, chat_id, "tools/call", {
+        "name": "bash_tool",
+        "arguments": {
+            "command": "echo hello-from-integration",
+            "description": "integration smoke: echo",
+        },
+    }, req_id=2)
+    assert r["status"] == 200, f"tools/call HTTP {r['status']}: {r['body'][:400]}"
+
+    env = r["envelope"]
+    assert env["jsonrpc"] == "2.0"
+    assert "result" in env, f"got JSON-RPC error instead of result: {env}"
+    result = env["result"]
+
+    # MCP tool-level error path: result.isError=True is a successful protocol
+    # response carrying a domain-level failure. Treat as fail for this smoke.
+    assert not result.get("isError"), f"bash_tool reported isError=True: {result}"
+
+    content = result.get("content", [])
+    assert content and content[0]["type"] == "text", (
+        f"expected text content[], got: {content}"
+    )
+    text_blob = "".join(part["text"] for part in content if part.get("type") == "text")
+    assert "hello-from-integration" in text_blob, (
+        f"expected echo output in tool result, got:\n{text_blob[:500]}"
+    )
+
+
+@pytest.mark.integration
+def test_health_unauthenticated(orchestrator):
+    """/health stays open — used by k8s probes and uptime monitors."""
+    import httpx
+    r = httpx.get(f"{orchestrator['url']}/health", timeout=5.0)
+    assert r.status_code == 200
+    assert r.json() == {"status": "healthy"}