damaros 0.1.0__py3-none-any.whl

damaros/__init__.py

@@ -0,0 +1,27 @@
+"""The ICU's seats from Python, over the local servers the CLI already runs. Nothing is reimplemented: the tools, the clock, the reward and the cost are the TypeScript
+harness's. No runtime dependencies; Gymnasium is used when installed.
+
+Phase 2 U4: `from damaros import make` — one SDK shape over both worlds.
+"""
+from ._version import __version__
+from .client import WorldClient, make
+from .env import BedsideEnv, UnitEnv
+from .host import ResidentHost, serve_host
+from .resident_env import HostLost, ResidentEnv, ResidentLanes
+from .spaces import EventsSpace, SceneSpace, ToolCallSpace
+
+__all__ = [
+    "__version__",
+    "make",
+    "WorldClient",
+    "BedsideEnv",
+    "UnitEnv",
+    "ResidentEnv",
+    "ResidentLanes",
+    "ResidentHost",
+    "serve_host",
+    "HostLost",
+    "ToolCallSpace",
+    "EventsSpace",
+    "SceneSpace",
+]

damaros/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

damaros/adapters/__init__.py

@@ -0,0 +1,6 @@
+"""Thin adapters from the ICU's physician seat to the three lab stacks (OpenEnv, verifiers, Inspect). Each is under 200 lines, wraps one `Seat`, and takes its reward
+from the server (`end_case`): none computes a reward, none can ask for a test or evaluation case (the local server it wraps serves the sample and train splits only).
+The reward and the harm cost travel as separate fields in every adapter and are never summed. `python3 -m damaros.adapters smoke <name>` plays one episode of one."""
+from .seat import Seat
+
+__all__ = ["Seat"]

damaros/adapters/__main__.py

