holon-sh 0.0.1.dev1__tar.gz

holon_sh-0.0.1.dev1/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+dist/
+*.egg-info/

holon_sh-0.0.1.dev1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Holon Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

holon_sh-0.0.1.dev1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.5
+Name: holon-sh
+Version: 0.0.1.dev1
+Summary: Typed MCP clients, bindings, and app views
+Project-URL: Repository, https://github.com/holon-sh/sdk-py
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: httpx2<3,>=2.10
+Requires-Dist: jsonschema<5,>=4.26
+Requires-Dist: mcp<3,>=2.3

holon_sh-0.0.1.dev1/holon/binding.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import NotRequired, TypedDict
+
+import httpx2
+
+
+class Binding(TypedDict):
+    endpoint: str
+    http_client: NotRequired[Callable[[], httpx2.AsyncClient]]
+    # Python clients open one session per call, so every binding already behaves as scoped.
+    scoped: NotRequired[bool]
+
+
+_resolver: Callable[[str], Binding | None] | None = None
+
+
+def set_default_binding(resolve: Callable[[str], Binding | None]) -> None:
+    """Resolve bindings for app clients that were not bound with ``create_apps``.
+
+    Without a resolver, or when it returns ``None``, a client falls back to its
+    ``<NAME>_MCP_URL`` environment variable.
+    """
+    global _resolver
+    _resolver = resolve
+
+
+def resolve_default_binding(app: str) -> Binding | None:
+    return _resolver(app) if _resolver is not None else None

