"""Synthetic, simulator-neutral runtime for the first four basic-40 assets. Only LabHost advances the common clock. LabSession identities are assigned by the host, never taken from a request's arguments. This is an API access filter, NOT a sandbox against Python introspection, shared memory or filesystem access. Deploy the host in a separate trusted process before giving an untrusted agent filesystem/code execution access. No real instrument or robot driver is present. Scene commands require a synchronous, atomic scene_adapter callback. It receives (instance_id, updates), with SI-valued state IDs. Success means that callback returned; evaluated Blender poses require separate backend verification. """ from __future__ import annotations import argparse import copy import hashlib import json import math import platform import threading from dataclasses import dataclass, field from datetime import datetime, timezone from pathlib import Path from typing import Any, Callable PROTOCOL_VERSION = "1.0.0" RPM_TO_RAD_S = 2 * math.pi / 60 def _slot(unit, origin, visibility="agent", access="read_only", capability=None, parameter=None): return {"unit": unit, "origin": origin, "visibility": visibility, "access": access, "write_via": None if not capability else {"capability_id": capability, "parameter": parameter}} COMMON_SLOTS = { "power.enabled": _slot("1", "setpoint", access="read_write", capability="power.set", parameter="enabled"), } THERMAL_SLOTS = { "thermal.target_k": _slot("K", "setpoint", access="read_write", capability="thermal.set_temperature", parameter="temperature_K"), "thermal.temperature_k": _slot("K", "process_truth", "debug"), "thermal.indicated_temperature_k": _slot("K", "derived"), } ASSET_SPECS: dict[str, dict[str, Any]] = { "instrument.ika_rct_digital": { "catalog_id": "CHEM-008", "model": "IKA RCT digital", "asset_version": "1.0.0", "capabilities": ["power.set", "thermal.set_temperature", "stirring.set_speed"], "state_slots": {**COMMON_SLOTS, **THERMAL_SLOTS, "stirring.target_rad_s": _slot("rad/s", "setpoint", access="read_write", capability="stirring.set_speed", parameter="speed_rad_s"), "stirring.speed_rad_s": _slot("rad/s", "process_truth", "debug"), "stirring.indicated_speed_rad_s": _slot("rad/s", "derived"), "stirring.angle_rad": _slot("rad", "process_truth", "debug")}, "parameters": { "heater_power_W": {"value": 600.0, "evidence": "catalog", "source": "CHEM-008 specification"}, "maximum_temperature_K": {"value": 583.15, "evidence": "catalog", "source": "CHEM-008: 310 deg C"}, "minimum_speed_rad_s": {"value": 50 * RPM_TO_RAD_S, "evidence": "catalog", "source": "CHEM-008: 50 rpm"}, "maximum_speed_rad_s": {"value": 1500 * RPM_TO_RAD_S, "evidence": "catalog", "source": "CHEM-008: 1500 rpm"}, "speed_increment_rad_s": {"value": 10 * RPM_TO_RAD_S, "evidence": "catalog", "source": "CHEM-008: 10 rpm; grid starts at 50 rpm"}, "thermal_capacity_J_K": {"value": 1800.0, "evidence": "assumption", "source": "Empty plate lumped model; uncalibrated"}, "heat_loss_W_K": {"value": 1.2, "evidence": "assumption", "source": "Empty plate convection/loss approximation"}, "stirring_time_constant_s": {"value": 1.5, "evidence": "assumption", "source": "First-order rotor response; not vendor response time"}, }, }, "instrument.binder_fd56": { "catalog_id": "CHEM-011", "model": "BINDER FD 56", "asset_version": "1.0.0", "capabilities": ["power.set", "thermal.set_temperature", "scene.set_door"], "state_slots": {**COMMON_SLOTS, **THERMAL_SLOTS, "door.angle_rad": _slot("rad", "scene", access="read_write", capability="scene.set_door", parameter="angle_rad")}, "parameters": { "heater_power_W": {"value": 1100.0, "evidence": "catalog", "source": "CHEM-011 specification"}, "minimum_target_above_ambient_K": {"value": 10.0, "evidence": "catalog", "source": "CHEM-011: ambient + 10 deg C"}, "maximum_temperature_K": {"value": 573.15, "evidence": "catalog", "source": "CHEM-011: 300 deg C"}, "maximum_door_angle_rad": {"value": math.radians(100), "evidence": "assumption", "source": "Scene articulation limit 100 deg; not measured manufacturer travel"}, "thermal_capacity_J_K": {"value": 15000.0, "evidence": "assumption", "source": "Empty chamber effective heat capacity; no sample drying chemistry"}, "heat_loss_W_K": {"value": 2.5, "evidence": "assumption", "source": "Closed chamber lumped loss"}, "door_open_loss_W_K": {"value": 20.0, "evidence": "assumption", "source": "Additional loss at fully open door"}, "door_open_heater_fraction": {"value": 0.25, "evidence": "assumption", "source": "Simulation reduction at full opening; NOT a manufacturer interlock"}, }, }, "instrument.ne1000_bd10ml": { "catalog_id": "CHEM-184", "model": "New Era NE-1000, B-D 10 mL syringe", "asset_version": "1.0.0", "capabilities": ["power.set", "pumping.set_flow_rate", "pumping.set_direction", "pumping.start", "pumping.stop"], "state_slots": {**COMMON_SLOTS, "pumping.flow_rate_m3_s": _slot("m^3/s", "setpoint", access="read_write", capability="pumping.set_flow_rate", parameter="flow_rate_m3_s"), "pumping.running": _slot("1", "derived"), "pumping.direction": _slot("1", "setpoint", access="read_write", capability="pumping.set_direction", parameter="direction"), "pumping.transferred_volume_m3": _slot("m^3", "process_truth", "debug"), "pumping.plunger_displacement_m": _slot("m", "derived")}, "parameters": { "maximum_flow_rate_m3_s": {"value": 500.4e-6 / 3600, "evidence": "public_document", "source": "NE-1000 manual 1200-01, 2016-04-06, p50: B-D 10 mL syringe 500.4 mL/h"}, "minimum_flow_rate_m3_s": {"value": 6.876e-9 / 3600, "evidence": "public_document", "source": "NE-1000 manual 1200-01, 2016-04-06, p50: B-D 10 mL syringe 6.876 uL/h"}, "syringe_diameter_m": {"value": .01443, "evidence": "public_document", "source": "NE-1000 manual 1200-01, 2016-04-06, p50: B-D 10 mL inner diameter 14.43 mm; supplemental configuration choice"}, "syringe_stroke_m": {"value": 10e-6 / (math.pi * .01443**2 / 4), "evidence": "assumption", "source": "Ideal 10 mL cylinder travel V/A; not a measured manufacturer stroke"}, }, }, "instrument.esco_efa5": { "catalog_id": "CHEM-199", "model": "Esco EFA-5UDUVW-9", "asset_version": "1.0.0", "capabilities": ["power.set", "scene.set_sash"], "state_slots": {**COMMON_SLOTS, "sash.opening_m": _slot("m", "scene", access="read_write", capability="scene.set_sash", parameter="opening_m"), "ventilation.external_exhaust_m3_s": _slot("m^3/s", "derived"), "ventilation.face_velocity_m_s": _slot("m/s", "derived")}, "parameters": { "opening_width_m": {"value": 1.301, "evidence": "public_document", "source": "Esco EFA-5UDUVW-9 technical specifications: clear opening width 1301 mm"}, "maximum_sash_opening_m": {"value": .670, "evidence": "public_document", "source": "Esco EFA-5UDUVW-9 technical specifications: maximum sash opening 670 mm"}, }, }, } CAPABILITY_ARGUMENTS = { "power.set": {"enabled": {"type": "boolean"}}, "thermal.set_temperature": {"temperature_K": {"type": "number", "x-unit": "K"}}, "stirring.set_speed": {"speed_rad_s": {"type": "number", "x-unit": "rad/s"}}, "scene.set_door": {"angle_rad": {"type": "number", "x-unit": "rad"}}, "pumping.set_flow_rate": {"flow_rate_m3_s": {"type": "number", "x-unit": "m^3/s"}}, "pumping.set_direction": {"direction": {"type": "string", "enum": ["infuse", "withdraw"]}}, "pumping.start": {}, "pumping.stop": {}, "scene.set_sash": {"opening_m": {"type": "number", "x-unit": "m"}}, } CAPABILITY_RESULT_SLOT = { "power.set": ("enabled", "power.enabled"), "thermal.set_temperature": ("setpoint_K", "thermal.target_k"), "stirring.set_speed": ("setpoint_rad_s", "stirring.target_rad_s"), "scene.set_door": ("angle_rad", "door.angle_rad"), "pumping.set_flow_rate": ("flow_rate_m3_s", "pumping.flow_rate_m3_s"), "pumping.set_direction": ("direction", "pumping.direction"), "pumping.start": ("running", "pumping.running"), "pumping.stop": ("running", "pumping.running"), "scene.set_sash": ("opening_m", "sash.opening_m"), } DECLARED_CAPABILITIES = {"instrument.ne1000_bd10ml": { "pumping.program": {"availability": "declared", "kind": "configuration", "description_zh": "NE-1000 41 阶段程序功能尚未实现；本接口不接受或执行程序。下述结构仅为本项目未来仿真提案，不是厂家串口格式。", "input_schema": {"type": "object", "properties": {"phases": {"type": "array", "minItems": 1, "maxItems": 41, "items": {"type": "object", "properties": { "direction": {"type": "string", "enum": ["infuse", "withdraw"]}, "flow_rate_m3_s": {"type": "number", "exclusiveMinimum": 0, "x-unit": "m^3/s"}, "duration_s": {"type": "number", "exclusiveMinimum": 0, "x-unit": "s"}}, "required": ["direction", "flow_rate_m3_s", "duration_s"], "additionalProperties": False}}}, "required": ["phases"], "additionalProperties": False}, "output_schema": {"type": "object", "properties": {}, "additionalProperties": False}, "example_arguments": [{"phases": [{"direction": "infuse", "flow_rate_m3_s": 1e-9, "duration_s": 10}]}], "state_effects": [], "observes": [], "binding": None} }} HOST_CAPABILITIES = { "sim.step": {"kind": "simulation", "visibility": "trusted_host_only", "scope": "All registered instances in this LabHost share one world clock", "input_schema": {"type": "object", "properties": {"dt_s": {"type": "number", "minimum": 0, "maximum": 3600, "x-unit": "s"}}, "required": ["dt_s"], "additionalProperties": False}, "binding": "basic40_runtime.LabHost.step(dt_s)", "completion_criterion": "Common host time equals previous time + dt_s; all process instances advanced under one world lock", "partial_failure": "SceneSynchronizationError means process and time advanced; failed scene updates remain in trusted diagnostics"}, "host.configure_syringe": {"kind": "configuration", "visibility": "trusted_host_only", "binding": "LabHost.configure_syringe"}, "host.connect_pump": {"kind": "configuration", "visibility": "trusted_host_only", "binding": "LabHost.connect_pump", "constraints": "Each syringe vessel belongs exclusively to one pump and cannot be another pump's external vessel; external collection vessels may be shared. All checks precede connection, position and revision changes."}, "host.set_external_exhaust": {"kind": "configuration", "visibility": "trusted_host_only", "binding": "LabHost.set_external_exhaust"}, "host.sync_scene": {"kind": "configuration", "visibility": "trusted_host_only", "binding": "LabHost.sync_scene"}, } def export_contract_metadata(): """Type metadata only: no instance values, identities, samples or task state. capability.output_schema describes the protocol envelope's result member. All other envelope fields follow Chemistry Lab protocol 1.0.0. """ assets = copy.deepcopy(ASSET_SPECS) summaries = {"power.set": "设置本机供电；风柜仅本机照明，不改变外部排风量", "thermal.set_temperature": "写入温度目标；实际温度仅随宿主时间演化", "stirring.set_speed": "设置搅拌角速度；50–1500 rpm 按 10 rpm 递增，0 单独表示停止目标", "scene.set_door": "经场景适配器设置门转角；无机器人抓取或碰撞求解", "pumping.set_flow_rate": "设置所选 B-D 10 mL 注射器的正值体积流率", "pumping.set_direction": "停泵时设置注入或回抽方向", "pumping.start": "启动受行程与容器容量限制的输液；本调用不转移物质", "pumping.stop": "停止后续输液；保留已经转移的物质", "scene.set_sash": "经场景适配器设置视窗垂直开口并派生估计面风速"} examples = {"power.set": {"enabled": True}, "thermal.set_temperature": {"temperature_K": 333.15}, "stirring.set_speed": {"speed_rad_s": 300 * RPM_TO_RAD_S}, "scene.set_door": {"angle_rad": .5}, "pumping.set_flow_rate": {"flow_rate_m3_s": 1e-9}, "pumping.set_direction": {"direction": "infuse"}, "pumping.start": {}, "pumping.stop": {}, "scene.set_sash": {"opening_m": .457}} for type_id, spec in assets.items(): for sid, slot in spec["state_slots"].items(): if sid in ("power.enabled", "pumping.running"): slot["value_schema"] = {"type": "boolean"} elif sid == "pumping.direction": slot["value_schema"] = {"type": "string", "enum": ["infuse", "withdraw"]} elif sid == "ventilation.face_velocity_m_s": slot["value_schema"] = {"anyOf": [{"type": "number", "minimum": 0}, {"type": "null"}]} else: slot["value_schema"] = {"type": "number"} slot["read_binding"] = f"LabSession.read(instance_id=..., state_ids=['{sid}'])" slot["sampling"] = {"mode": "instant", "time_domain": "simulation", "window": None} slot["reference_conditions"] = "Actual room conditions supplied by host; no standard-state conversion" if sid == "ventilation.external_exhaust_m3_s" else None if slot["origin"] == "derived": slot["observation_note_zh"] = "明确的理想化模型观测，quality=estimated；不是厂家真实传感器读数或精度声明" caps = {} for capability in spec["capabilities"]: args = copy.deepcopy(CAPABILITY_ARGUMENTS[capability]) if capability == "thermal.set_temperature": args["temperature_K"].update(minimum=283.15 if type_id.endswith("binder_fd56") else 273.15, maximum=spec["parameters"]["maximum_temperature_K"]["value"], description="Actual lower bound is host ambient + 10 K for FD 56, or host ambient for RCT") elif capability == "stirring.set_speed": args["speed_rad_s"].update(minimum=0, maximum=1500 * RPM_TO_RAD_S, description="Allowed: 0, or (50 + 10*n) rpm converted to rad/s, n=0..145") elif capability == "scene.set_door": args["angle_rad"].update(minimum=0, maximum=spec["parameters"]["maximum_door_angle_rad"]["value"]) elif capability == "scene.set_sash": args["opening_m"].update(minimum=0, maximum=spec["parameters"]["maximum_sash_opening_m"]["value"]) elif capability == "pumping.set_flow_rate": args["flow_rate_m3_s"].update(minimum=spec["parameters"]["minimum_flow_rate_m3_s"]["value"], maximum=spec["parameters"]["maximum_flow_rate_m3_s"]["value"], **{"x-reference-conditions": "Liquid geometric displacement at modeled room conditions; no gas reference state"}) output_key, sid = CAPABILITY_RESULT_SLOT[capability] out_value = copy.deepcopy(spec["state_slots"][sid]["value_schema"]) if out_value.get("type") == "number": out_value["x-unit"] = spec["state_slots"][sid]["unit"] effects = [{"state_id": sid, "timing": "immediate", "description_zh": summaries[capability]}] if capability in ("thermal.set_temperature", "scene.set_door") or (capability == "power.set" and "thermal.target_k" in spec["state_slots"]): effects += [{"state_id": key, "timing": "on_step", "description_zh": "空载集中参数热模型及理想化显示"} for key in ("thermal.temperature_k", "thermal.indicated_temperature_k")] if capability == "stirring.set_speed" or (capability == "power.set" and "stirring.target_rad_s" in spec["state_slots"]): effects += [{"state_id": key, "timing": "on_step", "description_zh": "有限响应时间的速度及其时间积分角度"} for key in ("stirring.speed_rad_s", "stirring.indicated_speed_rad_s", "stirring.angle_rad")] if capability in ("pumping.start", "pumping.set_flow_rate", "pumping.set_direction"): effects += [{"state_id": key, "timing": "on_step", "description_zh": "输液事务后更新累计体积、真实几何行程与边界停止状态"} for key in ("pumping.transferred_volume_m3", "pumping.plunger_displacement_m", "pumping.running")] if capability == "power.set" and "pumping.running" in spec["state_slots"]: effects.append({"state_id": "pumping.running", "timing": "immediate", "description_zh": "断电时停止输液"}) if capability == "scene.set_sash": effects.append({"state_id": "ventilation.face_velocity_m_s", "timing": "immediate", "description_zh": "外部Q/(1.301×开口)估计；开口为0时不可用，不能用于安全判断"}) caps[capability] = {"availability": "implemented", "visibility": "agent", "kind": "simulation" if capability.startswith("scene.") else "device_command", "description_zh": summaries[capability], "input_schema": {"type": "object", "properties": args, "required": list(args), "additionalProperties": False}, "output_schema": {"type": "object", "properties": {output_key: out_value}, "required": [output_key], "additionalProperties": False}, "state_effects": effects, "observes": [sid], "example_arguments": [examples[capability]], "binding": "basic40_runtime.LabSession.invoke(instance_id=..., capability_id='" + capability + "', arguments=..., request_id=...)", "scene_backend_required": capability.startswith("scene."), "preconditions_zh": (["本机已上电"] if capability in ("thermal.set_temperature", "stirring.set_speed", "pumping.set_flow_rate", "pumping.set_direction", "pumping.start") else []) + (["目标≥宿主环境温度" + ("+10 K" if type_id.endswith("binder_fd56") else "")] if capability == "thermal.set_temperature" else []) + (["非零值必须为从50 rpm起每10 rpm递增的离散值"] if capability == "stirring.set_speed" else []) + (["方向只能在停泵时改变"] if capability == "pumping.set_direction" else []) + (["宿主已配置固定注射器、连接液体容器并设置正流量；供体非空、受体未满、剩余行程为正"] if capability == "pumping.start" else []) + (["宿主注册了实际场景回调"] if capability.startswith("scene.") else []), "completion_criterion_zh": "返回值中的设定或开关状态已写入；过程演化仅发生于宿主step，succeeded不代表达到温度或完成输液"} spec["capabilities"] = caps spec["declared_capabilities"] = copy.deepcopy(DECLARED_CAPABILITIES.get(type_id, {})) return {"asset_types": assets, "host_capabilities": copy.deepcopy(HOST_CAPABILITIES), "result_schema_scope": "Each capability output_schema describes response.result, not the entire standard protocol envelope", "trusted_scene_callback": "__call__(instance_id: str, updates: dict[state_id, value]); all state values use SI"} def _number(value: Any) -> bool: if type(value) not in (int, float): return False try: return math.isfinite(value) except (OverflowError, TypeError): return False @dataclass class _Instance: instance_id: str asset_type_id: str state: dict[str, Any] revision: int = 0 syringe: dict[str, Any] | None = None connections: tuple[str, str] | None = None @dataclass class _Vessel: volume_m3: float capacity_m3: float species_mass_kg: dict[str, float] = field(default_factory=dict) class SceneSynchronizationError(RuntimeError): """World time/process advanced, but at least one backend sync failed.""" class LabHost: """Trusted host API: registration, identity, materials, scene and world time. Do not expose this object to an untrusted agent. Supply a LabSession or a remote wrapper with authenticated host-side principal selection instead. Deduplication is in-memory and intentionally makes no restart guarantee. """ def __init__(self, *, ambient_temperature_K=293.15, scene_adapter: Callable[[str, dict[str, Any]], None] | None = None): if not _number(ambient_temperature_K) or not 273.15 <= ambient_temperature_K <= 313.15: raise ValueError("Ambient temperature must be finite and within the assumed 273.15–313.15 K model range") self.ambient_temperature_K = float(ambient_temperature_K) self.time_s = 0.0 self.scene_adapter = scene_adapter self._instances: dict[str, _Instance] = {} self._vessels: dict[str, _Vessel] = {} self._principals: dict[str, tuple[str, frozenset[str] | None]] = {} self._requests: dict[tuple[str, str, str], tuple[str, dict[str, Any]]] = {} self._logs: dict[str, list[dict[str, Any]]] = {} self._transactions: list[dict[str, Any]] = [] self._scene_faults: list[dict[str, Any]] = [] self._lock = threading.RLock() def create_instance(self, instance_id: str, asset_type_id: str): with self._lock: if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances: raise ValueError("Instance ID must be unique and nonempty") if asset_type_id not in ASSET_SPECS: raise ValueError("Unknown asset type") slots = ASSET_SPECS[asset_type_id]["state_slots"] state = {sid: 0.0 for sid in slots} state["power.enabled"] = False if "thermal.target_k" in slots: state["thermal.target_k"] = self.ambient_temperature_K + (10 if asset_type_id.endswith("binder_fd56") else 0) state["thermal.temperature_k"] = self.ambient_temperature_K state["thermal.indicated_temperature_k"] = round(self.ambient_temperature_K, 1) if "pumping.running" in slots: state["pumping.running"] = False state["pumping.direction"] = "infuse" if "ventilation.face_velocity_m_s" in slots: state["ventilation.face_velocity_m_s"] = None if self.scene_adapter: self.scene_adapter(instance_id, copy.deepcopy(state)) self._instances[instance_id] = _Instance(instance_id, asset_type_id, state) def sync_scene(self, instance_ids=None): """Explicit host resync after loading/configuration; no time advance. Call this after configuring a syringe and connecting its loaded content. Initial creation already pushes all initial slots when a backend exists. """ if self.scene_adapter is None: raise RuntimeError("No scene backend is registered") with self._lock: ids = list(self._instances) if instance_ids is None else list(instance_ids) if any(key not in self._instances for key in ids): raise ValueError("Unknown scene instance") for key in ids: try: self.scene_adapter(key, copy.deepcopy(self._instances[key].state)) except Exception: self._scene_faults.append({"instance_id": key, "time_s": self.time_s, "code": "SCENE_SYNC_FAILED"}) raise SceneSynchronizationError("Scene resynchronization failed; backend may have partial effects") from None def describe_host(self): """Trusted host metadata; sim.step is never an instrument capability.""" return copy.deepcopy(HOST_CAPABILITIES) def register_principal(self, principal_id: str, *, visibility: str, instance_ids=None): if visibility not in ("agent", "debug", "evaluator"): raise ValueError("Invalid host-assigned visibility") if not isinstance(principal_id, str) or not principal_id: raise ValueError("Invalid principal ID") with self._lock: if principal_id in self._principals: raise ValueError("Principal already registered; identities are immutable for session lifetime") allowed = None if instance_ids is None else frozenset(instance_ids) if allowed is not None and not allowed <= self._instances.keys(): raise ValueError("Principal scope includes an unknown instance") self._principals[principal_id] = (visibility, allowed) self._logs[principal_id] = [] def session(self, principal_id: str) -> "LabSession": if principal_id not in self._principals: raise ValueError("Principal must first be authenticated and registered by the host") return LabSession(self, principal_id) def create_vessel(self, vessel_id: str, *, volume_m3: float, capacity_m3: float, species_mass_kg: dict[str, float]): with self._lock: if not isinstance(vessel_id, str) or not vessel_id or vessel_id in self._vessels: raise ValueError("Vessel ID must be unique and nonempty") if not (_number(volume_m3) and _number(capacity_m3) and 0 <= volume_m3 <= capacity_m3 and capacity_m3 > 0): raise ValueError("Invalid vessel volume or capacity") if not isinstance(species_mass_kg, dict) or any(not isinstance(k, str) or not k or not _number(v) or v < 0 for k, v in species_mass_kg.items()): raise ValueError("Invalid material masses") if volume_m3 == 0 and any(species_mass_kg.values()): raise ValueError("An empty liquid vessel cannot contain nonzero material mass") self._vessels[vessel_id] = _Vessel(float(volume_m3), float(capacity_m3), copy.deepcopy(species_mass_kg)) def configure_syringe(self, instance_id: str, *, diameter_m: float, stroke_m: float, evidence: str): with self._lock: inst = self._require_pump(instance_id) if inst.state["pumping.running"]: raise ValueError("Stop pump before changing calibrated syringe") if not (_number(diameter_m) and _number(stroke_m) and math.isclose(diameter_m, self._value(inst, "syringe_diameter_m"), rel_tol=1e-9) and math.isclose(stroke_m, self._value(inst, "syringe_stroke_m"), rel_tol=1e-9)): raise ValueError("This asset type requires the declared B-D 10 mL nominal geometry") if not isinstance(evidence, str) or not evidence.strip(): raise ValueError("Per-instance calibration evidence is required") inst.syringe = {"diameter_m": float(diameter_m), "stroke_m": float(stroke_m), "area_m2": math.pi * diameter_m**2 / 4, "evidence": evidence} inst.state["pumping.transferred_volume_m3"] = 0.0 inst.state["pumping.plunger_displacement_m"] = 0.0 inst.connections = None inst.revision += 1 def connect_pump(self, instance_id: str, syringe_vessel_id: str, external_vessel_id: str): """Bind syringe content and external liquid vessel; direction selects donor. Infuse: syringe -> external. Withdraw: external -> syringe. Initial plunger position is derived from the explicitly loaded syringe volume. Host setup represents physical loading; it never adds or deletes matter. Each syringe vessel is exclusive to its pump and cannot be used as any other pump's external vessel. External collection vessels may be shared. Rejected configuration leaves connections, plunger and revision unchanged. """ with self._lock: inst = self._require_pump(instance_id) if inst.state["pumping.running"]: raise ValueError("Stop pump before changing material connections") if syringe_vessel_id == external_vessel_id or syringe_vessel_id not in self._vessels or external_vessel_id not in self._vessels: raise ValueError("Two distinct registered material vessels are required") if not inst.syringe: raise ValueError("Configure the declared syringe geometry before connecting") for other in self._instances.values(): if other is inst or not other.connections: continue other_syringe, other_external = other.connections if syringe_vessel_id in (other_syringe, other_external) or external_vessel_id == other_syringe: raise ValueError("A syringe vessel must be exclusive to one pump and cannot serve another pump as an external vessel") syringe = self._vessels[syringe_vessel_id] capacity = inst.syringe["area_m2"] * inst.syringe["stroke_m"] if syringe.volume_m3 > capacity + 1e-18: raise ValueError("Loaded content exceeds the declared 10 mL syringe") inst.connections = (syringe_vessel_id, external_vessel_id) inst.state["pumping.plunger_displacement_m"] = max(0.0, inst.syringe["stroke_m"] - syringe.volume_m3 / inst.syringe["area_m2"]) inst.revision += 1 def set_external_exhaust(self, instance_id: str, flow_rate_m3_s: float): """Host facility boundary condition, at current room conditions; not a sensor.""" with self._lock: inst = self._instances[instance_id] if inst.asset_type_id != "instrument.esco_efa5": raise ValueError("External exhaust applies only to the fume hood") if not _number(flow_rate_m3_s) or not 0 <= flow_rate_m3_s <= 5: raise ValueError("Flow must fit the assumed 0–5 m^3/s facility envelope") inst.state["ventilation.external_exhaust_m3_s"] = float(flow_rate_m3_s) self._update_face_velocity(inst) inst.revision += 1 def _require_pump(self, instance_id): inst = self._instances[instance_id] if inst.asset_type_id != "instrument.ne1000_bd10ml": raise ValueError("Operation requires a syringe pump") return inst def _value(self, inst, name): return ASSET_SPECS[inst.asset_type_id]["parameters"][name]["value"] def _update_face_velocity(self, inst): opening = inst.state["sash.opening_m"] area = self._value(inst, "opening_width_m") * opening inst.state["ventilation.face_velocity_m_s"] = inst.state["ventilation.external_exhaust_m3_s"] / area if area > 0 else None def _thermal_step(self, inst, dt): s = inst.state ambient = self.ambient_temperature_K old = s["thermal.temperature_k"] capacity = self._value(inst, "thermal_capacity_J_K") loss = self._value(inst, "heat_loss_W_K") power = self._value(inst, "heater_power_W") if s["power.enabled"] else 0 if "door.angle_rad" in s: fraction = s["door.angle_rad"] / self._value(inst, "maximum_door_angle_rad") loss += fraction * self._value(inst, "door_open_loss_W_K") power *= 1 - fraction * (1 - self._value(inst, "door_open_heater_fraction")) target = s["thermal.target_k"] decay = math.exp(-loss * dt / capacity) if not power: temperature = ambient + (old - ambient) * decay elif old < target: equilibrium = ambient + power / loss temperature = min(target, equilibrium + (old - equilibrium) * decay) else: cooled = ambient + (old - ambient) * decay if cooled >= target: temperature = cooled else: crossing_s = -capacity / loss * math.log((target - ambient) / (old - ambient)) if target > ambient and old > target else 0.0 equilibrium = ambient + power / loss temperature = min(target, equilibrium + (target - equilibrium) * math.exp(-loss * max(0.0, dt - crossing_s) / capacity)) s["thermal.temperature_k"] = temperature # A declared ideal display proxy, rounded to 0.1 K; no sensor accuracy claim. s["thermal.indicated_temperature_k"] = round(temperature, 1) def _pump_step(self, inst, dt): s = inst.state if not s["pumping.running"]: return if not s["power.enabled"] or not inst.syringe or not inst.connections: s["pumping.running"] = False return infuse = s["pumping.direction"] == "infuse" donor_id, recipient_id = inst.connections if infuse else tuple(reversed(inst.connections)) donor, recipient = self._vessels[donor_id], self._vessels[recipient_id] area = inst.syringe["area_m2"] stroke_remaining = max(0.0, inst.syringe["stroke_m"] - s["pumping.plunger_displacement_m"] if infuse else s["pumping.plunger_displacement_m"]) available = min(donor.volume_m3, max(0.0, recipient.capacity_m3 - recipient.volume_m3), stroke_remaining * area) requested = s["pumping.flow_rate_m3_s"] * dt volume = min(requested, available) if volume > 0: fraction = min(1.0, volume / donor.volume_m3) masses = {key: value * fraction for key, value in donor.species_mass_kg.items()} # All checks and the entire material transaction occur under the world lock. for key, mass in masses.items(): donor.species_mass_kg[key] -= mass recipient.species_mass_kg[key] = recipient.species_mass_kg.get(key, 0.0) + mass donor.volume_m3 -= volume recipient.volume_m3 += volume s["pumping.transferred_volume_m3"] += volume s["pumping.plunger_displacement_m"] += (1 if infuse else -1) * volume / area self._transactions.append({"transaction_id": f"transfer_{len(self._transactions) + 1:06d}", "instance_id": inst.instance_id, "donor_id": donor_id, "recipient_id": recipient_id, "volume_m3": volume, "species_mass_kg": masses, "start_time_s": self.time_s, "end_time_s": self.time_s + dt, "direction": s["pumping.direction"], "quality": "synthetic_process_truth"}) if available <= requested + 1e-18: s["pumping.running"] = False def step(self, dt_s: float): """Advance one trusted world step; read/invoke never call this method. The batch model permits up to 3600 seconds per step. Transfers use a constant commanded rate, exact bounded volume and homogeneous material. A failed backend synchronization leaves already-advanced process state intact and raises SceneSynchronizationError after the common clock commits. """ if not _number(dt_s) or not 0 <= dt_s <= 3600: raise ValueError("dt_s must be finite and in [0, 3600]") if not dt_s: return with self._lock: scene_failed = False for inst in self._instances.values(): before = copy.deepcopy(inst.state) s = inst.state if "thermal.temperature_k" in s: self._thermal_step(inst, dt_s) if "stirring.speed_rad_s" in s: old = s["stirring.speed_rad_s"] target = s["stirring.target_rad_s"] if s["power.enabled"] else 0.0 tau = self._value(inst, "stirring_time_constant_s") decay = math.exp(-dt_s / tau) s["stirring.speed_rad_s"] = target + (old - target) * decay s["stirring.angle_rad"] = (s["stirring.angle_rad"] + target * dt_s + (old - target) * tau * (1 - decay)) % (2 * math.pi) s["stirring.indicated_speed_rad_s"] = round(s["stirring.speed_rad_s"] / RPM_TO_RAD_S) * RPM_TO_RAD_S if "pumping.running" in s: self._pump_step(inst, dt_s) if before != s: inst.revision += 1 if self.scene_adapter: updates = {key: copy.deepcopy(value) for key, value in s.items() if before[key] != value} if updates: try: self.scene_adapter(inst.instance_id, updates) except Exception: scene_failed = True self._scene_faults.append({"instance_id": inst.instance_id, "time_s": self.time_s + dt_s, "code": "SCENE_SYNC_FAILED"}) self.time_s += dt_s if scene_failed: raise SceneSynchronizationError("Process and common clock advanced; one or more scene updates failed. Inspect trusted host diagnostics.") def debug_snapshot(self): """Host-only diagnostic state. Never expose as an agent tool or file.""" with self._lock: return copy.deepcopy({"time_s": self.time_s, "instances": {key: {"asset_type_id": inst.asset_type_id, "revision": inst.revision, "state": inst.state, "syringe": inst.syringe, "connections": inst.connections} for key, inst in self._instances.items()}, "vessels": {key: {"volume_m3": vessel.volume_m3, "capacity_m3": vessel.capacity_m3, "species_mass_kg": vessel.species_mass_kg} for key, vessel in self._vessels.items()}, "transactions": self._transactions, "scene_faults": self._scene_faults}) class LabSession: """Agent-facing adapter; access is resolved from an immutable host registry.""" def __init__(self, host: LabHost, principal_id: str): self.__host = host self.__principal_id = principal_id def _allowed(self, inst): _, scope = self.__host._principals[self.__principal_id] return scope is None or inst.instance_id in scope def _visible(self, spec): role, _ = self.__host._principals[self.__principal_id] return spec["visibility"] == "agent" or role in ("debug", "evaluator") def _envelope(self, instance_id, request_id=None, *, status="succeeded", result=None, observations=None, error=None): host = self.__host safe_instance_id = instance_id if isinstance(instance_id, str) else None safe_request_id = request_id if isinstance(request_id, str) else None inst = host._instances.get(safe_instance_id) return {"protocol_version": PROTOCOL_VERSION, "instance_id": safe_instance_id, "request_id": safe_request_id, "operation_id": None, "status": status, "state_revision": inst.revision if inst and self._allowed(inst) else None, "clock": {"domain": "simulation", "time_s": host.time_s}, "result": {} if result is None else result, "observations": {} if observations is None else observations, "error": error} def _error(self, instance_id, code, request_id=None, status="rejected"): # Deliberately static messages; never interpolate internal state/exception text. messages = {"UNKNOWN_INSTANCE": "Instance is unavailable in this session.", "UNKNOWN_CAPABILITY": "Capability is unavailable for this asset.", "INVALID_ARGUMENT": "Arguments do not meet the declared schema or limits.", "PRECONDITION_FAILED": "Required operating configuration or state is unavailable.", "ACCESS_DENIED": "Requested operation is outside the session access policy.", "REQUEST_CONFLICT": "Request ID was already used for a different operation or arguments.", "UNSUPPORTED": "Capability execution is not available in this adapter configuration.", "DEVICE_ERROR": "Scene backend did not complete the command."} return self._envelope(instance_id, request_id, status=status, error={"code": code, "message": messages[code], "retryable": False, "side_effects": "unknown" if code == "DEVICE_ERROR" else "none", "progress": None}) def _instance(self, instance_id): if not isinstance(instance_id, str): return None inst = self.__host._instances.get(instance_id) return inst if inst and self._allowed(inst) else None def describe(self, *, asset_type_id=None, instance_id=None): with self.__host._lock: if (asset_type_id is None) == (instance_id is None): return self._error(None, "INVALID_ARGUMENT") if instance_id is not None: inst = self._instance(instance_id) if not inst: return self._error(instance_id, "UNKNOWN_INSTANCE") asset_type_id = inst.asset_type_id if not isinstance(asset_type_id, str) or asset_type_id not in ASSET_SPECS: return self._error(instance_id, "INVALID_ARGUMENT") _, scope = self.__host._principals[self.__principal_id] if scope is not None and not any(self.__host._instances[key].asset_type_id == asset_type_id for key in scope): return self._error(instance_id, "ACCESS_DENIED") spec = export_contract_metadata()["asset_types"][asset_type_id] capabilities = {} for capability, info in spec["capabilities"].items(): capabilities[capability] = {"input_schema": copy.deepcopy(info["input_schema"]), "output_schema": copy.deepcopy(info["output_schema"]), "description_zh": info["description_zh"], "preconditions_zh": info["preconditions_zh"], "availability": "unsupported" if capability.startswith("scene.") and self.__host.scene_adapter is None else "implemented"} capabilities.update(copy.deepcopy(spec["declared_capabilities"])) return {"protocol_version": PROTOCOL_VERSION, "asset_type_id": asset_type_id, "asset_version": spec["asset_version"], "instance_id": instance_id, "catalog_id": spec["catalog_id"], "model": spec["model"], "adapter": "basic40_runtime.LabSession", "capabilities": capabilities, "state_slots": copy.deepcopy({sid: slot for sid, slot in spec["state_slots"].items() if self._visible(slot)}), "limitations": ["Synthetic process model; no real hardware or robot execution.", "Readout proxies are estimated, not measured sensor readings.", "In-memory request deduplication does not survive host restart.", "Python API filtering is not process/filesystem isolation.", "Esco model uses the base switch-controlled lighting configuration; no digital display or Sentinel airflow sensor is assumed.", "Fume face velocity is a host Q/area estimate; manufacturer rated working points are not this model's measurements or a safety assessment."]} def read(self, *, instance_id, state_ids=None): with self.__host._lock: inst = self._instance(instance_id) if not inst: return self._error(instance_id, "UNKNOWN_INSTANCE") slots = ASSET_SPECS[inst.asset_type_id]["state_slots"] if state_ids is None: state_ids = [key for key, slot in slots.items() if self._visible(slot)] if not isinstance(state_ids, list) or any(not isinstance(key, str) for key in state_ids) or len(set(state_ids)) != len(state_ids): return self._error(instance_id, "INVALID_ARGUMENT") # Unknown and restricted IDs have the same error to avoid truth discovery. if any(key not in slots or not self._visible(slots[key]) for key in state_ids): return self._error(instance_id, "ACCESS_DENIED") observations = {} for key in state_ids: value = copy.deepcopy(inst.state[key]) quality = "unavailable" if value is None else "estimated" if slots[key]["origin"] == "derived" else "valid" observations[key] = {"value": value, "unit": slots[key]["unit"], "quality": quality, "sample_time_s": self.__host.time_s, "sample_window_s": None} if value is None: observations[key]["reason"] = "Face velocity is undefined at zero modeled open area." return self._envelope(instance_id, observations=observations) def invoke(self, *, instance_id, capability_id, arguments, request_id): host = self.__host with host._lock: inst = self._instance(instance_id) if not inst: return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) if not isinstance(request_id, str) or not request_id or len(request_id) > 256 or not isinstance(capability_id, str) or not isinstance(arguments, dict): return self._error(instance_id, "INVALID_ARGUMENT", request_id if isinstance(request_id, str) else None) try: digest = hashlib.sha256(json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False, separators=(",", ":")).encode()).hexdigest() except (ValueError, TypeError): return self._error(instance_id, "INVALID_ARGUMENT", request_id) key = (self.__principal_id, instance_id, request_id) if key in host._requests: previous_digest, response = host._requests[key] if digest != previous_digest: return self._error(instance_id, "REQUEST_CONFLICT", request_id) return copy.deepcopy(response) response = self._invoke_checked(inst, capability_id, arguments, request_id) host._requests[key] = (digest, copy.deepcopy(response)) host._logs[self.__principal_id].append({"instance_id": instance_id, "capability_id": capability_id, "request_id": request_id, "response": copy.deepcopy(response)}) return response def _invoke_checked(self, inst, capability, args, request): host, s = self.__host, inst.state spec = ASSET_SPECS[inst.asset_type_id] fail = lambda code, status="rejected": self._error(inst.instance_id, code, request, status) if capability in DECLARED_CAPABILITIES.get(inst.asset_type_id, {}): return fail("UNSUPPORTED", "unsupported") if capability not in spec["capabilities"]: return fail("UNKNOWN_CAPABILITY") expected = CAPABILITY_ARGUMENTS[capability] if set(args) != set(expected): return fail("INVALID_ARGUMENT") for key, description in expected.items(): if description["type"] == "boolean" and type(args[key]) is not bool: return fail("INVALID_ARGUMENT") if description["type"] == "number" and not _number(args[key]): return fail("INVALID_ARGUMENT") if description["type"] == "string" and (not isinstance(args[key], str) or args[key] not in description["enum"]): return fail("INVALID_ARGUMENT") value = next(iter(args.values()), None) if capability == "thermal.set_temperature": minimum = host.ambient_temperature_K + (10 if inst.asset_type_id.endswith("binder_fd56") else 0) if not minimum <= value <= host._value(inst, "maximum_temperature_K"): return fail("INVALID_ARGUMENT") elif capability == "stirring.set_speed": rpm = value / RPM_TO_RAD_S if value != 0 and (rpm < 50 - 1e-9 or rpm > 1500 + 1e-9 or not math.isclose((rpm - 50) / 10, round((rpm - 50) / 10), abs_tol=1e-8)): return fail("INVALID_ARGUMENT") elif capability == "scene.set_door": if not 0 <= value <= host._value(inst, "maximum_door_angle_rad"): return fail("INVALID_ARGUMENT") elif capability == "scene.set_sash": if not 0 <= value <= host._value(inst, "maximum_sash_opening_m"): return fail("INVALID_ARGUMENT") elif capability == "pumping.set_flow_rate": if not host._value(inst, "minimum_flow_rate_m3_s") <= value <= host._value(inst, "maximum_flow_rate_m3_s"): return fail("INVALID_ARGUMENT") if capability in ("thermal.set_temperature", "stirring.set_speed", "pumping.set_flow_rate", "pumping.set_direction", "pumping.start") and not s["power.enabled"]: return fail("PRECONDITION_FAILED") if capability == "pumping.set_direction" and s["pumping.running"]: return fail("PRECONDITION_FAILED") if capability == "pumping.start": if not inst.syringe or not inst.connections or s["pumping.flow_rate_m3_s"] <= 0: return fail("PRECONDITION_FAILED") infuse = s["pumping.direction"] == "infuse" donor, recipient = (host._vessels[key] for key in (inst.connections if infuse else tuple(reversed(inst.connections)))) remaining = max(0.0, inst.syringe["stroke_m"] - s["pumping.plunger_displacement_m"] if infuse else s["pumping.plunger_displacement_m"]) * inst.syringe["area_m2"] if donor.volume_m3 <= 0 or remaining <= 1e-18 or recipient.volume_m3 >= recipient.capacity_m3: return fail("PRECONDITION_FAILED") output_key, slot = CAPABILITY_RESULT_SLOT[capability] if capability == "pumping.start": value = True elif capability == "pumping.stop": value = False if capability.startswith("scene.") and host.scene_adapter is None: return fail("UNSUPPORTED", "unsupported") updates = {slot: value} if capability == "power.set" and not value and "pumping.running" in s: updates["pumping.running"] = False if capability == "scene.set_sash": area = host._value(inst, "opening_width_m") * value updates["ventilation.face_velocity_m_s"] = s["ventilation.external_exhaust_m3_s"] / area if area > 0 else None if host.scene_adapter: try: host.scene_adapter(inst.instance_id, copy.deepcopy(updates)) except Exception: # A foreign backend can have partial effects. Internal process state # is unchanged, but this is failed/unknown, never rejected/none. return fail("DEVICE_ERROR", "failed") s.update(updates) inst.revision += 1 # Only declared, visible completion values are returned; no full snapshot. return self._envelope(inst.instance_id, request, result={output_key: value}) def write(self, *, instance_id, state_id, value, request_id): with self.__host._lock: inst = self._instance(instance_id) if not inst: return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) slots = ASSET_SPECS[inst.asset_type_id]["state_slots"] if not isinstance(state_id, str) or state_id not in slots or not self._visible(slots[state_id]): return self._error(instance_id, "ACCESS_DENIED", request_id) slot = slots[state_id] if slot["access"] != "read_write" or not slot["write_via"]: return self._error(instance_id, "ACCESS_DENIED", request_id) route = slot["write_via"] return self.invoke(instance_id=instance_id, capability_id=route["capability_id"], arguments={route["parameter"]: value}, request_id=request_id) def logs(self): """Only this principal's already-filtered response records.""" with self.__host._lock: return copy.deepcopy(self.__host._logs[self.__principal_id]) def validate_runtime(output: Path | None = None): """Run deterministic synthetic tests, recording actual environment and time.""" import importlib.util import io import unittest test_file = Path(__file__).resolve().parents[1] / "tests" / "test_basic40_runtime.py" spec = importlib.util.spec_from_file_location("test_basic40_runtime", test_file) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) suite = unittest.defaultTestLoader.loadTestsFromModule(module) stream = io.StringIO() result = unittest.TextTestRunner(stream=stream, verbosity=2).run(suite) report = {"schema_version": "1.0.0", "recorded_at": datetime.now(timezone.utc).isoformat(), "method": "unittest through real LabSession describe/read/invoke/write and trusted LabHost.step", "environment": {"python": platform.python_version(), "platform": platform.platform()}, "data_classification": "Deterministic synthetic fixtures only; no real sample state", "tests_run": result.testsRun, "result": "passed" if result.wasSuccessful() else "failed", "failures": len(result.failures), "errors": len(result.errors), "log": stream.getvalue(), "layers": {"process": "passed" if result.wasSuccessful() else "failed", "host": "passed" if result.wasSuccessful() else "failed", "scene": "not_run", "robot": "not_run", "hardware": "not_run"}, "limitations": ["Scene tests use an atomic recording callback, not evaluated Blender geometry.", "API visibility filtering is verified; filesystem/process isolation is not implemented.", "Physics coefficients are uncalibrated assumptions and sensor proxies are estimated."]} if output: output.parent.mkdir(parents=True, exist_ok=True) output.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") return report if __name__ == "__main__": parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--validate", type=Path, metavar="REPORT_JSON") parsed = parser.parse_args() if parsed.validate: report = validate_runtime(parsed.validate) print(json.dumps({key: report[key] for key in ("tests_run", "result", "failures", "errors")}, indent=2)) raise SystemExit(0 if report["result"] == "passed" else 1) parser.print_help()