@@ -0,0 +1,169 @@
+"""python3 -m damaros.adapters smoke <openenv|openenv_mcp|verifiers|verifiers_v1|nemo_gym|inspect>: plays one patient through that adapter with a scripted policy (no model, no GPU, no network)
+and prints the server's reward and cost, apart."""
+import asyncio
+import json
+import sys
+
+def summary(credit):
+    """What the credit comes to, in two numbers every adapter can carry: how many acting calls were credited, and what they did to the chance of death in all."""
+    credit = credit or []
+    return {"calls": len(credit), "net_p_death": round(sum(k["effect"]["p_death"] for k in credit), 6)}
+
+
+SMOKE_SEED = "smoke-182"  # a patient the scripted policy harms twice: a reward of -0.1 and a cost with two kinds in it, so an adapter that dropped either could not pass
+POLICY = [("order_lab", {"test": "blood_culture_x2", "priority": "stat"}), ("order_med", {"drug": "cefepime", "priority": "stat"})] + [("wait", {"minutes": 240})] * 200  # waits end the patient at the horizon
+
+
+def openenv(seed):
+    from .openenv import IcuEnvironment, ToolCall
+
+    env = IcuEnvironment(size=14)
+    env.reset(seed=seed)
+    for name, args in POLICY:
+        obs = env.step(ToolCall(name=name, arguments=args))
+        if obs.done:
+            break
+    env.close()
+    return obs.reward, obs.cost, summary(obs.credit)
+
+
+def verifiers(seed):
+    from .verifiers import IcuEnv
+
+    env = IcuEnv(seeds=[seed], size=14)
+    state = {"info": {"seed": str(seed)}}
+    asyncio.run(env.setup_state(state))
+    for i, (name, args) in enumerate(POLICY):
+        msg = {"role": "assistant", "content": "", "tool_calls": [{"id": f"c{i}", "type": "function", "function": {"name": name, "arguments": json.dumps(args)}}]}
+        asyncio.run(env.env_response([msg], state))
+        if state["server_reward"] is not None:
+            break
+    state["seat"].close()
+    return state["server_reward"], state["cost"], summary(state["credit"])
+
+
+def inspect(seed):
+    from inspect_ai.solver import TaskState
+    from .inspect import KEY, tools_for
+    from .seat import Seat
+
+    seat = Seat(size=14)
+    seat.reset(seed)
+
+    class Store:
+        data = {}
+        set = lambda self, k, v: self.data.__setitem__(k, v)  # noqa: E731
+
+    state = type("S", (), {"store": Store()})()
+    tools = {d.name: d.tool for d in tools_for(seat, state)}
+    for name, args in POLICY:
+        asyncio.run(tools[name](**args))
+        if KEY in state.store.data:
+            break
+    seat.close()
+    r = state.store.data.get(KEY, {})
+    return r.get("reward"), r.get("cost"), summary(r.get("credit"))
+
+
+def openenv_mcp(seed):
+    from openenv.core.env_server.mcp_types import CallToolAction, ListToolsAction
+
+    from .openenv_mcp import IcuMCPEnvironment
+
+    env = IcuMCPEnvironment(size=14)
+    env.reset(seed=seed)
+    assert env.step(ListToolsAction()).tools, "the MCP form lists the seat's tools"
+    for name, args in POLICY:
+        obs = env.step(CallToolAction(tool_name=name, arguments=args))
+        if obs.done:
+            break
+    env.close()
+    return obs.reward, (obs.metadata or {}).get("cost"), summary((obs.metadata or {}).get("credit"))
+
+
+def verifiers_v1(seed):
+    from damaros.adapters.verifiers_v1 import IcuEnv, IcuEnvConfig
+
+    env = IcuEnv(IcuEnvConfig(taskset={"id": "damaros_verifiers", "seeds": [seed], "size": 14}, max_turns=len(POLICY)))
+    (task,) = list(env.taskset)
+    agents, trace = scripted_agents(POLICY)
+    asyncio.run(env.run(task, agents))
+    m = trace.metrics
+    return trace.rewards["damaros_reward"], {"severe": m["damaros_cost_severe"], "other": m["damaros_cost_other"], "by_kind": {k[len("damaros_cost_"):]: v for k, v in m.items() if k.startswith("damaros_cost_") and k not in ("damaros_cost_severe", "damaros_cost_other")}}, {"calls": int(m["damaros_credit_calls"]), "net_p_death": round(m["damaros_credit_net_p_death"], 6)}
+
+
+def scripted_agents(policy):
+    """A verifiers v1 `agents` whose player replies with one JSON tool call a turn from `policy` ([(name, arguments)]) and then stops, with the trace it records into: the model's place, taken by a list,
+    so `IcuEnv.run` is played with no model. Returns (agents, trace); `trace.rewards` and `trace.metrics` hold what the env recorded."""
+
+    class Trace:
+        def __init__(self):
+            self.rewards, self.metrics = {}, {}
+
+        def record_reward(self, k, v, w=1.0):
+            self.rewards[k] = v
+
+        def record_metric(self, k, v):
+            self.metrics[k] = v
+
+    class Reply:
+        def __init__(self, text, terminated):
+            self.last_reply, self.terminated = text, terminated
+
+    class Player:
+        def __init__(self):
+            self.trace, self.calls = Trace(), iter(policy)
+
+        async def turn(self, _text):
+            call = next(self.calls, None)
+            return Reply(json.dumps({"name": call[0], "arguments": call[1]}) if call else "", call is None)
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *_):
+            return False
+
+    player = Player()
+    agents = type("Agents", (), {"player": type("P", (), {"interaction": lambda self, _task: player})()})()
+    return agents, player.trace
+
+
+def nemo_gym(seed):
+    from unittest.mock import MagicMock
+
+    from fastapi.testclient import TestClient
+    from nemo_gym.server_utils import ServerClient
+
+    from .nemo_gym import IcuResourcesServer, IcuResourcesServerConfig
+
+    server = IcuResourcesServer(config=IcuResourcesServerConfig(host="0.0.0.0", port=8080, entrypoint="", name="", size=14), server_client=MagicMock(spec=ServerClient))
+    client = TestClient(server.setup_webserver())
+    client.post("/seed_session", json={"seed": seed})
+    for name, args in POLICY:
+        if client.post(f"/{name}", json=args).json()["done"]:
+            break
+    response = {"id": "smoke", "created_at": 0.0, "model": "scripted", "object": "response", "output": [], "parallel_tool_calls": False, "tool_choice": "auto", "tools": []}
+    verified = client.post("/verify", json={"responses_create_params": {"input": []}, "response": response}).json()
+    return verified["reward"], verified["cost"], summary(verified.get("credit"))
+
+
+ADAPTERS = ("openenv", "openenv_mcp", "verifiers", "verifiers_v1", "nemo_gym", "inspect")
+EXTRA = {"openenv_mcp": "openenv"}  # the MCP form shares the openenv extra
+
+
+def main(argv):
+    if len(argv) != 2 or argv[0] != "smoke" or argv[1] not in ADAPTERS:
+        print(f"usage: python3 -m damaros.adapters smoke <{'|'.join(ADAPTERS)}>", file=sys.stderr)
+        return 2
+    try:
+        reward, cost, credit = globals()[argv[1]](SMOKE_SEED)
+    except ImportError as e:
+        print(f"{argv[1]} is not installed ({e}). pip install 'damaros[{EXTRA.get(argv[1], argv[1])}]'", file=sys.stderr)
+        return 2
+    print(json.dumps({"adapter": argv[1], "reward": reward, "cost": cost, "credit": credit}))
+    return 0 if reward is not None else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