holon_sh-0.0.1.dev1/holon/client.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from typing import Any, Generic, Literal, Protocol, TypeAlias, TypeVar
+
+import httpx2
+import jsonschema  # type: ignore[import-untyped,unused-ignore]
+from mcp import Client
+from mcp.client.streamable_http import streamable_http_client
+from mcp.types import (
+    CallToolRequest,
+    CallToolRequestParams,
+    CallToolResult,
+    ContentBlock,
+    Implementation,
+    InputRequiredResult,
+    InputResponses,
+    RequestParamsMeta,
+)
+from pydantic import TypeAdapter
+from referencing import Registry
+
+from holon.binding import Binding, resolve_default_binding
+
+# Binding is re-exported for the generated holon.apps module.
+__all__ = ["Apps", "Binding", "ToolCallError", "ToolResult"]
+
+Output = TypeVar("Output")
+
+
+class CompleteResult(Protocol, Generic[Output]):
+    result_type: Literal["complete"]
+    is_error: Literal[False]
+    structured_content: Output
+    content: list[ContentBlock]
+    meta: dict[str, object] | None
+
+
+class ErrorResult(Protocol):
+    result_type: Literal["complete"]
+    is_error: Literal[True]
+    structured_content: object
+    content: list[ContentBlock]
+    meta: dict[str, object] | None
+
+
+ToolResult: TypeAlias = CompleteResult[Output] | ErrorResult | InputRequiredResult
+
+_result = TypeAdapter(CallToolResult | InputRequiredResult)
+
+
+class ToolCallError(RuntimeError):
+    def __init__(
+        self, app: str, tool: str, result: CallToolResult | InputRequiredResult
+    ) -> None:
+        self.app = app
+        self.tool = tool
+        self.result = result
+        self.code: Literal["tool_error", "input_required"]
+        if isinstance(result, InputRequiredResult):
+            self.code, message = "input_required", "additional input required"
+        else:
+            self.code, message = "tool_error", "tool failed"
+        super().__init__(f"{app}.{tool}: {message}.")
+
+
+def validate(schema: dict[str, Any], value: object, label: str) -> None:
+    try:
+        jsonschema.validate(
+            value,
+            schema,
+            registry=Registry(),
+            format_checker=jsonschema.FormatChecker(),
+        )
+    except jsonschema.ValidationError as error:
+        raise ValueError(f"Invalid {label}: {error.message}") from error
+
+
+class _App:
+    def __init__(
+        self,
+        name: str,
+        identity: dict[str, Any],
+        contract: dict[str, Any] | None,
+        binding: Binding | None = None,
+    ) -> None:
+        self._name = name
+        self._identity = identity
+        self._binding = binding
+        # None for a dependency without a contract: any tool, unvalidated.
+        self._definitions = (
+            None
+            if contract is None
+            else {tool["name"]: tool for tool in contract["tools"]}
+        )
+        self.tools = _Tools(self)
+
+    async def call_tool(
+        self,
+        name: str,
+        arguments: Mapping[str, object],
+        *,
+        timeout: float | None = None,
+        input_responses: InputResponses | None = None,
+        request_state: str | None = None,
+        meta: RequestParamsMeta | None = None,
+    ) -> CallToolResult | InputRequiredResult:
+        definition = None
+        if self._definitions is not None:
+            definition = self._definitions.get(name)
+            if definition is None:
+                raise ValueError(f"Unknown tool {self._name}.{name}.")
+            validate(
+                definition["inputSchema"],
+                arguments,
+                f"arguments for {self._name}.{name}",
+            )
+        binding = self._binding or resolve_default_binding(self._name)
+        if binding is None and self._name not in self._identity["requires"]:
+            raise ValueError(
+                f"Dependency {self._name} is not declared by this application."
+            )
+        variable = self._name.upper().replace("-", "_") + "_MCP_URL"
+        endpoint = binding["endpoint"] if binding else os.environ.get(variable)
+        if not endpoint:
+            raise RuntimeError(
+                f"Dependency {self._name} is unavailable ({variable}). Set the endpoint or supply a binding."
+            )
+        http = (
+            binding["http_client"]()
+            if binding and "http_client" in binding
+            else httpx2.AsyncClient(trust_env=False)
+        )
+        async with http:
+            transport = streamable_http_client(endpoint, http_client=http)
+            async with Client(
+                transport,
+                client_info=Implementation(
+                    name=self._identity["name"], version=self._identity["version"]
+                ),
+                mode="2026-07-28",
+            ) as client:
+                result = await client.session.send_request(
+                    CallToolRequest(
+                        params=CallToolRequestParams(
+                            name=name,
+                            arguments=dict(arguments),
+                            input_responses=input_responses,
+                            request_state=request_state,
+                            _meta=meta,
+                        )
+                    ),
+                    _result,
+                    request_read_timeout_seconds=timeout,
+                )
+        if (
+            definition is not None
+            and isinstance(result, CallToolResult)
+            and not result.is_error
+            and "outputSchema" in definition
+        ):
+            validate(
+                definition["outputSchema"],
+                result.structured_content,
+                f"structured output from {self._name}.{name}",
+            )
+        return result
+
+
+class _Tools:
+    def __init__(self, client: _App) -> None:
+        self._client = client
+
+    def __getattr__(self, name: str) -> Any:
+        definitions = self._client._definitions
+        if name.startswith("_") or definitions is None or name not in definitions:
+            raise AttributeError(name)
+
+        async def call(
+            arguments: Mapping[str, object], *, timeout: float | None = None
+        ) -> object:
+            result = await self._client.call_tool(name, arguments, timeout=timeout)
+            if isinstance(result, InputRequiredResult) or result.is_error:
+                raise ToolCallError(self._client._name, name, result)
+            return result.structured_content
+
+        return call
+
+
+class Apps:
+    def __init__(
+        self,
+        identity: dict[str, Any],
+        contracts: dict[str, Any],
+        bindings: Mapping[str, Binding] | None = None,
+    ) -> None:
+        # Every declared dependency gets a client; those without a contract are untyped.
+        available: dict[str, dict[str, Any] | None] = {
+            name: None for name in identity["requires"]
+        }
+        available.update(contracts)
+        selected = available if bindings is None else {}
+        for name in bindings or ():
+            if name not in available:
+                raise ValueError(f"Unknown app binding: {name}")
+            selected[name] = available[name]
+        self._apps = {
+            name: _App(name, identity, contract, bindings[name] if bindings else None)
+            for name, contract in selected.items()
+        }
+
+    def __getitem__(self, name: str) -> _App:
+        return self._apps[name]
+
+    def __getattr__(self, name: str) -> _App:
+        if name.startswith("_") or name not in self._apps:
+            raise AttributeError(name)
+        return self._apps[name]