damaros/adapters/inspect.py

@@ -0,0 +1,148 @@
+"""Inspect adapter: a `Task` over the sample and train splits with a `Scorer` that reads the server's score. The solver gives the model the physician's tools and plays them on the
+seat; the scorer returns the server's reward as its value and the harm cost in its metadata, apart, and never sums them. Needs `pip install damaros[inspect]`."""
+import json
+
+from inspect_ai import Task, task
+from inspect_ai.dataset import MemoryDataset, Sample
+from inspect_ai.model import ChatMessageUser
+from inspect_ai.scorer import Score, Target, mean, scorer
+from inspect_ai.solver import Generate, TaskState, solver
+from inspect_ai.tool import ToolDef, ToolParam, ToolParams
+
+from .seat import Seat
+
+KEY = "damaros"
+
+
+def params_of(schema):
+    """Inspect wants a description for every parameter; the server's schema has one only where the tool says something about it, so the others are named by the parameter."""
+    props = {k: ToolParam.model_validate({"description": k.replace("_", " "), **v}) for k, v in schema.get("properties", {}).items()}
+    return ToolParams(properties=props, required=schema.get("required", []))
+
+
+def tools_for(seat, state):
+    """One Inspect tool per tool the server lists; a call runs on the seat, and the patient's end writes the server's reward and cost into the sample's store."""
+    defs = []
+    for spec in seat.tool_list:
+        schema = spec["input_schema"]
+
+        def make(name):
+            async def run(**arguments):
+                text, reward, done = seat.call(name, arguments)
+                if done:
+                    state.store.set(KEY, {"reward": reward, "cost": seat.cost, "credit": seat.credit, "budget": seat.budget})
+                return text
+
+            return run
+
+        defs.append(ToolDef(make(spec["name"]), name=spec["name"], description=spec.get("description") or spec["name"], parameters=params_of(schema)))
+    return defs
+
+
+@solver
+def physician(size=14, harm_budget=None, server=None):
+    async def solve(state: TaskState, generate: Generate) -> TaskState:
+        seat = Seat(size=size, harm_budget=harm_budget, server=server)
+        text, _ = seat.reset(state.metadata["seed"])
+        state.tools = [d.as_tool() for d in tools_for(seat, state)]
+        state.messages.append(ChatMessageUser(content=text))
+        try:
+            return await generate(state)
+        finally:
+            seat.close()
+
+    return solve
+
+
+@scorer(metrics=[mean()])
+def server_reward():
+    async def score(state: TaskState, target: Target) -> Score:
+        result = state.store.get(KEY) or {"reward": 0.0, "cost": None}
+        return Score(value=float(result["reward"] or 0.0), answer=json.dumps(result["cost"]), metadata={"cost": result["cost"], "credit": result.get("credit"), "budget": result.get("budget")})
+
+    return score
+
+
+@task
+def icu(seeds=range(8), size=14, harm_budget=None, server=None):
+    """`server` (`-T server=https://...`, with the run's token in DAMAROS_RUN_TOKEN, never a -T argument): each sample plays the hosted run's next patient; `seeds` then only counts the samples. Run it with `--max-samples 1`: a run has one patient in hand at a time."""
+    return Task(dataset=MemoryDataset([Sample(input=f"Care for the patient on seed {s}.", metadata={"seed": str(s)}) for s in seeds]), solver=physician(size=size, harm_budget=harm_budget, server=server), scorer=server_reward())
+
+
+@task
+def icu_server(server, token, agent, is_=None, analysis_out=None):
+    """The `--server` form (D4): submits an EVALUATION run through the hosted server and reads the run analysis back. The cases stay on the server: each sample is "the next patient",
+    nothing here can name one, and the sample's score is 0 (an evaluation patient has no outcome until the run is scored); the task's metric is the server's verdict, read from the customer's
+    analysis, which is also written to `analysis_out` when given. Run it with one sample at a time: `inspect eval ... --max-samples 1`.
+
+        inspect eval damaros.adapters.inspect@icu_server -T server=https://app.damaros.ai -T token=... -T agent=my-agent@1.2 --max-samples 1
+    """
+    from ..server import Server
+
+    run = Server(server, token).open_evaluation_run(agent, is_)
+    seat = run.seat()
+    tools = [{"name": t["name"], "description": t.get("description", ""), "input_schema": t.get("inputSchema") or t.get("input_schema")} for t in seat.tool_list]
+
+    @solver
+    def play():
+        async def solve(state: TaskState, generate: Generate) -> TaskState:
+            patient = seat.next_case()
+            if patient is None:
+                return state
+            defs = []
+            for spec in tools:
+                schema = spec["input_schema"]
+
+                def make(name):
+                    async def call(**arguments):
+                        out = seat.call(name, arguments)
+                        if out.get("ended"):
+                            seat.end_case()
+                        return json.dumps(out)
+
+                    return call
+
+                defs.append(ToolDef(make(spec["name"]), name=spec["name"], description=spec["description"] or spec["name"], parameters=params_of(schema)))
+            state.tools = [d.as_tool() for d in defs]
+            state.messages.append(ChatMessageUser(content=json.dumps(patient)))
+            try:
+                return await generate(state)
+            finally:
+                seat.end_case()  # hand the bed back whether or not the model did; a test patient shows no outcome
+                run.handed_back += 1
+                if run.handed_back >= (run.cases_planned or 1):
+                    seat.next_case()  # the panel is played: asking for another patient is what closes the run, and the server scores it
+                    run.analysis()  # wait here, once, for the score
+
+        return solve
+
+    @scorer(metrics=[server_verdict(run, analysis_out)])
+    def pending():
+        async def score(state: TaskState, target: Target) -> Score:
+            return Score(value=0.0, explanation="an evaluation patient has no outcome until the server scores the run")
+
+        return score
+
+    n = run.cases_planned or 1
+    return Task(dataset=MemoryDataset([Sample(input="Care for the next patient.", metadata={"n": i}) for i in range(n)]), solver=play(), scorer=pending())
+
+
+def server_verdict(run, analysis_out=None):
+    """A metric: 1.0 if the run met the account's thresholds and 0.0 if it did not, read from the customer's analysis once the server has scored the run (the solver of the last sample waits
+    for it; Inspect asks a metric after every sample, so this never waits). The analysis is written to `analysis_out` when given."""
+    from inspect_ai.scorer import metric
+
+    @metric
+    def damaros_verdict():
+        def compute(scores):
+            analysis = run.scored
+            if not scores or analysis is None:
+                return 0.0
+            if analysis_out:
+                with open(analysis_out, "w") as f:
+                    json.dump(analysis, f, indent=2)
+            return 1.0 if analysis["verdict"]["result"] == "met" else 0.0
+
+        return compute
+
+    return damaros_verdict()

damaros/adapters/nemo_gym.py

@@ -0,0 +1,100 @@
+"""NeMo Gym adapter: a resources server whose tool routes run on the physician's seat and whose `/verify` returns the server's reward, so a NeMo Gym rollout collects Damaros episodes with no Damaros
+code on the lab's side. One route per tool (`/get_chart`, `/order_med`, ...), each taking the tool's arguments as the body; `/seed_session` opens a patient from a seed; `/verify` returns the reward
+as `end_case` gave it, with the harm cost beside it in `cost` (never added to `reward`). `tool_definitions()` is the Responses-API tool list to put in a dataset row's `responses_create_params`.
+Written against nemo-gym 0.4.0 (2026-07-02, Apache-2.0, Python >=3.12); 0.5.0 and later need Python >=3.13.14, so a 3.12 environment stays on 0.4.0. Needs `pip install damaros[nemo_gym]`."""
+from typing import Any, Dict, List, Optional
+
+from fastapi import FastAPI, Request
+from pydantic import BaseModel, Field
+
+from nemo_gym.base_resources_server import (
+    BaseResourcesServerConfig,
+    BaseSeedSessionRequest,
+    BaseSeedSessionResponse,
+    BaseVerifyRequest,
+    BaseVerifyResponse,
+    SimpleResourcesServer,
+)
+from nemo_gym.server_utils import SESSION_ID_KEY
+
+from .seat import Seat
+
+
+class IcuResourcesServerConfig(BaseResourcesServerConfig):
+    size: int = 14
+    clusters: Optional[List[str]] = None
+    harm_budget: Optional[str] = None
+    server: Optional[str] = None  # the hosted server's address: each session plays the next patient of the run whose token is DAMAROS_RUN_TOKEN (the environment, never this config)
+
+
+class IcuSeedSessionRequest(BaseSeedSessionRequest):
+    seed: str = "nemo_gym"
+
+
+class ToolResult(BaseModel):
+    text: str
+    done: bool = False
+
+
+class IcuVerifyResponse(BaseVerifyResponse):
+    cost: Optional[Dict[str, Any]] = None  # the harm cost, apart from `reward`; None while the patient is still open
+    credit: Optional[list] = None  # what each acting call did to the patient (the server's); None while the patient is still open
+    budget: Optional[Dict[str, Any]] = None
+
+
+class IcuResourcesServer(SimpleResourcesServer):
+    config: IcuResourcesServerConfig
+    seats: Dict[str, Any] = Field(default_factory=dict)  # session id -> Seat
+    rewards: Dict[str, Optional[float]] = Field(default_factory=dict)
+
+    def _seat_args(self) -> dict:
+        return {"size": self.config.size, "clusters": self.config.clusters, "harm_budget": self.config.harm_budget, "server": self.config.server}
+
+    def tool_definitions(self) -> List[dict]:
+        """The seat's tools as Responses-API function tools, for a dataset row's `responses_create_params.tools`."""
+        probe = Seat(**self._seat_args())
+        tools = [{"type": "function", "name": t["name"], "description": t.get("description", ""), "parameters": t["input_schema"], "strict": False} for t in probe.tools()]
+        probe.close()
+        return tools
+
+    def setup_webserver(self) -> FastAPI:
+        app = super().setup_webserver()
+        for tool in self.tool_definitions():
+            app.post(f"/{tool['name']}")(self._route(tool["name"]))
+        return app
+
+    def _route(self, name: str):
+        async def call(request: Request, body: Dict[str, Any]) -> ToolResult:
+            sid = request.session[SESSION_ID_KEY]
+            if sid not in self.seats:
+                return ToolResult(text="No patient is open. Seed the session first.", done=False)
+            text, reward, done = self.seats[sid].call(name, body)
+            if done:
+                self.rewards[sid] = reward
+            return ToolResult(text=text, done=done)
+
+        call.__name__ = name
+        return call
+
+    async def seed_session(self, request: Request, body: IcuSeedSessionRequest) -> BaseSeedSessionResponse:
+        sid = request.session[SESSION_ID_KEY]
+        if sid in self.seats:
+            self.seats.pop(sid).close()
+        self.seats[sid] = Seat(**self._seat_args())
+        self.seats[sid].reset(body.seed)
+        self.rewards[sid] = None
+        return BaseSeedSessionResponse()
+
+    async def verify(self, request: Request, body: BaseVerifyRequest) -> IcuVerifyResponse:
+        """The server's reward for the patient, as `end_case` gave it: zero for one never handed back. The seat closes here."""
+        sid = request.session[SESSION_ID_KEY]
+        seat = self.seats.pop(sid, None)
+        reward = self.rewards.pop(sid, None)
+        cost, credit, budget = (seat.cost, seat.credit, seat.budget) if seat is not None and reward is not None else (None, None, None)
+        if seat is not None:
+            seat.close()
+        return IcuVerifyResponse(**body.model_dump(), reward=float(reward or 0.0), cost=cost, credit=credit, budget=budget)
+
+
+if __name__ == "__main__":
+    IcuResourcesServer.run_webserver()