holon_sh-0.0.1.dev1/holon/view.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from mcp.server.apps import APP_MIME_TYPE
+from mcp.server.mcpserver.resources import FunctionResource
+
+
+def app_view(
+    uri: str,
+    name: str,
+    file: Path | str,
+    *,
+    connect_domains: list[str] | None = None,
+    resource_domains: list[str] | None = None,
+) -> FunctionResource:
+    page = Path(file)
+    csp = {
+        "connectDomains": connect_domains or [],
+        "resourceDomains": resource_domains or [],
+    }
+    built: list[str] = []
+
+    def read() -> str:
+        if not built:
+            built.append(page.read_text())
+        return built[0]
+
+    return FunctionResource.from_function(
+        read,
+        uri,
+        name=name,
+        mime_type=APP_MIME_TYPE,
+        meta={"ui": {"csp": csp}},
+    )

holon_sh-0.0.1.dev1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "holon-sh"
+version = "0.0.1.dev1"
+description = "Typed MCP clients, bindings, and app views"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = ["mcp>=2.3,<3", "jsonschema>=4.26,<5", "httpx2>=2.10,<3"]
+
+[project.urls]
+Repository = "https://github.com/holon-sh/sdk-py"
+
+[tool.hatch.build.targets.wheel]
+only-include = ["holon"]
+
+[tool.hatch.build.targets.sdist]
+include = ["holon", "tests", "scripts", "pyproject.toml"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py311"
+
+[dependency-groups]
+dev = ["mcptype==0.0.6", "mypy==2.4.0", "pytest==9.1.1", "ruff==0.16.8", "types-jsonschema", "hatchling>=1.27,<2"]

holon_sh-0.0.1.dev1/scripts/verify_distribution.py

@@ -0,0 +1,91 @@
+"""Install each built distribution in an isolated environment and test it.
+
+Dependency packages are copied from the invoking development environment to
+avoid network access. The holon namespace is excluded so only the installed
+artifact can satisfy the runtime imports.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+import sysconfig
+import tempfile
+import venv
+from pathlib import Path
+
+
+def verify(root: Path) -> None:
+    artifacts = sorted(root.glob("dist/holon_sh-*.whl")) + sorted(
+        root.glob("dist/holon_sh-*.tar.gz")
+    )
+    if len(artifacts) != 2:
+        raise RuntimeError("Build exactly one wheel and one sdist before verification.")
+    for artifact in artifacts:
+        with tempfile.TemporaryDirectory(prefix="holon-sh-consumer-") as temporary:
+            directory = Path(temporary)
+            environment = directory / "venv"
+            venv.create(environment, with_pip=False)
+            python = environment / (
+                "Scripts/python.exe" if sys.platform == "win32" else "bin/python"
+            )
+            installed = Path(
+                subprocess.check_output(
+                    [
+                        str(python),
+                        "-c",
+                        "import sysconfig; print(sysconfig.get_path('purelib'))",
+                    ],
+                    text=True,
+                ).strip()
+            )
+            for source in Path(sysconfig.get_path("purelib")).iterdir():
+                if (
+                    source.name.startswith(("holon", "_holon"))
+                    or source.suffix == ".pth"
+                ):
+                    continue
+                target = installed / source.name
+                if source.is_dir():
+                    shutil.copytree(source, target, dirs_exist_ok=True)
+                else:
+                    shutil.copy2(source, target)
+            subprocess.run(
+                [
+                    "uv",
+                    "pip",
+                    "install",
+                    "--python",
+                    str(python),
+                    "--no-deps",
+                    "--no-build-isolation",
+                    str(artifact),
+                ],
+                check=True,
+            )
+            subprocess.run(
+                [
+                    str(python),
+                    "-c",
+                    "import holon, holon.client; assert holon.__file__ is None; print(holon.client.__file__)",
+                ],
+                cwd=directory,
+                check=True,
+            )
+            subprocess.run(
+                [
+                    str(python),
+                    "-m",
+                    "pytest",
+                    str(root / "tests/test_package.py"),
+                    "-k",
+                    "generated_namespace",
+                ],
+                cwd=directory,
+                check=True,
+            )
+
+
+if __name__ == "__main__":
+    verify(Path(__file__).resolve().parents[1])

holon_sh-0.0.1.dev1/tests/test_package.py

@@ -0,0 +1,83 @@
+"""Consumer contracts at the generated namespace boundary."""
+
+import os
+import subprocess
+import sys
+
+from mcptype.compiler import generate
+
+
+def test_generated_namespace_combines_app_types_with_installed_runtime(tmp_path):
+    identity = {"name": "caller", "version": "1"}
+    contract = {
+        "tools": [
+            {
+                "name": "read",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {"id": {"type": "string"}},
+                    "required": ["id"],
+                    "additionalProperties": False,
+                },
+                "outputSchema": {
+                    "type": "object",
+                    "properties": {"total": {"type": "number"}},
+                    "required": ["total"],
+                },
+            }
+        ]
+    }
+    result = generate(
+        {
+            "target": "python",
+            "identity": identity,
+            "requires": {"orders": {"name": "orders", "version": "1"}},
+            "contracts": {"orders": contract},
+            "python_module": "holon/apps/__init__.py",
+            "python_runtime_module": "holon.client",
+            "banner": "holon-generated-apps-v1 app=caller",
+        }
+    )
+    for name, content in result["files"].items():
+        path = tmp_path / name
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(content)
+    assert not (tmp_path / "holon/__init__.py").exists()
+    (tmp_path / "check.py").write_text("""from pathlib import Path
+import holon
+import holon.client
+from holon.apps import apps, Inputs, Outputs
+from holon.binding import Binding, set_default_binding
+
+binding: Binding = {"endpoint": "https://example.com/mcp"}
+set_default_binding(lambda name: binding)
+
+async def run() -> float:
+    arguments: Inputs.orders.read = {"id": "order-1"}
+    output: Outputs.orders.read = await apps.orders.tools.read(arguments)
+    return output["total"]
+
+async def invalid() -> None:
+    await apps.orders.tools.read({"id": 1})  # type: ignore
+    await apps.orders.tools.read({})  # type: ignore
+    apps.missing  # type: ignore
+
+assert holon.__file__ is None
+assert not (Path(__file__).parent / "holon/client.py").exists()
+assert Path(holon.client.__file__).parent != Path(__file__).parent / "holon"
+""")
+    # Runtime and typing must agree across the two namespace portions. No
+    # MYPYPATH/PYTHONPATH override is allowed to hide packaging problems.
+    env = {
+        key: value
+        for key, value in os.environ.items()
+        if key not in {"MYPYPATH", "PYTHONPATH"}
+    }
+    for command in [
+        [sys.executable, "-m", "mypy", "--strict", "--no-incremental", "check.py"],
+        [sys.executable, "check.py"],
+    ]:
+        checked = subprocess.run(
+            command, cwd=tmp_path, env=env, text=True, capture_output=True, check=False
+        )
+        assert checked.returncode == 0, checked.stdout + checked.stderr

holon_sh-0.0.1.dev1/tests/test_runtime.py

@@ -0,0 +1,232 @@
+import asyncio
+import json
+
+import httpx2
+import pytest
+from mcp.server import MCPServer
+from mcp.types import CallToolResult, InputRequiredResult, TextContent
+
+import holon.binding
+from holon.binding import set_default_binding
+from holon.client import Apps, ToolCallError
+
+
+def test_clients_preserve_mcp_results_validate_and_cancel(monkeypatch):
+    async def exercise():
+        started = asyncio.Event()
+        cancelled = asyncio.Event()
+        server = MCPServer("orders")
+
+        @server.tool()
+        async def read(id: str, limit: int = 5) -> CallToolResult | InputRequiredResult:
+            if id == "error":
+                return CallToolResult(
+                    is_error=True,
+                    content=[TextContent(type="text", text="Unavailable")],
+                    _meta={"preserved": True},
+                )
+            if id == "input":
+                return InputRequiredResult(
+                    request_state="opaque", _meta={"preserved": True}
+                )
+            if id == "slow":
+                started.set()
+                try:
+                    await asyncio.Event().wait()
+                finally:
+                    cancelled.set()
+            return CallToolResult(
+                content=[TextContent(type="text", text="Order")],
+                structured_content={"total": "bad" if id == "bad" else limit},
+                _meta={"preserved": True},
+            )
+
+        app = server.streamable_http_app(stateless_http=True)
+        requests = []
+        clients = []
+
+        async def record(request):
+            if request.method == "POST":
+                requests.append(json.loads(await request.aread()))
+
+        def http_client():
+            client = httpx2.AsyncClient(
+                transport=httpx2.ASGITransport(app=app),
+                event_hooks={"request": [record]},
+            )
+            clients.append(client)
+            return client
+
+        monkeypatch.setattr(holon.binding, "_resolver", None)
+        monkeypatch.delenv("MISSING_MCP_URL", raising=False)
+        set_default_binding(
+            lambda app: (
+                {"endpoint": "http://127.0.0.1:8000/mcp", "http_client": http_client}
+                if app == "orders"
+                else None
+            )
+        )
+        contract = {
+            "tools": [
+                {
+                    "name": "read",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "string"},
+                            "limit": {"type": "integer", "default": 5},
+                        },
+                        "required": ["id"],
+                        "additionalProperties": False,
+                    },
+                    "outputSchema": {
+                        "type": "object",
+                        "properties": {"total": {"type": "number"}},
+                        "required": ["total"],
+                    },
+                }
+            ]
+        }
+        identity = {"name": "checkout", "version": "1", "requires": {"orders": {}}}
+        apps = Apps(identity, {"orders": contract})
+        repr(apps)
+        repr(apps.orders.tools)
+        with pytest.raises(TypeError):
+            await apps.orders
+        with pytest.raises(TypeError):
+            json.dumps(apps.orders)
+        assert not requests
+        async with app.router.lifespan_context(app):
+            arguments = {"id": "good"}
+            output, raw = await asyncio.gather(
+                apps.orders.tools.read(arguments),
+                apps.orders.call_tool("read", {"id": "good", "limit": 2}),
+            )
+            assert output == {"total": 5}
+            assert arguments == {"id": "good"}
+            assert raw.structured_content == {"total": 2}
+            assert raw.content[0].text == "Order"
+            assert raw.meta["preserved"] is True
+            assert not any(request["method"] == "tools/list" for request in requests)
+            other = Apps({**identity, "name": "other"}, {"orders": contract})
+            await asyncio.gather(
+                apps.orders.tools.read(arguments), other.orders.tools.read(arguments)
+            )
+            callers = [
+                request["params"]["_meta"]["io.modelcontextprotocol/clientInfo"]["name"]
+                for request in requests
+                if request["method"] == "tools/call"
+            ]
+            assert set(callers) == {"checkout", "other"}
+            for value, code in [("error", "tool_error"), ("input", "input_required")]:
+                raw = await apps.orders.call_tool("read", {"id": value})
+                with pytest.raises(ToolCallError) as error:
+                    await apps.orders.tools.read({"id": value})
+                assert error.value.code == code
+                assert error.value.app == "orders"
+                assert error.value.tool == "read"
+                assert type(error.value.result) is type(raw)
+                assert error.value.result.meta["preserved"] is True
+                if isinstance(raw, InputRequiredResult):
+                    assert error.value.result.request_state
+                else:
+                    assert error.value.result == raw
+            before = len(requests)
+            with pytest.raises(ValueError, match="arguments"):
+                await apps.orders.tools.read({"id": 1})
+            assert len(requests) == before
+            with pytest.raises(ValueError, match="structured output"):
+                await apps.orders.tools.read({"id": "bad"})
+            task = asyncio.create_task(apps.orders.tools.read({"id": "slow"}))
+            await started.wait()
+            task.cancel()
+            with pytest.raises(asyncio.CancelledError):
+                await task
+            await cancelled.wait()
+            untyped = Apps({**identity, "requires": {"orders": {}, "missing": {}}}, {})
+            raw = await untyped.orders.call_tool("read", {"id": "good"})
+            assert raw.structured_content == {"total": 5}
+            assert not hasattr(untyped.orders.tools, "read")
+            with pytest.raises(RuntimeError, match=r"unavailable \(MISSING_MCP_URL\)"):
+                await untyped.missing.call_tool("read", {})
+        assert all(client.is_closed for client in clients)
+
+    async def bounded():
+        async with asyncio.timeout(15):
+            await exercise()
+
+    asyncio.run(bounded())
+
+
+def test_endpoint_bindings_call_without_the_runtime(monkeypatch):
+    async def exercise():
+        server = MCPServer("orders")
+        headers = []
+
+        @server.tool()
+        async def read(id: str) -> CallToolResult:
+            return CallToolResult(
+                content=[TextContent(type="text", text=id)],
+                structured_content={"total": 1},
+            )
+
+        app = server.streamable_http_app(stateless_http=True)
+
+        async def record(request):
+            headers.append(request.headers.get("authorization"))
+
+        def http_client():
+            return httpx2.AsyncClient(
+                transport=httpx2.ASGITransport(app=app),
+                headers={"Authorization": "Bearer external"},
+                event_hooks={"request": [record]},
+            )
+
+        monkeypatch.delenv("ORDERS_MCP_URL", raising=False)
+        monkeypatch.setattr(holon.binding, "_resolver", None)
+        contract = {
+            "tools": [
+                {
+                    "name": "read",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {"id": {"type": "string"}},
+                        "required": ["id"],
+                        "additionalProperties": False,
+                    },
+                    "outputSchema": {
+                        "type": "object",
+                        "properties": {"total": {"type": "number"}},
+                        "required": ["total"],
+                    },
+                }
+            ]
+        }
+        identity = {"name": "script", "version": "1", "requires": {}}
+        with pytest.raises(ValueError, match="Unknown app binding"):
+            Apps(identity, {"orders": contract}, {"missing": {"endpoint": "http://x"}})
+        bound = Apps(
+            identity,
+            {"orders": contract},
+            {
+                "orders": {
+                    "endpoint": "http://127.0.0.1:8000/mcp",
+                    "http_client": http_client,
+                }
+            },
+        )
+        async with app.router.lifespan_context(app):
+            assert await bound.orders.tools.read({"id": "a"}) == {"total": 1}
+            with pytest.raises(ValueError, match="arguments"):
+                await bound.orders.tools.read({"id": 1})
+            with pytest.raises(ValueError, match="not declared"):
+                await Apps(identity, {"orders": contract}).orders.tools.read(
+                    {"id": "a"}
+                )
+        assert headers and all(value == "Bearer external" for value in headers)
+
+    async def bounded():
+        async with asyncio.timeout(15):
+            await exercise()
+
+    asyncio.run(bounded())

holon_sh-0.0.1.dev1/tests/test_view.py

@@ -0,0 +1,47 @@
+import asyncio
+
+from mcp import Client
+from mcp.server import MCPServer
+from mcp.server.apps import APP_MIME_TYPE
+
+from holon.view import app_view
+
+
+def test_app_view_serves_one_build_for_the_life_of_the_process(tmp_path):
+    page = tmp_path / "index.html"
+    page.write_text("<html>one</html>")
+    server = MCPServer("site")
+    server.add_resource(
+        app_view(
+            "ui://site/index.html",
+            "Site",
+            page,
+            connect_domains=["https://api.example"],
+        )
+    )
+
+    async def exercise():
+        async with Client(server, mode="2026-07-28") as client:
+            listed = await client.list_resources()
+            resource = listed.resources[0]
+            assert (str(resource.uri), resource.name, resource.mime_type) == (
+                "ui://site/index.html",
+                "Site",
+                APP_MIME_TYPE,
+            )
+            assert resource.meta == {
+                "ui": {
+                    "csp": {
+                        "connectDomains": ["https://api.example"],
+                        "resourceDomains": [],
+                    }
+                }
+            }
+            first = await client.read_resource("ui://site/index.html")
+            assert first.contents[0].text == "<html>one</html>"
+            assert first.contents[0].mime_type == APP_MIME_TYPE
+            page.write_text("<html>two</html>")
+            second = await client.read_resource("ui://site/index.html")
+            assert second.contents[0].text == "<html>one</html>"
+
+    asyncio.run(exercise())