damaros/adapters/openenv.py

@@ -0,0 +1,50 @@
+"""OpenEnv adapter: an `Environment` with reset, step and state over the physician's seat. The observation is the seat's text plus the structured chart; the reward is
+the server's, given on the step that ends the patient, and the harm cost is its own field. Needs `pip install damaros[openenv]`."""
+from typing import Any, Optional
+
+from openenv.core.env_server import Action, Environment, Observation, State
+
+from .seat import Seat
+
+
+class ToolCall(Action):
+    name: str
+    arguments: dict[str, Any] = {}
+
+
+class IcuObservation(Observation):
+    text: str = ""
+    chart: Optional[dict[str, Any]] = None
+    cost: Optional[dict[str, Any]] = None  # the harm cost, apart from `reward`; only when the patient ends
+    credit: Optional[list[dict[str, Any]]] = None  # what each acting call did to the patient (the server's): the run with it minus the run without it, with the same case and seed; only when the patient ends
+    budget: Optional[dict[str, Any]] = None  # with a harm budget set: {"file_hash", "breached": the rule that ended the patient, or null}
+
+
+class IcuState(State):
+    seed: str = ""
+    t: Optional[int] = None
+
+
+class IcuEnvironment(Environment[ToolCall, IcuObservation, IcuState]):
+    def __init__(self, size: int = 14, clusters: Optional[list[str]] = None, harm_budget: Optional[str] = None, server: Optional[str] = None, run_token: Optional[str] = None):
+        """`server` (and `run_token`, or DAMAROS_RUN_TOKEN): play a run on the hosted server, one of its patients per reset."""
+        super().__init__()
+        self.seat = Seat(size=size, clusters=clusters, harm_budget=harm_budget, server=server, run_token=run_token)
+        self._state = IcuState()
+
+    def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, **kwargs: Any) -> IcuObservation:
+        text, _ = self.seat.reset(seed if seed is not None else "openenv")
+        self._state = IcuState(episode_id=episode_id, step_count=0, seed=str(seed))
+        return IcuObservation(text=text, chart=self.seat.chart(text), done=False, reward=None)
+
+    def step(self, action: ToolCall, timeout_s: Optional[float] = None, **kwargs: Any) -> IcuObservation:
+        text, reward, done = self.seat.call(action.name, action.arguments)
+        self._state.step_count += 1
+        return IcuObservation(text=text, chart=self.seat.chart(text), done=done, reward=reward, cost=self.seat.cost if done else None, credit=self.seat.credit if done else None, budget=self.seat.budget if done else None)
+
+    @property
+    def state(self) -> IcuState:
+        return self._state
+
+    def close(self) -> None:
+        self.seat.close()

damaros/adapters/openenv_mcp.py

@@ -0,0 +1,62 @@
+"""OpenEnv's MCP form (RFC 003, "MCP Support: Traditional Tool Calling"): an `MCPEnvironment` whose FastMCP server carries the physician's tools, so a policy lists them with `ListToolsAction` and calls
+them with `CallToolAction`, the same as at inference. The RFC file is on OpenEnv's main (merged with #169, 2025-11-24) although its own header still reads "In Review"; the classes it describes ship in
+openenv-core 0.3.0 (2026-05-11), which this is written against. Each tool is the seat's, with the seat's own JSON schema. The call that ends the patient comes back with `done` true, the server's reward
+in `reward` and the harm cost beside it in `metadata["cost"]`, never added to the reward. It sits beside the plain `Action` form in `openenv.py`. Needs `pip install damaros[openenv]`."""
+from typing import Any, Optional
+
+from fastmcp import FastMCP
+from fastmcp.tools import Tool
+from fastmcp.tools.base import ToolResult
+from openenv.core.env_server.mcp_environment import MCPEnvironment
+from openenv.core.env_server.mcp_types import CallToolAction
+from openenv.core.env_server.types import Observation, State
+
+from .seat import Seat
+
+
+class IcuMCPEnvironment(MCPEnvironment):
+    def __init__(self, size: int = 14, clusters: Optional[list[str]] = None, harm_budget: Optional[str] = None, server: Optional[str] = None, run_token: Optional[str] = None):
+        """`server` (and `run_token`, or DAMAROS_RUN_TOKEN): play a run on the hosted server, one of its patients per reset."""
+        self.seat = Seat(size=size, clusters=clusters, harm_budget=harm_budget, server=server, run_token=run_token)
+        mcp = FastMCP("damaros-icu")
+        for spec in self.seat.tools():  # the tool list does not depend on the seed
+            mcp.add_tool(self._tool(spec))
+        super().__init__(mcp)
+        self._state = State(episode_id=None, step_count=0)
+        self._reward: Optional[float] = None
+
+    def _tool(self, spec: dict) -> Tool:
+        env = self
+
+        class SeatTool(Tool):
+            async def run(self, arguments: dict[str, Any]) -> ToolResult:
+                text, reward, done = env.seat.call(spec["name"], arguments)
+                if done:
+                    env._reward = reward
+                return ToolResult(content=text)
+
+        return SeatTool(name=spec["name"], description=spec.get("description", ""), parameters=spec["input_schema"])
+
+    def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, **kwargs: Any) -> Observation:
+        text, _ = self.seat.reset(seed if seed is not None else "openenv")
+        self._state, self._reward = State(episode_id=episode_id, step_count=0), None
+        return Observation(done=False, reward=None, metadata={"chart": text})
+
+    def step(self, action, timeout_s: Optional[float] = None, **kwargs: Any) -> Observation:
+        obs = super().step(action, timeout_s=timeout_s, **kwargs)
+        self._state.step_count += 1
+        if isinstance(action, CallToolAction) and self._reward is not None:
+            obs.done, obs.reward = True, self._reward
+            obs.metadata = {**(obs.metadata or {}), "cost": self.seat.cost, "credit": self.seat.credit, "budget": self.seat.budget}
+        return obs
+
+    def _step_impl(self, action, timeout_s: Optional[float] = None, **kwargs: Any) -> Observation:
+        return Observation(done=False, reward=None, metadata={"error": f"Unknown action {type(action).__name__}; use ListToolsAction or CallToolAction."})
+
+    @property
+    def state(self) -> State:
+        return self._state
+
+    def close(self) -> None:
+        self.seat.close()
+        super().close()