new workflow & prcxi slot removal

(cherry picked from commit 06b6f0d804)

.conda/base/recipe.yaml

@@ -3,7 +3,7 @@
 
 package:
   name: unilabos
-  version: 0.10.19
+  version: 0.10.18
 
 source:
   path: ../../unilabos
@@ -54,7 +54,7 @@ requirements:
   - pymodbus
   - matplotlib
   - pylibftdi
-  - uni-lab::unilabos-env ==0.10.19
+  - uni-lab::unilabos-env ==0.10.18
 
 about:
   repository: https://github.com/deepmodeling/Uni-Lab-OS

.conda/environment/recipe.yaml

@@ -2,7 +2,7 @@
 
 package:
   name: unilabos-env
-  version: 0.10.19
+  version: 0.10.18
 
 build:
   noarch: generic

.conda/full/recipe.yaml

@@ -3,7 +3,7 @@
 
 package:
   name: unilabos-full
-  version: 0.10.19
+  version: 0.10.18
 
 build:
   noarch: generic
@@ -11,7 +11,7 @@ build:
 requirements:
   run:
   # Base unilabos package (includes unilabos-env)
-  - uni-lab::unilabos ==0.10.19
+  - uni-lab::unilabos ==0.10.18
   # Documentation tools
   - sphinx
   - sphinx_rtd_theme

.cursor/skills/create-device-skill/SKILL.md

@@ -1,328 +0,0 @@
----
-name: create-device-skill
-description: Create a skill for any Uni-Lab device by extracting action schemas from the device registry. Use when the user wants to create a new device skill, add device API documentation, or set up action schemas for a device.
----
-
-# 创建设备 Skill 指南
-
-本 meta-skill 教你如何为任意 Uni-Lab-OS 设备创建完整的 API 操作技能（参考 `unilab-device-api` 的成功案例）。
-
-## 数据源
-
-- **设备注册表**: `unilabos_data/req_device_registry_upload.json`
-- **结构**: `{ "resources": [{ "id": "<device_id>", "class": { "module": "<python_module:ClassName>", "action_value_mappings": { ... } } }] }`
-- **生成时机**: `unilab` 启动并完成注册表上传后自动生成
-- **module 字段**: 格式 `unilabos.devices.xxx.yyy:ClassName`，可转为源码路径 `unilabos/devices/xxx/yyy.py`，阅读源码可了解参数含义和设备行为
-
-## 创建流程
-
-### Step 0 — 收集必备信息（缺一不可，否则询问后终止）
-
-开始前**必须**确认以下 4 项信息全部就绪。如果用户未提供任何一项，**立即询问并终止当前流程**，等用户补齐后再继续。
-
-向用户提问：「请提供你的 unilab 启动参数，我需要以下信息：」
-
-#### 必备项 ①：ak / sk（认证凭据）
-
-来源：启动命令的 `--ak` `--sk` 参数，或 config.py 中的 `ak = "..."` `sk = "..."`。
-
-获取后立即生成 AUTH token：
-
-```bash
-python ./scripts/gen_auth.py <ak> <sk>
-# 或从 config.py 提取
-python ./scripts/gen_auth.py --config <config.py>
-```
-
-认证算法：`base64(ak:sk)` → `Authorization: Lab <token>`
-
-#### 必备项 ②：--addr（目标环境）
-
-决定 API 请求发往哪个服务器。从启动命令的 `--addr` 参数获取：
-
-| `--addr` 值 | BASE URL |
-|-------------|----------|
-| `test` | `https://uni-lab.test.bohrium.com` |
-| `uat` | `https://uni-lab.uat.bohrium.com` |
-| `local` | `http://127.0.0.1:48197` |
-| 不传（默认） | `https://uni-lab.bohrium.com` |
-| 其他自定义 URL | 直接使用该 URL |
-
-#### 必备项 ③：req_device_registry_upload.json（设备注册表）
-
-数据文件由 `unilab` 启动时自动生成，需要定位它：
-
-**推断 working_dir**（即 `unilabos_data` 所在目录）：
-
-| 条件 | working_dir 取值 |
-|------|------------------|
-| 传了 `--working_dir` | `<working_dir>/unilabos_data/`（若子目录已存在则直接用） |
-| 仅传了 `--config` | `<config 文件所在目录>/unilabos_data/` |
-| 都没传 | `<当前工作目录>/unilabos_data/` |
-
-**按优先级搜索文件**：
-
-```
-<推断的 working_dir>/unilabos_data/req_device_registry_upload.json
-<推断的 working_dir>/req_device_registry_upload.json
-<workspace 根目录>/unilabos_data/req_device_registry_upload.json
-```
-
-也可以直接 Glob 搜索：`**/req_device_registry_upload.json`
-
-找到后**必须检查文件修改时间**并告知用户：「找到注册表文件 `<路径>`，生成于 `<时间>`。请确认这是最近一次启动生成的。」超过 1 天提醒用户是否需要重新启动 `unilab`。
-
-**如果文件不存在** → 告知用户先运行 `unilab` 启动命令，等日志出现 `注册表响应数据已保存` 后再执行本流程。**终止。**
-
-#### 必备项 ④：目标设备
-
-用户需要明确要为哪个设备创建 skill。可以是设备名称（如「PRCXI 移液站」）或 device_id（如 `liquid_handler.prcxi`）。
-
-如果用户不确定，运行提取脚本列出所有设备供选择：
-
-```bash
-python ./scripts/extract_device_actions.py --registry <找到的文件路径>
-```
-
-#### 完整示例
-
-用户提供：
-
-```
---ak a1fd9d4e-xxxx-xxxx-xxxx-d9a69c09f0fd
---sk 136ff5c6-xxxx-xxxx-xxxx-a03e301f827b
---addr test
---port 8003
---disable_browser
-```
-
-从中提取：
-- ✅ ak/sk → 运行 `gen_auth.py` 得到 `AUTH="Authorization: Lab YTFmZDlk..."`
-- ✅ addr=test → `BASE=https://uni-lab.test.bohrium.com`
-- ✅ 搜索 `unilabos_data/req_device_registry_upload.json` → 找到并确认时间
-- ✅ 用户指明目标设备 → 如 `liquid_handler.prcxi`
-
-**四项全部就绪后才进入 Step 1。**
-
-### Step 1 — 列出可用设备
-
-运行提取脚本，列出所有设备及 action 数量和 Python 源码路径，让用户选择：
-
-```bash
-# 自动搜索（默认在 unilabos_data/ 和当前目录查找）
-python ./scripts/extract_device_actions.py
-
-# 指定注册表文件路径
-python ./scripts/extract_device_actions.py --registry <path/to/req_device_registry_upload.json>
-```
-
-脚本输出包含每个设备的 **Python 源码路径**（从 `class.module` 转换），可用于后续阅读源码理解参数含义。
-
-### Step 2 — 提取 Action Schema
-
-用户选择设备后，运行提取脚本：
-
-```bash
-python ./scripts/extract_device_actions.py [--registry <path>] <device_id> ./skills/<skill-name>/actions/
-```
-
-脚本会显示设备的 Python 源码路径和类名，方便阅读源码了解参数含义。
-
-每个 action 生成一个 JSON 文件，包含：
-- `type` — 作为 API 调用的 `action_type`
-- `schema` — 完整 JSON Schema（含 `properties.goal.properties` 参数定义）
-- `goal` — goal 字段映射（含占位符 `$placeholder`）
-- `goal_default` — 默认值
-
-### Step 3 — 写 action-index.md
-
-按模板为每个 action 写条目：
-
-```markdown
-### `<action_name>`
-
-<用途描述（一句话）>
-
-- **Schema**: [`actions/<filename>.json`](actions/<filename>.json)
-- **核心参数**: `param1`, `param2`（从 schema.required 获取）
-- **可选参数**: `param3`, `param4`
-- **占位符字段**: `field`（需填入物料信息，值以 `$` 开头）
-```
-
-描述规则：
-- 从 `schema.properties` 读参数列表（schema 已提升为 goal 内容）
-- 从 `schema.required` 区分核心/可选参数
-- 按功能分类（移液、枪头、外设等）
-- 标注 `placeholder_keys` 中的字段类型：
-  - `unilabos_resources` → **ResourceSlot**，填入 `{id, name, uuid}`（id 是路径格式，从资源树取物料节点）
-  - `unilabos_devices` → **DeviceSlot**，填入路径字符串如 `"/host_node"`（从资源树筛选 type=device）
-  - `unilabos_nodes` → **NodeSlot**，填入路径字符串如 `"/PRCXI/PRCXI_Deck"`（资源树中任意节点）
-  - `unilabos_class` → **ClassSlot**，填入类名字符串如 `"container"`（从注册表查找）
-- array 类型字段 → `[{id, name, uuid}, ...]`
-- 特殊：`create_resource` 的 `res_id`（ResourceSlot）可填不存在的路径
-
-### Step 4 — 写 SKILL.md
-
-直接复用 `unilab-device-api` 的 API 模板（10 个 endpoint），修改：
-- 设备名称
-- Action 数量
-- 目录列表
-- Session state 中的 `device_name`
-- **AUTH 头** — 使用 Step 0 中 `gen_auth.py` 生成的 `Authorization: Lab <token>`（不要硬编码 `Api` 类型的 key）
-- **Python 源码路径** — 在 SKILL.md 开头注明设备对应的源码文件，方便参考参数含义
-- **Slot 字段表** — 列出本设备哪些 action 的哪些字段需要填入 Slot（物料/设备/节点/类名）
-
-API 模板结构：
-
-```markdown
-## 设备信息
-- device_id, Python 源码路径, 设备类名
-
-## 前置条件（缺一不可）
-- ak/sk → AUTH, --addr → BASE URL
-
-## Session State
-- lab_uuid（通过 API #1 自动匹配，不要问用户）, device_name
-
-## API Endpoints (10 个)
-# 注意：
-# - #1 获取 lab 列表 + 自动匹配 lab_uuid（遍历 is_admin 的 lab，
-#   调用 /lab/info/{uuid} 比对 access_key == ak）
-# - #2 创建工作流用 POST /lab/workflow
-# - #10 获取资源树路径含 lab_uuid: /lab/material/download/{lab_uuid}
-
-## Placeholder Slot 填写规则
-- unilabos_resources → ResourceSlot → {"id":"/path/name","name":"name","uuid":"xxx"}
-- unilabos_devices → DeviceSlot → "/parent/device" 路径字符串
-- unilabos_nodes → NodeSlot → "/parent/node" 路径字符串
-- unilabos_class → ClassSlot → "class_name" 字符串
-- 特例：create_resource 的 res_id 允许填不存在的路径
-- 列出本设备所有 Slot 字段、类型及含义
-
-## 渐进加载策略
-## 完整工作流 Checklist
-```
-
-### Step 5 — 验证
-
-检查文件完整性：
-- [ ] `SKILL.md` 包含 10 个 API endpoint
-- [ ] `SKILL.md` 包含 Placeholder Slot 填写规则（ResourceSlot / DeviceSlot / NodeSlot / ClassSlot + create_resource 特例）和本设备的 Slot 字段表
-- [ ] `action-index.md` 列出所有 action 并有描述
-- [ ] `actions/` 目录中每个 action 有对应 JSON 文件
-- [ ] JSON 文件包含 `type`, `schema`（已提升为 goal 内容）, `goal`, `goal_default`, `placeholder_keys` 字段
-- [ ] 描述能让 agent 判断该用哪个 action
-
-## Action JSON 文件结构
-
-```json
-{
-  "type": "LiquidHandlerTransfer",    // → API 的 action_type
-  "goal": {                           // goal 字段映射
-    "sources": "sources",
-    "targets": "targets",
-    "tip_racks": "tip_racks",
-    "asp_vols": "asp_vols"
-  },
-  "schema": {                         // ← 直接是 goal 的 schema（已提升）
-    "type": "object",
-    "properties": {                   // 参数定义（即请求中 goal 的字段）
-      "sources": { "type": "array", "items": { "type": "object" } },
-      "targets": { "type": "array", "items": { "type": "object" } },
-      "asp_vols": { "type": "array", "items": { "type": "number" } }
-    },
-    "required": [...],
-    "_unilabos_placeholder_info": {   // ← Slot 类型标记
-      "sources": "unilabos_resources",
-      "targets": "unilabos_resources",
-      "tip_racks": "unilabos_resources"
-    }
-  },
-  "goal_default": { ... },            // 默认值
-  "placeholder_keys": {               // ← 汇总所有 Slot 字段
-    "sources": "unilabos_resources",  //    ResourceSlot
-    "targets": "unilabos_resources",
-    "tip_racks": "unilabos_resources",
-    "target_device_id": "unilabos_devices"  // DeviceSlot
-  }
-}
-```
-
-> **注意**：`schema` 已由脚本从原始 `schema.properties.goal` 提升为顶层，直接包含参数定义。
-> `schema.properties` 中的字段即为 API 请求 `param.goal` 中的字段。
-
-## Placeholder Slot 类型体系
-
-`placeholder_keys` / `_unilabos_placeholder_info` 中有 4 种值，对应不同的填写方式：
-
-| placeholder 值 | Slot 类型 | 填写格式 | 选取范围 |
-|---------------|-----------|---------|---------|
-| `unilabos_resources` | ResourceSlot | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` | 仅**物料**节点（不含设备） |
-| `unilabos_devices` | DeviceSlot | `"/parent/device_name"` | 仅**设备**节点（type=device），路径字符串 |
-| `unilabos_nodes` | NodeSlot | `"/parent/node_name"` | **设备 + 物料**，即所有节点，路径字符串 |
-| `unilabos_class` | ClassSlot | `"class_name"` | 注册表中已上报的资源类 name |
-
-### ResourceSlot（`unilabos_resources`）
-
-最常见的类型。从资源树中选取**物料**节点（孔板、枪头盒、试剂槽等）：
-
-```json
-{"id": "/workstation/container1", "name": "container1", "uuid": "ff149a9a-2cb8-419d-8db5-d3ba056fb3c2"}
-```
-
-- 单个（schema type=object）：`{"id": "/path/name", "name": "name", "uuid": "xxx"}`
-- 数组（schema type=array）：`[{"id": "/path/a", "name": "a", "uuid": "xxx"}, ...]`
-- `id` 本身是从 parent 计算的路径格式
-- 根据 action 语义选择正确的物料（如 `sources` = 液体来源，`targets` = 目标位置）
-
-> **特例**：`create_resource` 的 `res_id` 字段，目标物料可能**尚不存在**，此时直接填写期望的路径（如 `"/workstation/container1"`），不需要 uuid。
-
-### DeviceSlot（`unilabos_devices`）
-
-填写**设备路径字符串**。从资源树中筛选 type=device 的节点，从 parent 计算路径：
-
-```
-"/host_node"
-"/bioyond_cell/reaction_station"
-```
-
-- 只填路径字符串，不需要 `{id, uuid}` 对象
-- 根据 action 语义选择正确的设备（如 `target_device_id` = 目标设备）
-
-### NodeSlot（`unilabos_nodes`）
-
-范围 = 设备 + 物料。即资源树中**所有节点**都可以选，填写**路径字符串**：
-
-```
-"/PRCXI/PRCXI_Deck"
-```
-
-- 使用场景：当参数既可能指向物料也可能指向设备时（如 `PumpTransferProtocol` 的 `from_vessel`/`to_vessel`，`create_resource` 的 `parent`）
-
-### ClassSlot（`unilabos_class`）
-
-填写注册表中已上报的**资源类 name**。从本地 `req_resource_registry_upload.json` 中查找：
-
-```
-"container"
-```
-
-### 通过 API #10 获取资源树
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/material/download/$lab_uuid" -H "$AUTH"
-```
-
-注意 `lab_uuid` 在路径中（不是查询参数）。资源树返回所有节点，每个节点包含 `id`（路径格式）、`name`、`uuid`、`type`、`parent` 等字段。填写 Slot 时需根据 placeholder 类型筛选正确的节点。
-
-## 最终目录结构
-
-```
-./<skill-name>/
-├── SKILL.md              # API 端点 + 渐进加载指引
-├── action-index.md       # 动作索引：描述/用途/核心参数
-└── actions/              # 每个 action 的完整 JSON Schema
-    ├── action1.json
-    ├── action2.json
-    └── ...
-```

.cursor/skills/create-device-skill/scripts/extract_device_actions.py

@@ -1,200 +0,0 @@
-#!/usr/bin/env python3
-"""
-从 req_device_registry_upload.json 中提取指定设备的 action schema。
-
-用法:
-  # 列出所有设备及 action 数量（自动搜索注册表文件）
-  python extract_device_actions.py
-
-  # 指定注册表文件路径
-  python extract_device_actions.py --registry <path/to/req_device_registry_upload.json>
-
-  # 提取指定设备的 action 到目录
-  python extract_device_actions.py <device_id> <output_dir>
-  python extract_device_actions.py --registry <path> <device_id> <output_dir>
-
-示例:
-  python extract_device_actions.py --registry unilabos_data/req_device_registry_upload.json
-  python extract_device_actions.py liquid_handler.prcxi .cursor/skills/unilab-device-api/actions/
-"""
-import json
-import os
-import sys
-from datetime import datetime
-
-REGISTRY_FILENAME = "req_device_registry_upload.json"
-
-def find_registry(explicit_path=None):
-    """
-    查找 req_device_registry_upload.json 文件。
-
-    搜索优先级：
-    1. 用户通过 --registry 显式指定的路径
-    2. <cwd>/unilabos_data/req_device_registry_upload.json
-    3. <cwd>/req_device_registry_upload.json
-    4. <script所在目录>/../../.. (workspace根) 下的 unilabos_data/
-    5. 向上逐级搜索父目录（最多 5 层）
-    """
-    if explicit_path:
-        if os.path.isfile(explicit_path):
-            return explicit_path
-        if os.path.isdir(explicit_path):
-            fp = os.path.join(explicit_path, REGISTRY_FILENAME)
-            if os.path.isfile(fp):
-                return fp
-        print(f"警告: 指定的路径不存在: {explicit_path}")
-        return None
-
-    candidates = [
-        os.path.join("unilabos_data", REGISTRY_FILENAME),
-        REGISTRY_FILENAME,
-    ]
-
-    for c in candidates:
-        if os.path.isfile(c):
-            return c
-
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    workspace_root = os.path.normpath(os.path.join(script_dir, "..", "..", ".."))
-    for c in candidates:
-        path = os.path.join(workspace_root, c)
-        if os.path.isfile(path):
-            return path
-
-    cwd = os.getcwd()
-    for _ in range(5):
-        parent = os.path.dirname(cwd)
-        if parent == cwd:
-            break
-        cwd = parent
-        for c in candidates:
-            path = os.path.join(cwd, c)
-            if os.path.isfile(path):
-                return path
-
-    return None
-
-def load_registry(path):
-    with open(path, 'r', encoding='utf-8') as f:
-        return json.load(f)
-
-def list_devices(data):
-    """列出所有包含 action_value_mappings 的设备，同时返回 module 路径"""
-    resources = data.get('resources', [])
-    devices = []
-    for res in resources:
-        rid = res.get('id', '')
-        cls = res.get('class', {})
-        avm = cls.get('action_value_mappings', {})
-        module = cls.get('module', '')
-        if avm:
-            devices.append((rid, len(avm), module))
-    return devices
-
-def flatten_schema_to_goal(action_data):
-    """将 schema 中嵌套的 goal 内容提升为顶层 schema，去掉 feedback/result 包装"""
-    schema = action_data.get('schema', {})
-    goal_schema = schema.get('properties', {}).get('goal', {})
-    if goal_schema:
-        action_data = dict(action_data)
-        action_data['schema'] = goal_schema
-    return action_data
-
-
-def extract_actions(data, device_id, output_dir):
-    """提取指定设备的 action schema 到独立 JSON 文件"""
-    resources = data.get('resources', [])
-    for res in resources:
-        if res.get('id') == device_id:
-            cls = res.get('class', {})
-            module = cls.get('module', '')
-            avm = cls.get('action_value_mappings', {})
-            if not avm:
-                print(f"设备 {device_id} 没有 action_value_mappings")
-                return []
-
-            if module:
-                py_path = module.split(":")[0].replace(".", "/") + ".py"
-                class_name = module.split(":")[-1] if ":" in module else ""
-                print(f"Python 源码: {py_path}")
-                if class_name:
-                    print(f"设备类: {class_name}")
-
-            os.makedirs(output_dir, exist_ok=True)
-            written = []
-            for action_name in sorted(avm.keys()):
-                action_data = flatten_schema_to_goal(avm[action_name])
-                filename = action_name.replace('-', '_') + '.json'
-                filepath = os.path.join(output_dir, filename)
-                with open(filepath, 'w', encoding='utf-8') as f:
-                    json.dump(action_data, f, indent=2, ensure_ascii=False)
-                written.append(filename)
-                print(f"  {filepath}")
-            return written
-
-    print(f"设备 {device_id} 未找到")
-    return []
-
-def main():
-    args = sys.argv[1:]
-    explicit_registry = None
-
-    if "--registry" in args:
-        idx = args.index("--registry")
-        if idx + 1 < len(args):
-            explicit_registry = args[idx + 1]
-            args = args[:idx] + args[idx + 2:]
-        else:
-            print("错误: --registry 需要指定路径")
-            sys.exit(1)
-
-    registry_path = find_registry(explicit_registry)
-    if not registry_path:
-        print(f"错误: 找不到 {REGISTRY_FILENAME}")
-        print()
-        print("解决方法:")
-        print("  1. 先运行 unilab 启动命令，等待注册表生成")
-        print("  2. 用 --registry 指定文件路径:")
-        print(f"     python {sys.argv[0]} --registry <path/to/{REGISTRY_FILENAME}>")
-        print()
-        print("搜索过的路径:")
-        for p in [
-            os.path.join("unilabos_data", REGISTRY_FILENAME),
-            REGISTRY_FILENAME,
-            os.path.join("<workspace_root>", "unilabos_data", REGISTRY_FILENAME),
-        ]:
-            print(f"  - {p}")
-        sys.exit(1)
-
-    print(f"注册表: {registry_path}")
-    mtime = os.path.getmtime(registry_path)
-    gen_time = datetime.fromtimestamp(mtime).strftime("%Y-%m-%d %H:%M:%S")
-    size_mb = os.path.getsize(registry_path) / (1024 * 1024)
-    print(f"生成时间: {gen_time}  (文件大小: {size_mb:.1f} MB)")
-    data = load_registry(registry_path)
-
-    if len(args) == 0:
-        devices = list_devices(data)
-        print(f"\n找到 {len(devices)} 个设备:")
-        print(f"{'设备 ID':<50} {'Actions':>7}  {'Python 模块'}")
-        print("-" * 120)
-        for did, count, module in sorted(devices, key=lambda x: x[0]):
-            py_path = module.split(":")[0].replace(".", "/") + ".py" if module else ""
-            print(f"{did:<50} {count:>7}  {py_path}")
-
-    elif len(args) == 2:
-        device_id = args[0]
-        output_dir = args[1]
-        print(f"\n提取 {device_id} 的 actions 到 {output_dir}/")
-        written = extract_actions(data, device_id, output_dir)
-        if written:
-            print(f"\n共写入 {len(written)} 个 action 文件")
-
-    else:
-        print("用法:")
-        print("  python extract_device_actions.py [--registry <path>]                # 列出设备")
-        print("  python extract_device_actions.py [--registry <path>] <device_id> <dir>  # 提取 actions")
-        sys.exit(1)
-
-if __name__ == '__main__':
-    main()

.cursor/skills/create-device-skill/scripts/gen_auth.py

@@ -1,69 +0,0 @@
-#!/usr/bin/env python3
-"""
-从 ak/sk 生成 UniLab API Authorization header。
-
-算法: base64(ak:sk) → "Authorization: Lab <token>"
-
-用法:
-  python gen_auth.py <ak> <sk>
-  python gen_auth.py --config <config.py>
-
-示例:
-  python gen_auth.py myak mysk
-  python gen_auth.py --config experiments/config.py
-"""
-import base64
-import re
-import sys
-
-
-def gen_auth(ak: str, sk: str) -> str:
-    token = base64.b64encode(f"{ak}:{sk}".encode("utf-8")).decode("utf-8")
-    return token
-
-
-def extract_from_config(config_path: str) -> tuple:
-    """从 config.py 中提取 ak 和 sk"""
-    with open(config_path, "r", encoding="utf-8") as f:
-        content = f.read()
-    ak_match = re.search(r'''ak\s*=\s*["']([^"']+)["']''', content)
-    sk_match = re.search(r'''sk\s*=\s*["']([^"']+)["']''', content)
-    if not ak_match or not sk_match:
-        return None, None
-    return ak_match.group(1), sk_match.group(1)
-
-
-def main():
-    args = sys.argv[1:]
-
-    if len(args) == 2 and args[0] == "--config":
-        ak, sk = extract_from_config(args[1])
-        if not ak or not sk:
-            print(f"错误: 在 {args[1]} 中未找到 ak/sk 配置")
-            print("期望格式: ak = \"xxx\"  sk = \"xxx\"")
-            sys.exit(1)
-        print(f"配置文件: {args[1]}")
-    elif len(args) == 2:
-        ak, sk = args
-    else:
-        print("用法:")
-        print("  python gen_auth.py <ak> <sk>")
-        print("  python gen_auth.py --config <config.py>")
-        sys.exit(1)
-
-    token = gen_auth(ak, sk)
-    print(f"ak: {ak}")
-    print(f"sk: {sk}")
-    print()
-    print(f"Authorization header:")
-    print(f"  Authorization: Lab {token}")
-    print()
-    print(f"curl 用法:")
-    print(f'  curl -H "Authorization: Lab {token}" ...')
-    print()
-    print(f"Shell 变量:")
-    print(f'  AUTH="Authorization: Lab {token}"')
-
-
-if __name__ == "__main__":
-    main()

.github/workflows/ci-check.yml

@@ -49,7 +49,7 @@ jobs:
           uv pip uninstall enum34 || echo enum34 not installed, skipping
           uv pip install .
 
-      - name: Run check mode (AST registry validation)
+      - name: Run check mode (complete_registry)
         run: |
           call conda activate check-env
           echo Running check mode...

.gitignore

@@ -5,7 +5,6 @@ output/
 unilabos_data/
 pyrightconfig.json
 .cursorignore
-device_package*/
 ## Python
 
 # Byte-compiled / optimized / DLL files

AGENTS.md

@@ -1,87 +0,0 @@
-# AGENTS.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-Also follow the monorepo-level rules in `../AGENTS.md`.
-
-## Build & Development
-
-```bash
-# Install in editable mode (requires mamba env with python 3.11)
-pip install -e .
-uv pip install -r unilabos/utils/requirements.txt
-
-# Run with a device graph
-unilab --graph <graph.json> --config <config.py> --backend ros
-unilab --graph <graph.json> --config <config.py> --backend simple  # no ROS2 needed
-
-# Common CLI flags
-unilab --app_bridges websocket fastapi    # communication bridges
-unilab --test_mode                        # simulate hardware, no real execution
-unilab --check_mode                       # CI validation of registry imports
-unilab --skip_env_check                   # skip auto-install of dependencies
-unilab --visual rviz|web|disable          # visualization mode
-unilab --is_slave                         # run as slave node
-
-# Workflow upload subcommand
-unilab workflow_upload -f <workflow.json> -n <name> --tags tag1 tag2
-
-# Tests
-pytest tests/                              # all tests
-pytest tests/resources/test_resourcetreeset.py  # single test file
-pytest tests/resources/test_resourcetreeset.py::TestClassName::test_method  # single test
-```
-
-## Architecture
-
-### Startup Flow
-
-`unilab` CLI → `unilabos/app/main.py:main()` → loads config → builds registry → reads device graph (JSON/GraphML) → starts backend thread (ROS2/simple) → starts FastAPI web server + WebSocket client.
-
-### Core Layers
-
-**Registry** (`unilabos/registry/`): Singleton `Registry` class discovers and catalogs all device types, resource types, and communication devices from YAML definitions. Device types live in `registry/devices/*.yaml`, resources in `registry/resources/`, comms in `registry/device_comms/`. The registry resolves class paths to actual Python classes via `utils/import_manager.py`.
-
-**Resource Tracking** (`unilabos/resources/resource_tracker.py`): Pydantic-based `ResourceDict` → `ResourceDictInstance` → `ResourceTreeSet` hierarchy. `ResourceTreeSet` is the canonical in-memory representation of all devices and resources, used throughout the system. Graph I/O is in `resources/graphio.py` (reads JSON/GraphML device topology files into `nx.Graph` + `ResourceTreeSet`).
-
-**Device Drivers** (`unilabos/devices/`): 30+ hardware drivers organized by device type (liquid_handling, hplc, balance, arm, etc.). Each driver is a Python class that gets wrapped by `ros/device_node_wrapper.py:ros2_device_node()` to become a ROS2 node with publishers, subscribers, and action servers.
-
-**ROS2 Layer** (`unilabos/ros/`): `device_node_wrapper.py` dynamically wraps any device class into `ROS2DeviceNode` (defined in `ros/nodes/base_device_node.py`). Preset node types in `ros/nodes/presets/` include `host_node`, `controller_node`, `workstation`, `serial_node`, `camera`. Messages use custom `unilabos_msgs` (pre-built, distributed via releases).
-
-**Protocol Compilation** (`unilabos/compile/`): 20+ protocol compilers (add, centrifuge, dissolve, filter, heatchill, stir, pump, etc.) that transform YAML protocol definitions into executable sequences.
-
-**Communication** (`unilabos/device_comms/`): Hardware communication adapters — OPC-UA client, Modbus PLC, RPC, and a universal driver. `app/communication.py` provides a factory pattern for WebSocket client connections to the cloud.
-
-**Web/API** (`unilabos/app/web/`): FastAPI server with REST API (`api.py`), Jinja2 template pages (`pages.py`), and HTTP client for cloud communication (`client.py`). Runs on port 8002 by default.
-
-### Configuration System
-
-- **Config classes** in `unilabos/config/config.py`: `BasicConfig`, `WSConfig`, `HTTPConfig`, `ROSConfig` — all class-level attributes, loaded from Python config files
-- Config files are `.py` files with matching class names (see `config/example_config.py`)
-- Environment variables override with prefix `UNILABOS_` (e.g., `UNILABOS_BASICCONFIG_PORT=9000`)
-- Device topology defined in graph files (JSON with node-link format, or GraphML)
-
-### Key Data Flow
-
-1. Graph file → `graphio.read_node_link_json()` → `(nx.Graph, ResourceTreeSet, resource_links)`
-2. `ResourceTreeSet` + `Registry` → `initialize_device.initialize_device_from_dict()` → `ROS2DeviceNode` instances
-3. Device nodes communicate via ROS2 topics/actions or direct Python calls (simple backend)
-4. Cloud sync via WebSocket (`app/ws_client.py`) and HTTP (`app/web/client.py`)
-
-### Test Data
-
-Example device graphs and experiment configs are in `unilabos/test/experiments/` (not `tests/`). Registry test fixtures in `unilabos/test/registry/`.
-
-## Code Conventions
-
-- Code comments and log messages in simplified Chinese
-- Python 3.11+, type hints expected
-- Pydantic models for data validation (`resource_tracker.py`)
-- Singleton pattern via `@singleton` decorator (`utils/decorator.py`)
-- Dynamic class loading via `utils/import_manager.py` — device classes resolved at runtime from registry YAML paths
-- CLI argument dashes auto-converted to underscores for consistency
-
-## Licensing
-
-- Framework code: GPL-3.0
-- Device drivers (`unilabos/devices/`): DP Technology Proprietary License — do not redistribute

CLAUDE.md

@@ -1,4 +0,0 @@
-
-Please follow the rules defined in:
-
-@AGENTS.md

docs/developer_guide/add_device.md

@@ -15,9 +15,6 @@ Python 类设备驱动在完成注册表后可以直接在 Uni-Lab 中使用，
 **示例：**
 
 ```python
-from unilabos.registry.decorators import device, topic_config
-
-@device(id="mock_gripper", category=["gripper"], description="Mock Gripper")
 class MockGripper:
     def __init__(self):
         self._position: float = 0.0
@@ -26,23 +23,19 @@ class MockGripper:
         self._status = "Idle"
 
     @property
-    @topic_config()  # 添加 @topic_config 才会定时广播
     def position(self) -> float:
         return self._position
 
     @property
-    @topic_config()
     def velocity(self) -> float:
         return self._velocity
 
     @property
-    @topic_config()
     def torque(self) -> float:
         return self._torque
 
-    # 使用 @topic_config 装饰的属性，接入 Uni-Lab 时会定时对外广播
+    # 会被自动识别的设备属性，接入 Uni-Lab 时会定时对外广播
     @property
-    @topic_config(period=2.0)  # 可自定义发布周期
     def status(self) -> str:
         return self._status
 
@@ -156,7 +149,7 @@ my_device: # 设备唯一标识符
 
 系统会自动分析您的 Python 驱动类并生成：
 
-- `status_types`：从 `@topic_config` 装饰的 `@property` 或方法自动识别状态属性
+- `status_types`：从 `@property` 装饰的方法自动识别状态属性
 - `action_value_mappings`：从类方法自动生成动作映射
 - `init_param_schema`：从 `__init__` 方法分析初始化参数
 - `schema`：前端显示用的属性类型定义
@@ -186,9 +179,7 @@ Uni-Lab 设备驱动是一个 Python 类，需要遵循以下结构：
 
 ```python
 from typing import Dict, Any
-from unilabos.registry.decorators import device, topic_config
 
-@device(id="my_device", category=["general"], description="My Device")
 class MyDevice:
     """设备类文档字符串
 
@@ -207,9 +198,8 @@ class MyDevice:
         # 初始化硬件连接
 
     @property
-    @topic_config()  # 必须添加 @topic_config 才会广播
     def status(self) -> str:
-        """设备状态（通过 @topic_config 广播）"""
+        """设备状态（会自动广播）"""
         return self._status
 
     def my_action(self, param: float) -> Dict[str, Any]:
@@ -227,61 +217,34 @@ class MyDevice:
 
 ## 状态属性 vs 动作方法
 
-### 状态属性（@property + @topic_config）
+### 状态属性（@property）
 
-状态属性需要同时使用 `@property` 和 `@topic_config` 装饰器才会被识别并定期广播：
+状态属性会被自动识别并定期广播：
 
 ```python
-from unilabos.registry.decorators import topic_config
-
 @property
-@topic_config()  # 必须添加，否则不会广播
 def temperature(self) -> float:
     """当前温度"""
     return self._read_temperature()
 
 @property
-@topic_config(period=2.0)  # 可自定义发布周期（秒）
 def status(self) -> str:
     """设备状态: idle, running, error"""
     return self._status
 
 @property
-@topic_config(name="ready")  # 可自定义发布名称
 def is_ready(self) -> bool:
     """设备是否就绪"""
     return self._status == "idle"
 ```
 
-也可以使用普通方法（非 @property）配合 `@topic_config`：
-
-```python
-@topic_config(period=10.0)
-def get_sensor_data(self) -> Dict[str, float]:
-    """获取传感器数据（get_ 前缀会自动去除，发布名为 sensor_data）"""
-    return {"temp": self._temp, "humidity": self._humidity}
-```
-
-**`@topic_config` 参数**:
-
-| 参数 | 类型 | 默认值 | 说明 |
-|------|------|--------|------|
-| `period` | float | 5.0 | 发布周期（秒） |
-| `print_publish` | bool | 节点默认 | 是否打印发布日志 |
-| `qos` | int | 10 | QoS 深度 |
-| `name` | str | None | 自定义发布名称 |
-
-**发布名称优先级**：`@topic_config(name=...)` > `get_` 前缀去除 > 方法名
-
 **特点**:
 
-- 必须使用 `@topic_config` 装饰器
-- 支持 `@property` 和普通方法
-- 添加到注册表的 `status_types`
+- 使用`@property`装饰器
+- 只读，不能有参数
+- 自动添加到注册表的`status_types`
 - 定期发布到 ROS2 topic
 
-> **⚠️ 重要：** 仅有 `@property` 装饰器而没有 `@topic_config` 的属性**不会**被广播。这是一个 Breaking Change。
-
 ### 动作方法
 
 动作方法是设备可以执行的操作：
@@ -534,7 +497,6 @@ class LiquidHandler:
         self._status = "idle"
 
     @property
-    @topic_config()
     def status(self) -> str:
         return self._status
 
@@ -924,52 +886,7 @@ class MyDevice:
 
 ## 最佳实践
 
-### 1. 使用 `@device` 装饰器标识设备类
-
-```python
-from unilabos.registry.decorators import device
-
-@device(id="my_device", category=["heating"], description="My Heating Device", icon="heater.webp")
-class MyDevice:
-    ...
-```
-
-- `id`：设备唯一标识符，用于注册表匹配
-- `category`：分类列表，前端用于分组显示
-- `description`：设备描述
-- `icon`：图标文件名（可选）
-
-### 2. 使用 `@topic_config` 声明需要广播的状态
-
-```python
-from unilabos.registry.decorators import topic_config
-
-# ✓ @property + @topic_config → 会广播
-@property
-@topic_config(period=2.0)
-def temperature(self) -> float:
-    return self._temp
-
-# ✓ 普通方法 + @topic_config → 会广播（get_ 前缀自动去除）
-@topic_config(period=10.0)
-def get_sensor_data(self) -> Dict[str, float]:
-    return {"temp": self._temp}
-
-# ✓ 使用 name 参数自定义发布名称
-@property
-@topic_config(name="ready")
-def is_ready(self) -> bool:
-    return self._status == "idle"
-
-# ✗ 仅有 @property，没有 @topic_config → 不会广播
-@property
-def internal_state(self) -> str:
-    return self._state
-```
-
-> **注意：** 与 `@property` 连用时，`@topic_config` 必须放在 `@property` 下面。
-
-### 3. 类型注解
+### 1. 类型注解
 
 ```python
 from typing import Dict, Any, Optional, List
@@ -984,7 +901,7 @@ def method(
     pass
 ```
 
-### 4. 文档字符串
+### 2. 文档字符串
 
 ```python
 def method(self, param: float) -> Dict[str, Any]:
@@ -1006,7 +923,7 @@ def method(self, param: float) -> Dict[str, Any]:
     pass
 ```
 
-### 5. 配置验证
+### 3. 配置验证
 
 ```python
 def __init__(self, config: Dict[str, Any]):
@@ -1020,7 +937,7 @@ def __init__(self, config: Dict[str, Any]):
     self.baudrate = config['baudrate']
 ```
 
-### 6. 资源清理
+### 4. 资源清理
 
 ```python
 def __del__(self):
@@ -1029,7 +946,7 @@ def __del__(self):
         self.connection.close()
 ```
 
-### 7. 设计前端友好的返回值
+### 5. 设计前端友好的返回值
 
 **记住：返回值会直接显示在 Web 界面**
 

docs/developer_guide/add_registry.md

@@ -422,20 +422,18 @@ placeholder_keys:
 
 ### status_types
 
-系统会扫描你的 Python 类，从带有 `@topic_config` 装饰器的 `@property` 或方法自动生成这部分：
+系统会扫描你的 Python 类，从状态方法（property 或 get\_方法）自动生成这部分：
 
 ```yaml
 status_types:
-  current_temperature: float # 从 @topic_config 装饰的 @property 或方法
-  is_heating: bool
-  status: str
+  current_temperature: float # 从 get_current_temperature() 或 @property current_temperature
+  is_heating: bool # 从 get_is_heating() 或 @property is_heating
+  status: str # 从 get_status() 或 @property status
 ```
 
 **注意事项**：
 
-- 仅有带 `@topic_config` 装饰器的 `@property` 或方法才会被识别为状态属性
-- 没有 `@topic_config` 的 `@property` 不会生成 status_types，也不会广播
-- `get_` 前缀的方法名会自动去除前缀（如 `get_temperature` → `temperature`）
+- 系统会查找所有 `get_` 开头的方法和 `@property` 装饰的属性
 - 类型会自动转成相应的类型（如 `str`、`float`、`bool`）
 - 如果类型是 `Any`、`None` 或未知的，默认使用 `String`
 
@@ -539,13 +537,11 @@ class AdvancedLiquidHandler:
         self._temperature = 25.0
 
     @property
-    @topic_config()
     def status(self) -> str:
         """设备状态"""
         return self._status
 
     @property
-    @topic_config()
     def temperature(self) -> float:
         """当前温度"""
         return self._temperature
@@ -813,23 +809,21 @@ my_temperature_controller:
 你的设备类需要符合以下要求：
 
 ```python
-from unilabos.registry.decorators import device, topic_config
+from unilabos.common.device_base import DeviceBase
 
-@device(id="my_device", category=["temperature"], description="My Device")
-class MyDevice:
+class MyDevice(DeviceBase):
     def __init__(self, config):
         """初始化，参数会自动分析到 init_param_schema.config"""
+        super().__init__(config)
         self.port = config.get('port', '/dev/ttyUSB0')
 
-    # 状态方法（必须添加 @topic_config 才会生成到 status_types 并广播）
+    # 状态方法（会自动生成到 status_types）
     @property
-    @topic_config()
     def status(self):
         """返回设备状态"""
         return "idle"
 
     @property
-    @topic_config()
     def temperature(self):
         """返回当前温度"""
         return 25.0
@@ -1045,34 +1039,7 @@ resource.type      # "resource"
 
 ### 代码规范
 
-1. **使用 `@device` 装饰器标识设备类**
-
-```python
-from unilabos.registry.decorators import device
-
-@device(id="my_device", category=["heating"], description="My Device")
-class MyDevice:
-    ...
-```
-
-2. **使用 `@topic_config` 声明广播属性**
-
-```python
-from unilabos.registry.decorators import topic_config
-
-# ✓ 需要广播的状态属性
-@property
-@topic_config(period=2.0)
-def temperature(self) -> float:
-    return self._temp
-
-# ✗ 仅有 @property 不会广播
-@property
-def internal_counter(self) -> int:
-    return self._counter
-```
-
-3. **始终使用类型注解**
+1. **始终使用类型注解**
 
 ```python
 # ✓ 好
@@ -1084,7 +1051,7 @@ def method(self, resource, device):
     pass
 ```
 
-4. **提供有意义的参数名**
+2. **提供有意义的参数名**
 
 ```python
 # ✓ 好 - 清晰的参数名
@@ -1096,7 +1063,7 @@ def transfer(self, r1: ResourceSlot, r2: ResourceSlot):
     pass
 ```
 
-5. **使用 Optional 表示可选参数**
+3. **使用 Optional 表示可选参数**
 
 ```python
 from typing import Optional
@@ -1109,7 +1076,7 @@ def method(
     pass
 ```
 
-6. **添加详细的文档字符串**
+4. **添加详细的文档字符串**
 
 ```python
 def method(
@@ -1129,13 +1096,13 @@ def method(
     pass
 ```
 
-7. **方法命名规范**
+5. **方法命名规范**
 
-   - 状态方法使用 `@property` + `@topic_config` 装饰器，或普通方法 + `@topic_config`
+   - 状态方法使用 `@property` 装饰器或 `get_` 前缀
    - 动作方法使用动词开头
    - 保持命名清晰、一致
 
-8. **完善的错误处理**
+6. **完善的错误处理**
    - 实现完善的错误处理
    - 添加日志记录
    - 提供有意义的错误信息

docs/developer_guide/networking_overview.md

@@ -221,10 +221,10 @@ Laboratory A    Laboratory B
 
 ```bash
 # 实验室A
-unilab --ak your_ak --sk your_sk --upload_registry
+unilab --ak your_ak --sk your_sk --upload_registry --use_remote_resource
 
 # 实验室B
-unilab --ak your_ak --sk your_sk --upload_registry
+unilab --ak your_ak --sk your_sk --upload_registry --use_remote_resource
 ```
 
 ---

docs/user_guide/launch.md

@@ -22,6 +22,7 @@ options:
   --is_slave            Run the backend as slave node (without host privileges).
   --slave_no_host       Skip waiting for host service in slave mode
   --upload_registry     Upload registry information when starting unilab
+  --use_remote_resource Use remote resources when starting unilab
   --config CONFIG       Configuration file path, supports .py format Python config files
   --port PORT           Port for web service information page
   --disable_browser     Disable opening information page on startup
@@ -84,7 +85,7 @@ Uni-Lab 的启动过程分为以下几个阶段：
 支持两种方式：
 
 - **本地文件**：使用 `-g` 指定图谱文件（支持 JSON 和 GraphML 格式）
-- **远程资源**：不指定本地文件即可
+- **远程资源**：使用 `--use_remote_resource` 从云端获取
 
 ### 7. 注册表构建
 
@@ -195,7 +196,7 @@ unilab --config path/to/your/config.py
 unilab --ak your_ak --sk your_sk -g path/to/graph.json --upload_registry
 
 # 使用远程资源启动
-unilab --ak your_ak --sk your_sk
+unilab --ak your_ak --sk your_sk --use_remote_resource
 
 # 更新注册表
 unilab --ak your_ak --sk your_sk --complete_registry

recipes/msgs/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: ros-humble-unilabos-msgs
-  version: 0.10.19
+  version: 0.10.18
 source:
   path: ../../unilabos_msgs
   target_directory: src

recipes/unilabos/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: unilabos
-  version: "0.10.19"
+  version: "0.10.18"
 
 source:
   path: ../..

scripts/workflow.py

@@ -2,7 +2,6 @@ import json
 import logging
 import traceback
 import uuid
-import xml.etree.ElementTree as ET
 from typing import Any, Dict, List
 
 import networkx as nx
@@ -25,7 +24,15 @@ class SimpleGraph:
 
     def add_edge(self, source, target, **attrs):
         """添加边"""
-        edge = {"source": source, "target": target, **attrs}
+        # edge = {"source": source, "target": target, **attrs}
+        edge = {
+            "source": source, "target": target,
+            "source_node_uuid": source,
+            "target_node_uuid": target,
+            "source_handle_io": "source",
+            "target_handle_io": "target",
+            **attrs
+        }
         self.edges.append(edge)
 
     def to_dict(self):
@@ -42,6 +49,7 @@ class SimpleGraph:
             "multigraph": False,
             "graph": {},
             "nodes": nodes_list,
+            "edges": self.edges,
             "links": self.edges,
         }
 
@@ -58,495 +66,8 @@ def extract_json_from_markdown(text: str) -> str:
     return text
 
 
-def convert_to_type(val: str) -> Any:
-    """将字符串值转换为适当的数据类型"""
-    if val == "True":
-        return True
-    if val == "False":
-        return False
-    if val == "?":
-        return None
-    if val.endswith(" g"):
-        return float(val.split(" ")[0])
-    if val.endswith("mg"):
-        return float(val.split("mg")[0])
-    elif val.endswith("mmol"):
-        return float(val.split("mmol")[0]) / 1000
-    elif val.endswith("mol"):
-        return float(val.split("mol")[0])
-    elif val.endswith("ml"):
-        return float(val.split("ml")[0])
-    elif val.endswith("RPM"):
-        return float(val.split("RPM")[0])
-    elif val.endswith(" °C"):
-        return float(val.split(" ")[0])
-    elif val.endswith(" %"):
-        return float(val.split(" ")[0])
-    return val
 
 
-def refactor_data(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    """统一的数据重构函数，根据操作类型自动选择模板"""
-    refactored_data = []
-
-    # 定义操作映射，包含生物实验和有机化学的所有操作
-    OPERATION_MAPPING = {
-        # 生物实验操作
-        "transfer_liquid": "SynBioFactory-liquid_handler.prcxi-transfer_liquid",
-        "transfer": "SynBioFactory-liquid_handler.biomek-transfer",
-        "incubation": "SynBioFactory-liquid_handler.biomek-incubation",
-        "move_labware": "SynBioFactory-liquid_handler.biomek-move_labware",
-        "oscillation": "SynBioFactory-liquid_handler.biomek-oscillation",
-        # 有机化学操作
-        "HeatChillToTemp": "SynBioFactory-workstation-HeatChillProtocol",
-        "StopHeatChill": "SynBioFactory-workstation-HeatChillStopProtocol",
-        "StartHeatChill": "SynBioFactory-workstation-HeatChillStartProtocol",
-        "HeatChill": "SynBioFactory-workstation-HeatChillProtocol",
-        "Dissolve": "SynBioFactory-workstation-DissolveProtocol",
-        "Transfer": "SynBioFactory-workstation-TransferProtocol",
-        "Evaporate": "SynBioFactory-workstation-EvaporateProtocol",
-        "Recrystallize": "SynBioFactory-workstation-RecrystallizeProtocol",
-        "Filter": "SynBioFactory-workstation-FilterProtocol",
-        "Dry": "SynBioFactory-workstation-DryProtocol",
-        "Add": "SynBioFactory-workstation-AddProtocol",
-    }
-
-    UNSUPPORTED_OPERATIONS = ["Purge", "Wait", "Stir", "ResetHandling"]
-
-    for step in data:
-        operation = step.get("action")
-        if not operation or operation in UNSUPPORTED_OPERATIONS:
-            continue
-
-        # 处理重复操作
-        if operation == "Repeat":
-            times = step.get("times", step.get("parameters", {}).get("times", 1))
-            sub_steps = step.get("steps", step.get("parameters", {}).get("steps", []))
-            for i in range(int(times)):
-                sub_data = refactor_data(sub_steps)
-                refactored_data.extend(sub_data)
-            continue
-
-        # 获取模板名称
-        template = OPERATION_MAPPING.get(operation)
-        if not template:
-            # 自动推断模板类型
-            if operation.lower() in ["transfer", "incubation", "move_labware", "oscillation"]:
-                template = f"SynBioFactory-liquid_handler.biomek-{operation}"
-            else:
-                template = f"SynBioFactory-workstation-{operation}Protocol"
-
-        # 创建步骤数据
-        step_data = {
-            "template": template,
-            "description": step.get("description", step.get("purpose", f"{operation} operation")),
-            "lab_node_type": "Device",
-            "parameters": step.get("parameters", step.get("action_args", {})),
-        }
-        refactored_data.append(step_data)
-
-    return refactored_data
-
-
-def build_protocol_graph(
-    labware_info: List[Dict[str, Any]], protocol_steps: List[Dict[str, Any]], workstation_name: str
-) -> SimpleGraph:
-    """统一的协议图构建函数，根据设备类型自动选择构建逻辑"""
-    G = SimpleGraph()
-    resource_last_writer = {}
-    LAB_NAME = "SynBioFactory"
-
-    protocol_steps = refactor_data(protocol_steps)
-
-    # 检查协议步骤中的模板来判断协议类型
-    has_biomek_template = any(
-        ("biomek" in step.get("template", "")) or ("prcxi" in step.get("template", ""))
-        for step in protocol_steps
-    )
-
-    if has_biomek_template:
-        # 生物实验协议图构建
-        for labware_id, labware in labware_info.items():
-            node_id = str(uuid.uuid4())
-
-            labware_attrs = labware.copy()
-            labware_id = labware_attrs.pop("id", labware_attrs.get("name", f"labware_{uuid.uuid4()}"))
-            labware_attrs["description"] = labware_id
-            labware_attrs["lab_node_type"] = (
-                "Reagent" if "Plate" in str(labware_id) else "Labware" if "Rack" in str(labware_id) else "Sample"
-            )
-            labware_attrs["device_id"] = workstation_name
-
-            G.add_node(node_id, template=f"{LAB_NAME}-host_node-create_resource", **labware_attrs)
-            resource_last_writer[labware_id] = f"{node_id}:labware"
-
-        # 处理协议步骤
-        prev_node = None
-        for i, step in enumerate(protocol_steps):
-            node_id = str(uuid.uuid4())
-            G.add_node(node_id, **step)
-
-            # 添加控制流边
-            if prev_node is not None:
-                G.add_edge(prev_node, node_id, source_port="ready", target_port="ready")
-            prev_node = node_id
-
-            # 处理物料流
-            params = step.get("parameters", {})
-            if "sources" in params and params["sources"] in resource_last_writer:
-                source_node, source_port = resource_last_writer[params["sources"]].split(":")
-                G.add_edge(source_node, node_id, source_port=source_port, target_port="labware")
-
-            if "targets" in params:
-                resource_last_writer[params["targets"]] = f"{node_id}:labware"
-
-        # 添加协议结束节点
-        end_id = str(uuid.uuid4())
-        G.add_node(end_id, template=f"{LAB_NAME}-liquid_handler.biomek-run_protocol")
-        if prev_node is not None:
-            G.add_edge(prev_node, end_id, source_port="ready", target_port="ready")
-
-    else:
-        # 有机化学协议图构建
-        WORKSTATION_ID = workstation_name
-
-        # 为所有labware创建资源节点
-        for item_id, item in labware_info.items():
-            # item_id = item.get("id") or item.get("name", f"item_{uuid.uuid4()}")
-            node_id = str(uuid.uuid4())
-
-            # 判断节点类型
-            if item.get("type") == "hardware" or "reactor" in str(item_id).lower():
-                if "reactor" not in str(item_id).lower():
-                    continue
-                lab_node_type = "Sample"
-                description = f"Prepare Reactor: {item_id}"
-                liquid_type = []
-                liquid_volume = []
-            else:
-                lab_node_type = "Reagent"
-                description = f"Add Reagent to Flask: {item_id}"
-                liquid_type = [item_id]
-                liquid_volume = [1e5]
-
-            G.add_node(
-                node_id,
-                template=f"{LAB_NAME}-host_node-create_resource",
-                description=description,
-                lab_node_type=lab_node_type,
-                res_id=item_id,
-                device_id=WORKSTATION_ID,
-                class_name="container",
-                parent=WORKSTATION_ID,
-                bind_locations={"x": 0.0, "y": 0.0, "z": 0.0},
-                liquid_input_slot=[-1],
-                liquid_type=liquid_type,
-                liquid_volume=liquid_volume,
-                slot_on_deck="",
-                role=item.get("role", ""),
-            )
-            resource_last_writer[item_id] = f"{node_id}:labware"
-
-        last_control_node_id = None
-
-        # 处理协议步骤
-        for step in protocol_steps:
-            node_id = str(uuid.uuid4())
-            G.add_node(node_id, **step)
-
-            # 控制流
-            if last_control_node_id is not None:
-                G.add_edge(last_control_node_id, node_id, source_port="ready", target_port="ready")
-            last_control_node_id = node_id
-
-            # 物料流
-            params = step.get("parameters", {})
-            input_resources = {
-                "Vessel": params.get("vessel"),
-                "ToVessel": params.get("to_vessel"),
-                "FromVessel": params.get("from_vessel"),
-                "reagent": params.get("reagent"),
-                "solvent": params.get("solvent"),
-                "compound": params.get("compound"),
-                "sources": params.get("sources"),
-                "targets": params.get("targets"),
-            }
-
-            for target_port, resource_name in input_resources.items():
-                if resource_name and resource_name in resource_last_writer:
-                    source_node, source_port = resource_last_writer[resource_name].split(":")
-                    G.add_edge(source_node, node_id, source_port=source_port, target_port=target_port)
-
-            output_resources = {
-                "VesselOut": params.get("vessel"),
-                "FromVesselOut": params.get("from_vessel"),
-                "ToVesselOut": params.get("to_vessel"),
-                "FiltrateOut": params.get("filtrate_vessel"),
-                "reagent": params.get("reagent"),
-                "solvent": params.get("solvent"),
-                "compound": params.get("compound"),
-                "sources_out": params.get("sources"),
-                "targets_out": params.get("targets"),
-            }
-
-            for source_port, resource_name in output_resources.items():
-                if resource_name:
-                    resource_last_writer[resource_name] = f"{node_id}:{source_port}"
-
-    return G
-
-
-def draw_protocol_graph(protocol_graph: SimpleGraph, output_path: str):
-    """
-    (辅助功能) 使用 networkx 和 matplotlib 绘制协议工作流图，用于可视化。
-    """
-    if not protocol_graph:
-        print("Cannot draw graph: Graph object is empty.")
-        return
-
-    G = nx.DiGraph()
-
-    for node_id, attrs in protocol_graph.nodes.items():
-        label = attrs.get("description", attrs.get("template", node_id[:8]))
-        G.add_node(node_id, label=label, **attrs)
-
-    for edge in protocol_graph.edges:
-        G.add_edge(edge["source"], edge["target"])
-
-    plt.figure(figsize=(20, 15))
-    try:
-        pos = nx.nx_agraph.graphviz_layout(G, prog="dot")
-    except Exception:
-        pos = nx.shell_layout(G)  # Fallback layout
-
-    node_labels = {node: data["label"] for node, data in G.nodes(data=True)}
-    nx.draw(
-        G,
-        pos,
-        with_labels=False,
-        node_size=2500,
-        node_color="skyblue",
-        node_shape="o",
-        edge_color="gray",
-        width=1.5,
-        arrowsize=15,
-    )
-    nx.draw_networkx_labels(G, pos, labels=node_labels, font_size=8, font_weight="bold")
-
-    plt.title("Chemical Protocol Workflow Graph", size=15)
-    plt.savefig(output_path, dpi=300, bbox_inches="tight")
-    plt.close()
-    print(f"  - Visualization saved to '{output_path}'")
-
-
-from networkx.drawing.nx_agraph import to_agraph
-import re
-
-COMPASS = {"n","e","s","w","ne","nw","se","sw","c"}
-
-def _is_compass(port: str) -> bool:
-    return isinstance(port, str) and port.lower() in COMPASS
-
-def draw_protocol_graph_with_ports(protocol_graph, output_path: str, rankdir: str = "LR"):
-    """
-    使用 Graphviz 端口语法绘制协议工作流图。
-    - 若边上的 source_port/target_port 是 compass（n/e/s/w/...），直接用 compass。
-    - 否则自动为节点创建 record 形状并定义命名端口 <portname>。
-    最终由 PyGraphviz 渲染并输出到 output_path（后缀决定格式，如 .png/.svg/.pdf）。
-    """
-    if not protocol_graph:
-        print("Cannot draw graph: Graph object is empty.")
-        return
-
-    # 1) 先用 networkx 搭建有向图，保留端口属性
-    G = nx.DiGraph()
-    for node_id, attrs in protocol_graph.nodes.items():
-        label = attrs.get("description", attrs.get("template", node_id[:8]))
-        # 保留一个干净的“中心标签”，用于放在 record 的中间槽
-        G.add_node(node_id, _core_label=str(label), **{k:v for k,v in attrs.items() if k not in ("label",)})
-
-    edges_data = []
-    in_ports_by_node  = {}  # 收集命名输入端口
-    out_ports_by_node = {}  # 收集命名输出端口
-
-    for edge in protocol_graph.edges:
-        u = edge["source"]
-        v = edge["target"]
-        sp = edge.get("source_port")
-        tp = edge.get("target_port")
-
-        # 记录到图里（保留原始端口信息）
-        G.add_edge(u, v, source_port=sp, target_port=tp)
-        edges_data.append((u, v, sp, tp))
-
-        # 如果不是 compass，就按“命名端口”先归类，等会儿给节点造 record
-        if sp and not _is_compass(sp):
-            out_ports_by_node.setdefault(u, set()).add(str(sp))
-        if tp and not _is_compass(tp):
-            in_ports_by_node.setdefault(v, set()).add(str(tp))
-
-    # 2) 转为 AGraph，使用 Graphviz 渲染
-    A = to_agraph(G)
-    A.graph_attr.update(rankdir=rankdir, splines="true", concentrate="false", fontsize="10")
-    A.node_attr.update(shape="box", style="rounded,filled", fillcolor="lightyellow", color="#999999", fontname="Helvetica")
-    A.edge_attr.update(arrowsize="0.8", color="#666666")
-
-    # 3) 为需要命名端口的节点设置 record 形状与 label
-    #    左列 = 输入端口；中间 = 核心标签；右列 = 输出端口
-    for n in A.nodes():
-        node = A.get_node(n)
-        core = G.nodes[n].get("_core_label", n)
-
-        in_ports  = sorted(in_ports_by_node.get(n, []))
-        out_ports = sorted(out_ports_by_node.get(n, []))
-
-        # 如果该节点涉及命名端口，则用 record；否则保留原 box
-        if in_ports or out_ports:
-            def port_fields(ports):
-                if not ports:
-                    return " "  # 必须留一个空槽占位
-                # 每个端口一个小格子，<p> name
-                return "|".join(f"<{re.sub(r'[^A-Za-z0-9_:.|-]', '_', p)}> {p}" for p in ports)
-
-            left  = port_fields(in_ports)
-            right = port_fields(out_ports)
-
-            # 三栏：左(入) | 中(节点名) | 右(出)
-            record_label = f"{{ {left} | {core} | {right} }}"
-            node.attr.update(shape="record", label=record_label)
-        else:
-            # 没有命名端口：普通盒子，显示核心标签
-            node.attr.update(label=str(core))
-
-    # 4) 给边设置 headport / tailport
-    #    - 若端口为 compass：直接用 compass（e.g., headport="e"）
-    #    - 若端口为命名端口：使用在 record 中定义的 <port> 名（同名即可）
-    for (u, v, sp, tp) in edges_data:
-        e = A.get_edge(u, v)
-
-        # Graphviz 属性：tail 是源，head 是目标
-        if sp:
-            if _is_compass(sp):
-                e.attr["tailport"] = sp.lower()
-            else:
-                # 与 record label 中 <port> 名一致；特殊字符已在 label 中做了清洗
-                e.attr["tailport"] = re.sub(r'[^A-Za-z0-9_:.|-]', '_', str(sp))
-
-        if tp:
-            if _is_compass(tp):
-                e.attr["headport"] = tp.lower()
-            else:
-                e.attr["headport"] = re.sub(r'[^A-Za-z0-9_:.|-]', '_', str(tp))
-
-        # 可选：若想让边更贴边缘，可设置 constraint/spline 等
-        # e.attr["arrowhead"] = "vee"
-
-    # 5) 输出
-    A.draw(output_path, prog="dot")
-    print(f"  - Port-aware workflow rendered to '{output_path}'")
-
-
-def flatten_xdl_procedure(procedure_elem: ET.Element) -> List[ET.Element]:
-    """展平嵌套的XDL程序结构"""
-    flattened_operations = []
-    TEMP_UNSUPPORTED_PROTOCOL = ["Purge", "Wait", "Stir", "ResetHandling"]
-
-    def extract_operations(element: ET.Element):
-        if element.tag not in ["Prep", "Reaction", "Workup", "Purification", "Procedure"]:
-            if element.tag not in TEMP_UNSUPPORTED_PROTOCOL:
-                flattened_operations.append(element)
-
-        for child in element:
-            extract_operations(child)
-
-    for child in procedure_elem:
-        extract_operations(child)
-
-    return flattened_operations
-
-
-def parse_xdl_content(xdl_content: str) -> tuple:
-    """解析XDL内容"""
-    try:
-        xdl_content_cleaned = "".join(c for c in xdl_content if c.isprintable())
-        root = ET.fromstring(xdl_content_cleaned)
-
-        synthesis_elem = root.find("Synthesis")
-        if synthesis_elem is None:
-            return None, None, None
-
-        # 解析硬件组件
-        hardware_elem = synthesis_elem.find("Hardware")
-        hardware = []
-        if hardware_elem is not None:
-            hardware = [{"id": c.get("id"), "type": c.get("type")} for c in hardware_elem.findall("Component")]
-
-        # 解析试剂
-        reagents_elem = synthesis_elem.find("Reagents")
-        reagents = []
-        if reagents_elem is not None:
-            reagents = [{"name": r.get("name"), "role": r.get("role", "")} for r in reagents_elem.findall("Reagent")]
-
-        # 解析程序
-        procedure_elem = synthesis_elem.find("Procedure")
-        if procedure_elem is None:
-            return None, None, None
-
-        flattened_operations = flatten_xdl_procedure(procedure_elem)
-        return hardware, reagents, flattened_operations
-
-    except ET.ParseError as e:
-        raise ValueError(f"Invalid XDL format: {e}")
-
-
-def convert_xdl_to_dict(xdl_content: str) -> Dict[str, Any]:
-    """
-    将XDL XML格式转换为标准的字典格式
-
-    Args:
-        xdl_content: XDL XML内容
-
-    Returns:
-        转换结果，包含步骤和器材信息
-    """
-    try:
-        hardware, reagents, flattened_operations = parse_xdl_content(xdl_content)
-        if hardware is None:
-            return {"error": "Failed to parse XDL content", "success": False}
-
-        # 将XDL元素转换为字典格式
-        steps_data = []
-        for elem in flattened_operations:
-            # 转换参数类型
-            parameters = {}
-            for key, val in elem.attrib.items():
-                converted_val = convert_to_type(val)
-                if converted_val is not None:
-                    parameters[key] = converted_val
-
-            step_dict = {
-                "operation": elem.tag,
-                "parameters": parameters,
-                "description": elem.get("purpose", f"Operation: {elem.tag}"),
-            }
-            steps_data.append(step_dict)
-
-        # 合并硬件和试剂为统一的labware_info格式
-        labware_data = []
-        labware_data.extend({"id": hw["id"], "type": "hardware", **hw} for hw in hardware)
-        labware_data.extend({"name": reagent["name"], "type": "reagent", **reagent} for reagent in reagents)
-
-        return {
-            "success": True,
-            "steps": steps_data,
-            "labware": labware_data,
-            "message": f"Successfully converted XDL to dict format. Found {len(steps_data)} steps and {len(labware_data)} labware items.",
-        }
-
-    except Exception as e:
-        error_msg = f"XDL conversion failed: {str(e)}"
-        logger.error(error_msg)
-        return {"error": error_msg, "success": False}
 
 
 def create_workflow(

setup.py

@@ -4,7 +4,7 @@ package_name = 'unilabos'
 
 setup(
     name=package_name,
-    version='0.10.19',
+    version='0.10.18',
     packages=find_packages(),
     include_package_data=True,
     install_requires=['setuptools'],

unilabos/__init__.py

@@ -1 +1 @@
-__version__ = "0.10.19"
+__version__ = "0.10.18"

unilabos/app/main.py

@@ -1,10 +1,8 @@
 import argparse
 import asyncio
 import os
-import platform
 import shutil
 import signal
-import subprocess
 import sys
 import threading
 import time
@@ -26,84 +24,6 @@ from unilabos.config.config import load_config, BasicConfig, HTTPConfig
 _restart_requested: bool = False
 _restart_reason: str = ""
 
-RESTART_EXIT_CODE = 42
-
-
-def _build_child_argv():
-    """Build sys.argv for child process, stripping supervisor-only arguments."""
-    result = []
-    skip_next = False
-    for arg in sys.argv:
-        if skip_next:
-            skip_next = False
-            continue
-        if arg in ("--restart_mode", "--restart-mode"):
-            continue
-        if arg in ("--auto_restart_count", "--auto-restart-count"):
-            skip_next = True
-            continue
-        if arg.startswith("--auto_restart_count=") or arg.startswith("--auto-restart-count="):
-            continue
-        result.append(arg)
-    return result
-
-
-def _run_as_supervisor(max_restarts: int):
-    """
-    Supervisor process that spawns and monitors child processes.
-
-    Similar to Uvicorn's --reload: the supervisor itself does no heavy work,
-    it only launches the real process as a child and restarts it when the child
-    exits with RESTART_EXIT_CODE.
-    """
-    child_argv = [sys.executable] + _build_child_argv()
-    restart_count = 0
-
-    print_status(
-        f"[Supervisor] Restart mode enabled (max restarts: {max_restarts}), "
-        f"child command: {' '.join(child_argv)}",
-        "info",
-    )
-
-    while True:
-        print_status(
-            f"[Supervisor] Launching process (restart {restart_count}/{max_restarts})...",
-            "info",
-        )
-
-        try:
-            process = subprocess.Popen(child_argv)
-            exit_code = process.wait()
-        except KeyboardInterrupt:
-            print_status("[Supervisor] Interrupted, terminating child process...", "info")
-            process.terminate()
-            try:
-                process.wait(timeout=10)
-            except subprocess.TimeoutExpired:
-                process.kill()
-                process.wait()
-            sys.exit(1)
-
-        if exit_code == RESTART_EXIT_CODE:
-            restart_count += 1
-            if restart_count > max_restarts:
-                print_status(
-                    f"[Supervisor] Maximum restart count ({max_restarts}) reached, exiting",
-                    "warning",
-                )
-                sys.exit(1)
-            print_status(
-                f"[Supervisor] Child requested restart ({restart_count}/{max_restarts}), restarting in 2s...",
-                "info",
-            )
-            time.sleep(2)
-        else:
-            if exit_code != 0:
-                print_status(f"[Supervisor] Child exited with code {exit_code}", "warning")
-            else:
-                print_status("[Supervisor] Child exited normally", "info")
-            sys.exit(exit_code)
-
 
 def load_config_from_file(config_path):
     if config_path is None:
@@ -145,13 +65,6 @@ def parse_args():
         action="append",
         help="Path to the registry directory",
     )
-    parser.add_argument(
-        "--devices",
-        type=str,
-        default=None,
-        action="append",
-        help="Path to Python code directory for AST-based device/resource scanning",
-    )
     parser.add_argument(
         "--working_dir",
         type=str,
@@ -241,18 +154,18 @@ def parse_args():
         action="store_true",
         help="Skip environment dependency check on startup",
     )
+    parser.add_argument(
+        "--complete_registry",
+        action="store_true",
+        default=False,
+        help="Complete registry information",
+    )
     parser.add_argument(
         "--check_mode",
         action="store_true",
         default=False,
         help="Run in check mode for CI: validates registry imports and ensures no file changes",
     )
-    parser.add_argument(
-        "--complete_registry",
-        action="store_true",
-        default=False,
-        help="Complete and rewrite YAML registry files using AST analysis results",
-    )
     parser.add_argument(
         "--no_update_feedback",
         action="store_true",
@@ -264,24 +177,6 @@ def parse_args():
         default=False,
         help="Test mode: all actions simulate execution and return mock results without running real hardware",
     )
-    parser.add_argument(
-        "--extra_resource",
-        action="store_true",
-        default=False,
-        help="Load extra lab_ prefixed labware resources (529 auto-generated definitions from lab_resources.py)",
-    )
-    parser.add_argument(
-        "--restart_mode",
-        action="store_true",
-        default=False,
-        help="Enable supervisor mode: automatically restart the process when triggered via WebSocket",
-    )
-    parser.add_argument(
-        "--auto_restart_count",
-        type=int,
-        default=500,
-        help="Maximum number of automatic restarts in restart mode (default: 500)",
-    )
     # workflow upload subcommand
     workflow_parser = subparsers.add_parser(
         "workflow_upload",
@@ -332,11 +227,6 @@ def main():
     args = parser.parse_args()
     args_dict = vars(args)
 
-    # Supervisor mode: spawn child processes and monitor for restart
-    if args_dict.get("restart_mode", False):
-        _run_as_supervisor(args_dict.get("auto_restart_count", 5))
-        return
-
     # 环境检查 - 检查并自动安装必需的包 (可选)
     skip_env_check = args_dict.get("skip_env_check", False)
     check_mode = args_dict.get("check_mode", False)
@@ -467,11 +357,8 @@ def main():
     BasicConfig.test_mode = args_dict.get("test_mode", False)
     if BasicConfig.test_mode:
         print_status("启用测试模式：所有动作将模拟执行，不调用真实硬件", "warning")
-    BasicConfig.extra_resource = args_dict.get("extra_resource", False)
-    if BasicConfig.extra_resource:
-        print_status("启用额外资源加载：将加载lab_开头的labware资源定义", "info")
     BasicConfig.communication_protocol = "websocket"
-    machine_name = platform.node()
+    machine_name = os.popen("hostname").read().strip()
     machine_name = "".join([c if c.isalnum() or c == "_" else "_" for c in machine_name])
     BasicConfig.machine_name = machine_name
     BasicConfig.vis_2d_enable = args_dict["2d_vis"]
@@ -494,32 +381,22 @@ def main():
     # 显示启动横幅
     print_unilab_banner(args_dict)
 
-    # Step 0: AST 分析优先 + YAML 注册表加载
-    # check_mode 和 upload_registry 都会执行实际 import 验证
-    devices_dirs = args_dict.get("devices", None)
+    # 注册表 - check_mode 时强制启用 complete_registry
     complete_registry = args_dict.get("complete_registry", False) or check_mode
-    lab_registry = build_registry(
-        registry_paths=args_dict["registry_path"],
-        devices_dirs=devices_dirs,
-        upload_registry=BasicConfig.upload_registry,
-        check_mode=check_mode,
-        complete_registry=complete_registry,
-    )
+    lab_registry = build_registry(args_dict["registry_path"], complete_registry, BasicConfig.upload_registry)
 
-    # Check mode: 注册表验证完成后直接退出
+    # Check mode: complete_registry 完成后直接退出，git diff 检测由 CI workflow 执行
     if check_mode:
-        device_count = len(lab_registry.device_type_registry)
-        resource_count = len(lab_registry.resource_type_registry)
-        print_status(f"Check mode: 注册表验证完成 ({device_count} 设备, {resource_count} 资源)，退出", "info")
+        print_status("Check mode: complete_registry 完成，退出", "info")
         os._exit(0)
 
-    # Step 1: 上传全部注册表到服务端，同步保存到 unilabos_data
     if BasicConfig.upload_registry:
+        # 设备注册到服务端 - 需要 ak 和 sk
         if BasicConfig.ak and BasicConfig.sk:
-            # print_status("开始注册设备到服务端...", "info")
+            print_status("开始注册设备到服务端...", "info")
             try:
                 register_devices_and_resources(lab_registry)
-                # print_status("设备注册完成", "info")
+                print_status("设备注册完成", "info")
             except Exception as e:
                 print_status(f"设备注册失败: {e}", "error")
         else:
@@ -604,7 +481,7 @@ def main():
             continue
 
     # 如果从远端获取了物料信息，则与本地物料进行同步
-    if file_path is not None and request_startup_json and "nodes" in request_startup_json:
+    if request_startup_json and "nodes" in request_startup_json:
         print_status("开始同步远端物料到本地...", "info")
         remote_tree_set = ResourceTreeSet.from_raw_dict_list(request_startup_json["nodes"])
         resource_tree_set.merge_remote_resources(remote_tree_set)
@@ -701,10 +578,6 @@ def main():
             open_browser=not args_dict["disable_browser"],
             port=BasicConfig.port,
         )
-        if restart_requested:
-            print_status("[Main] Restart requested, cleaning up...", "info")
-            cleanup_for_restart()
-            os._exit(RESTART_EXIT_CODE)
 
 
 if __name__ == "__main__":

unilabos/app/register.py

@@ -1,8 +1,9 @@
+import json
 import time
-from typing import Any, Dict, Optional, Tuple
+from typing import Optional, Tuple, Dict, Any
 
 from unilabos.utils.log import logger
-from unilabos.utils.tools import normalize_json as _normalize_device
+from unilabos.utils.type_check import TypeEncoder
 
 
 def register_devices_and_resources(lab_registry, gather_only=False) -> Optional[Tuple[Dict[str, Any], Dict[str, Any]]]:
@@ -10,63 +11,50 @@ def register_devices_and_resources(lab_registry, gather_only=False) -> Optional[
     注册设备和资源到服务器（仅支持HTTP）
     """
 
+    # 注册资源信息 - 使用HTTP方式
     from unilabos.app.web.client import http_client
 
     logger.info("[UniLab Register] 开始注册设备和资源...")
 
+    # 注册设备信息
     devices_to_register = {}
     for device_info in lab_registry.obtain_registry_device_info():
-        devices_to_register[device_info["id"]] = _normalize_device(device_info)
-        logger.trace(f"[UniLab Register] 收集设备: {device_info['id']}")
+        devices_to_register[device_info["id"]] = json.loads(
+            json.dumps(device_info, ensure_ascii=False, cls=TypeEncoder)
+        )
+        logger.debug(f"[UniLab Register] 收集设备: {device_info['id']}")
 
     resources_to_register = {}
     for resource_info in lab_registry.obtain_registry_resource_info():
         resources_to_register[resource_info["id"]] = resource_info
-        logger.trace(f"[UniLab Register] 收集资源: {resource_info['id']}")
+        logger.debug(f"[UniLab Register] 收集资源: {resource_info['id']}")
 
     if gather_only:
         return devices_to_register, resources_to_register
-
+    # 注册设备
     if devices_to_register:
         try:
             start_time = time.time()
-            response = http_client.resource_registry(
-                {"resources": list(devices_to_register.values())},
-                tag="device_registry",
-            )
+            response = http_client.resource_registry({"resources": list(devices_to_register.values())})
             cost_time = time.time() - start_time
-            res_data = response.json() if response.status_code == 200 else {}
-            skipped = res_data.get("data", {}).get("skipped", False)
-            if skipped:
-                logger.info(
-                    f"[UniLab Register] 设备注册跳过（内容未变化）"
-                    f" {len(devices_to_register)} 个 {cost_time:.3f}s"
-                )
-            elif response.status_code in [200, 201]:
-                logger.info(f"[UniLab Register] 成功注册 {len(devices_to_register)} 个设备 {cost_time:.3f}s")
+            if response.status_code in [200, 201]:
+                logger.info(f"[UniLab Register] 成功注册 {len(devices_to_register)} 个设备 {cost_time}s")
             else:
-                logger.error(f"[UniLab Register] 设备注册失败: {response.status_code}, {response.text} {cost_time:.3f}s")
+                logger.error(f"[UniLab Register] 设备注册失败: {response.status_code}, {response.text} {cost_time}s")
         except Exception as e:
             logger.error(f"[UniLab Register] 设备注册异常: {e}")
 
+    # 注册资源
     if resources_to_register:
         try:
             start_time = time.time()
-            response = http_client.resource_registry(
-                {"resources": list(resources_to_register.values())},
-                tag="resource_registry",
-            )
+            response = http_client.resource_registry({"resources": list(resources_to_register.values())})
             cost_time = time.time() - start_time
-            res_data = response.json() if response.status_code == 200 else {}
-            skipped = res_data.get("data", {}).get("skipped", False)
-            if skipped:
-                logger.info(
-                    f"[UniLab Register] 资源注册跳过（内容未变化）"
-                    f" {len(resources_to_register)} 个 {cost_time:.3f}s"
-                )
-            elif response.status_code in [200, 201]:
-                logger.info(f"[UniLab Register] 成功注册 {len(resources_to_register)} 个资源 {cost_time:.3f}s")
+            if response.status_code in [200, 201]:
+                logger.info(f"[UniLab Register] 成功注册 {len(resources_to_register)} 个资源 {cost_time}s")
             else:
-                logger.error(f"[UniLab Register] 资源注册失败: {response.status_code}, {response.text} {cost_time:.3f}s")
+                logger.error(f"[UniLab Register] 资源注册失败: {response.status_code}, {response.text} {cost_time}s")
         except Exception as e:
             logger.error(f"[UniLab Register] 资源注册异常: {e}")
+
+    logger.info("[UniLab Register] 设备和资源注册完成.")

unilabos/app/web/api.py

@@ -1052,7 +1052,7 @@ async def handle_file_import(websocket: WebSocket, request_data: dict):
                                 "result": {},
                                 "schema": lab_registry._generate_unilab_json_command_schema(v["args"], k),
                                 "goal_default": {i["name"]: i["default"] for i in v["args"]},
-                                "handles": {},
+                                "handles": [],
                             }
                             # 不生成已配置action的动作
                             for k, v in enhanced_info["action_methods"].items()
@@ -1340,5 +1340,5 @@ def setup_api_routes(app):
     # 启动广播任务
     @app.on_event("startup")
     async def startup_event():
-        asyncio.create_task(broadcast_device_status(), name="web-api-startup-device")
-        asyncio.create_task(broadcast_status_page_data(), name="web-api-startup-status")
+        asyncio.create_task(broadcast_device_status())
+        asyncio.create_task(broadcast_status_page_data())

unilabos/app/web/client.py

@@ -3,13 +3,11 @@ HTTP客户端模块
 
 提供与远程服务器通信的客户端功能，只有host需要用
 """
-import gzip
+
 import json
 import os
 from typing import List, Dict, Any, Optional
 
-from unilabos.utils.tools import fast_dumps as _fast_dumps, fast_dumps_pretty as _fast_dumps_pretty
-
 import requests
 from unilabos.resources.resource_tracker import ResourceTreeSet
 from unilabos.utils.log import info
@@ -282,54 +280,22 @@ class HTTPClient:
             )
         return response
 
-    def resource_registry(
-        self, registry_data: Dict[str, Any] | List[Dict[str, Any]], tag: str = "registry",
-    ) -> requests.Response:
+    def resource_registry(self, registry_data: Dict[str, Any] | List[Dict[str, Any]]) -> requests.Response:
         """
-        注册资源到服务器，同步保存请求/响应到 unilabos_data
+        注册资源到服务器
 
         Args:
             registry_data: 注册表数据，格式为 {resource_id: resource_info} / [{resource_info}]
-            tag: 保存文件的标签后缀 (如 "device_registry" / "resource_registry")
 
         Returns:
             Response: API响应对象
         """
-        # 序列化一次，同时用于保存和发送
-        json_bytes = _fast_dumps(registry_data)
-
-        # 保存请求数据到 unilabos_data
-        req_path = os.path.join(BasicConfig.working_dir, f"req_{tag}_upload.json")
-        try:
-            os.makedirs(BasicConfig.working_dir, exist_ok=True)
-            with open(req_path, "wb") as f:
-                f.write(_fast_dumps_pretty(registry_data))
-            logger.trace(f"注册表请求数据已保存: {req_path}")
-        except Exception as e:
-            logger.warning(f"保存注册表请求数据失败: {e}")
-
-        compressed_body = gzip.compress(json_bytes)
-        headers = {
-            "Authorization": f"Lab {self.auth}",
-            "Content-Type": "application/json",
-            "Content-Encoding": "gzip",
-        }
         response = requests.post(
             f"{self.remote_addr}/lab/resource",
-            data=compressed_body,
-            headers=headers,
+            json=registry_data,
+            headers={"Authorization": f"Lab {self.auth}"},
             timeout=30,
         )
-
-        # 保存响应数据到 unilabos_data
-        res_path = os.path.join(BasicConfig.working_dir, f"res_{tag}_upload.json")
-        try:
-            with open(res_path, "w", encoding="utf-8") as f:
-                f.write(f"{response.status_code}\n{response.text}")
-            logger.trace(f"注册表响应数据已保存: {res_path}")
-        except Exception as e:
-            logger.warning(f"保存注册表响应数据失败: {e}")
-
         if response.status_code not in [200, 201]:
             logger.error(f"注册资源失败: {response.status_code}, {response.text}")
         if response.status_code == 200:

unilabos/app/web/server.py

@@ -86,7 +86,7 @@ def setup_server() -> FastAPI:
     # 设置页面路由
     try:
         setup_web_pages(pages)
-        # info("[Web] 已加载Web UI模块")
+        info("[Web] 已加载Web UI模块")
     except ImportError as e:
         info(f"[Web] 未找到Web页面模块: {str(e)}")
     except Exception as e:
@@ -138,7 +138,7 @@ def start_server(host: str = "0.0.0.0", port: int = 8002, open_browser: bool = T
     server_thread = threading.Thread(target=server.run, daemon=True, name="uvicorn_server")
     server_thread.start()
 
-    # info("[Web] Server started, monitoring for restart requests...")
+    info("[Web] Server started, monitoring for restart requests...")
 
     # 监控重启标志
     import unilabos.app.main as main_module

unilabos/app/ws_client.py

@@ -26,7 +26,6 @@ from enum import Enum
 from typing_extensions import TypedDict
 
 from unilabos.app.model import JobAddReq
-from unilabos.resources.resource_tracker import ResourceDictType
 from unilabos.ros.nodes.presets.host_node import HostNode
 from unilabos.utils.type_check import serialize_result_info
 from unilabos.app.communication import BaseCommunicationClient
@@ -409,7 +408,6 @@ class MessageProcessor:
         # 线程控制
         self.is_running = False
         self.thread = None
-        self._loop = None  # asyncio event loop引用，用于外部关闭websocket
         self.reconnect_count = 0
 
         logger.info(f"[MessageProcessor] Initialized for URL: {websocket_url}")
@@ -436,31 +434,22 @@ class MessageProcessor:
     def stop(self) -> None:
         """停止消息处理线程"""
         self.is_running = False
-        # 主动关闭websocket以快速中断消息接收循环
-        ws = self.websocket
-        loop = self._loop
-        if ws and loop and loop.is_running():
-            try:
-                asyncio.run_coroutine_threadsafe(ws.close(), loop)
-            except Exception:
-                pass
         if self.thread and self.thread.is_alive():
             self.thread.join(timeout=2)
         logger.info("[MessageProcessor] Stopped")
 
     def _run(self):
         """运行消息处理主循环"""
-        self._loop = asyncio.new_event_loop()
+        loop = asyncio.new_event_loop()
         try:
-            asyncio.set_event_loop(self._loop)
-            self._loop.run_until_complete(self._connection_handler())
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(self._connection_handler())
         except Exception as e:
             logger.error(f"[MessageProcessor] Thread error: {str(e)}")
             logger.error(traceback.format_exc())
         finally:
-            if self._loop:
-                self._loop.close()
-            self._loop = None
+            if loop:
+                loop.close()
 
     async def _connection_handler(self):
         """处理WebSocket连接和重连逻辑"""
@@ -477,10 +466,8 @@ class MessageProcessor:
                 async with websockets.connect(
                     self.websocket_url,
                     ssl=ssl_context,
-                    open_timeout=20,
                     ping_interval=WSConfig.ping_interval,
                     ping_timeout=10,
-                    close_timeout=5,
                     additional_headers={
                         "Authorization": f"Lab {BasicConfig.auth_secret()}",
                         "EdgeSession": f"{self.session_id}",
@@ -491,94 +478,81 @@ class MessageProcessor:
                     self.connected = True
                     self.reconnect_count = 0
 
-                    logger.info(f"[MessageProcessor] 已连接到 {self.websocket_url}")
+                    logger.trace(f"[MessageProcessor] Connected to {self.websocket_url}")
 
                     # 启动发送协程
-                    send_task = asyncio.create_task(self._send_handler(), name="websocket-send_task")
-
-                    # 每次连接（含重连）后重新向服务端注册，
-                    # 否则服务端不知道客户端已上线，不会推送消息。
-                    if self.websocket_client:
-                        self.websocket_client.publish_host_ready()
+                    send_task = asyncio.create_task(self._send_handler())
 
                     try:
                         # 接收消息循环
                         await self._message_handler()
                     finally:
-                        # 必须在 async with __aexit__ 之前停止 send_task，
-                        # 否则 send_task 会在关闭握手期间继续发送数据，
-                        # 干扰 websockets 库的内部清理，导致 task 泄漏。
-                        self.connected = False
                         send_task.cancel()
                         try:
                             await send_task
                         except asyncio.CancelledError:
                             pass
+                        self.connected = False
 
             except websockets.exceptions.ConnectionClosed:
-                logger.warning("[MessageProcessor] 与服务端连接中断")
-            except TimeoutError:
-                logger.warning(
-                    f"[MessageProcessor] 与服务端连接通信超时 (已尝试 {self.reconnect_count + 1} 次)，请检查您的网络状况"
-                )
-            except websockets.exceptions.InvalidStatus as e:
-                logger.warning(
-                    f"[MessageProcessor] 收到服务端注册码 {e.response.status_code}, 上一进程可能还未退出"
-                )
-            except Exception as e:
-                logger.error(traceback.format_exc())
-                logger.error(f"[MessageProcessor] 尝试重连时出错 {str(e)}")
-            finally:
+                logger.warning("[MessageProcessor] Connection closed")
                 self.connected = False
+            except Exception as e:
+                logger.error(f"[MessageProcessor] Connection error: {str(e)}")
+                logger.error(traceback.format_exc())
+                self.connected = False
+            finally:
                 self.websocket = None
 
             # 重连逻辑
-            if not self.is_running:
-                break
-            if self.reconnect_count < WSConfig.max_reconnect_attempts:
+            if self.is_running and self.reconnect_count < WSConfig.max_reconnect_attempts:
                 self.reconnect_count += 1
-                backoff = WSConfig.reconnect_interval
                 logger.info(
-                    f"[MessageProcessor] 即将在 {backoff} 秒后重连 (已尝试 {self.reconnect_count}/{WSConfig.max_reconnect_attempts})"
+                    f"[MessageProcessor] Reconnecting in {WSConfig.reconnect_interval}s "
+                    f"(attempt {self.reconnect_count}/{WSConfig.max_reconnect_attempts})"
                 )
-                await asyncio.sleep(backoff)
-            else:
+                await asyncio.sleep(WSConfig.reconnect_interval)
+            elif self.reconnect_count >= WSConfig.max_reconnect_attempts:
                 logger.error("[MessageProcessor] Max reconnection attempts reached")
                 break
+            else:
+                self.reconnect_count -= 1
 
     async def _message_handler(self):
-        """处理接收到的消息。
-
-        ConnectionClosed 不在此处捕获，让其向上传播到 _connection_handler，
-        以便 async with websockets.connect() 的 __aexit__ 能感知连接已断，
-        正确清理内部 task，避免 task 泄漏。
-        """
+        """处理接收到的消息"""
         if not self.websocket:
             logger.error("[MessageProcessor] WebSocket connection is None")
             return
 
-        async for message in self.websocket:
-            try:
-                data = json.loads(message)
-                message_type = data.get("action", "")
-                message_data = data.get("data")
-                if self.session_id and self.session_id == data.get("edge_session"):
-                    await self._process_message(message_type, message_data)
-                else:
-                    if message_type.endswith("_material"):
-                        logger.trace(
-                            f"[MessageProcessor] 收到一条归属 {data.get('edge_session')} 的旧消息：{data}"
-                        )
-                        logger.debug(
-                            f"[MessageProcessor] 跳过了一条归属 {data.get('edge_session')} 的旧消息: {data.get('action')}"
-                        )
-                    else:
+        try:
+            async for message in self.websocket:
+                try:
+                    data = json.loads(message)
+                    message_type = data.get("action", "")
+                    message_data = data.get("data")
+                    if self.session_id and self.session_id == data.get("edge_session"):
                         await self._process_message(message_type, message_data)
-            except json.JSONDecodeError:
-                logger.error(f"[MessageProcessor] Invalid JSON received: {message}")
-            except Exception as e:
-                logger.error(f"[MessageProcessor] Error processing message: {str(e)}")
-                logger.error(traceback.format_exc())
+                    else:
+                        if message_type.endswith("_material"):
+                            logger.trace(
+                                f"[MessageProcessor] 收到一条归属 {data.get('edge_session')} 的旧消息：{data}"
+                            )
+                            logger.debug(
+                                f"[MessageProcessor] 跳过了一条归属 {data.get('edge_session')} 的旧消息: {data.get('action')}"
+                            )
+                        else:
+                            await self._process_message(message_type, message_data)
+                except json.JSONDecodeError:
+                    logger.error(f"[MessageProcessor] Invalid JSON received: {message}")
+                except Exception as e:
+                    logger.error(f"[MessageProcessor] Error processing message: {str(e)}")
+                    logger.error(traceback.format_exc())
+
+        except websockets.exceptions.ConnectionClosed:
+            logger.info("[MessageProcessor] Message handler stopped - connection closed")
+        except Exception as e:
+            logger.error(f"[MessageProcessor] Message handler error: {str(e)}")
+            logger.error(traceback.format_exc())
 
     async def _send_handler(self):
         """处理发送队列中的消息"""
@@ -627,7 +601,6 @@ class MessageProcessor:
 
         except asyncio.CancelledError:
             logger.debug("[MessageProcessor] Send handler cancelled")
-            raise
         except Exception as e:
             logger.error(f"[MessageProcessor] Fatal error in send handler: {str(e)}")
             logger.error(traceback.format_exc())
@@ -659,10 +632,6 @@ class MessageProcessor:
             # elif message_type == "session_id":
             #     self.session_id = message_data.get("session_id")
             #     logger.info(f"[MessageProcessor] Session ID: {self.session_id}")
-            elif message_type == "add_device":
-                await self._handle_device_manage(message_data, "add")
-            elif message_type == "remove_device":
-                await self._handle_device_manage(message_data, "remove")
             elif message_type == "request_restart":
                 await self._handle_request_restart(message_data)
             else:
@@ -999,37 +968,6 @@ class MessageProcessor:
             )
             thread.start()
 
-    async def _handle_device_manage(self, device_list: list[ResourceDictType], action: str):
-        """Handle add_device / remove_device from LabGo server."""
-        if not device_list:
-            return
-
-        for item in device_list:
-            target_node_id = item.get("target_node_id", "host_node")
-
-            def _notify(target_id: str, act: str, cfg: ResourceDictType):
-                try:
-                    host_node = HostNode.get_instance(timeout=5)
-                    if not host_node:
-                        logger.error(f"[DeviceManage] HostNode not available for {act}_device")
-                        return
-                    success = host_node.notify_device_manage(target_id, act, cfg)
-                    if success:
-                        logger.info(f"[DeviceManage] {act}_device completed on {target_id}")
-                    else:
-                        logger.warning(f"[DeviceManage] {act}_device failed on {target_id}")
-                except Exception as e:
-                    logger.error(f"[DeviceManage] Error in {act}_device: {e}")
-                    logger.error(traceback.format_exc())
-
-            thread = threading.Thread(
-                target=_notify,
-                args=(target_node_id, action, item),
-                daemon=True,
-                name=f"DeviceManage-{action}-{item.get('id', '')}",
-            )
-            thread.start()
-
     async def _handle_request_restart(self, data: Dict[str, Any]):
         """
         处理重启请求
@@ -1041,9 +979,10 @@ class MessageProcessor:
         logger.info(f"[MessageProcessor] Received restart request, reason: {reason}, delay: {delay}s")
 
         # 发送确认消息
-        self.send_message(
-            {"action": "restart_acknowledged", "data": {"reason": reason, "delay": delay}}
-        )
+        if self.websocket_client:
+            await self.websocket_client.send_message(
+                {"action": "restart_acknowledged", "data": {"reason": reason, "delay": delay}}
+            )
 
         # 设置全局重启标志
         import unilabos.app.main as main_module
@@ -1145,7 +1084,6 @@ class QueueProcessor:
     def stop(self) -> None:
         """停止队列处理线程"""
         self.is_running = False
-        self.queue_update_event.set()  # 立即唤醒等待中的线程
         if self.thread and self.thread.is_alive():
             self.thread.join(timeout=2)
         logger.info("[QueueProcessor] Stopped")
@@ -1399,8 +1337,8 @@ class WebSocketClient(BaseCommunicationClient):
                 message = {"action": "normal_exit", "data": {"session_id": session_id}}
                 self.message_processor.send_message(message)
                 logger.info(f"[WebSocketClient] Sent normal_exit message with session_id: {session_id}")
-                # send_handler 每100ms检查一次队列，等300ms足以让消息发出
-                time.sleep(0.3)
+                # 给一点时间让消息发送出去
+                time.sleep(1)
             except Exception as e:
                 logger.warning(f"[WebSocketClient] Failed to send normal_exit message: {str(e)}")
 

unilabos/config/config.py

@@ -24,7 +24,6 @@ class BasicConfig:
     port = 8002  # 本地HTTP服务
     check_mode = False  # CI 检查模式，用于验证 registry 导入和文件一致性
     test_mode = False  # 测试模式，所有动作不实际执行，返回模拟结果
-    extra_resource = False  # 是否加载lab_开头的额外资源
     # 'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
     log_level: Literal["TRACE", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "DEBUG"
 
@@ -41,7 +40,7 @@ class BasicConfig:
 class WSConfig:
     reconnect_interval = 5  # 重连间隔（秒）
     max_reconnect_attempts = 999  # 最大重连次数
-    ping_interval = 20  # ping间隔（秒）
+    ping_interval = 30  # ping间隔（秒）
 
 
 # HTTP配置

unilabos/device_comms/universal_driver.py

@@ -1,3 +1,4 @@
+
 from abc import abstractmethod
 from functools import wraps
 import inspect

unilabos/devices/liquid_handling/prcxi/prcxi.py

@@ -93,13 +93,13 @@ class PRCXI9300Deck(Deck):
 
     # T1-T16 默认位置 (4列×4行)
     _DEFAULT_SITE_POSITIONS = [
-        (0, 0, 0), (138, 0, 0), (276, 0, 0), (414, 0, 0),         # T1-T4
-        (0, 96, 0), (138, 96, 0), (276, 96, 0), (414, 96, 0),     # T5-T8
-        (0, 192, 0), (138, 192, 0), (276, 192, 0), (414, 192, 0), # T9-T12
-        (0, 288, 0), (138, 288, 0), (276, 288, 0), (414, 288, 0), # T13-T16
+        (0, 288, 0), (138, 288, 0), (276, 288, 0), (414, 288, 0),   # T1-T4
+        (0, 192, 0), (138, 192, 0), (276, 192, 0), (414, 192, 0),   # T5-T8
+        (0, 96, 0),  (138, 96, 0),  (276, 96, 0),  (414, 96, 0),    # T9-T12
+        (0, 0, 0),   (138, 0, 0),   (276, 0, 0),   (414, 0, 0),     # T13-T16
     ]
     _DEFAULT_SITE_SIZE = {"width": 128.0, "height": 86, "depth": 0}
-    _DEFAULT_CONTENT_TYPE = ["plate", "tip_rack", "plates", "tip_racks", "tube_rack", "adaptor"]
+    _DEFAULT_CONTENT_TYPE = ["plate", "tip_rack", "plates", "tip_racks", "tube_rack"]
 
     def __init__(self, name: str, size_x: float, size_y: float, size_z: float,
                  sites: Optional[List[Dict[str, Any]]] = None, **kwargs):
@@ -634,7 +634,7 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
 
     def __init__(
         self,
-        deck: PRCXI9300Deck,
+        deck: Deck,
         host: str,
         port: int,
         timeout: float,
@@ -648,11 +648,11 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
         is_9320=False,
     ):
         tablets_info = []
-        for site_id in range(len(deck.sites)):
-            child = deck._get_site_resource(site_id)
+        count = 0
+        for child in deck.children:
             # 如果放其他类型的物料，是不可以的
             if hasattr(child, "_unilabos_state") and "Material" in child._unilabos_state:
-                number = site_id + 1
+                number = int(child.name.replace("T", ""))
                 tablets_info.append(
                     WorkTablets(
                         Number=number, Code=f"T{number}", Material=child._unilabos_state["Material"]

unilabos/devices/virtual/workbench.py

@@ -1,15 +1,15 @@
 """
 Virtual Workbench Device - 模拟工作台设备
-包含:
+包含：
 - 1个机械臂 (每次操作3s, 独占锁)
 - 3个加热台 (每次加热10s, 可并行)
 
-工作流程:
-1. A1-A5 物料同时启动, 竞争机械臂
+工作流程：
+1. A1-A5 物料同时启动，竞争机械臂
 2. 机械臂将物料移动到空闲加热台
-3. 加热完成后, 机械臂将物料移动到C1-C5
+3. 加热完成后，机械臂将物料移动到C1-C5
 
-注意: 调用来自线程池, 使用 threading.Lock 进行同步
+注意：调用来自线程池，使用 threading.Lock 进行同步
 """
 
 import logging
@@ -21,11 +21,9 @@ from threading import Lock, RLock
 
 from typing_extensions import TypedDict
 
-from unilabos.registry.decorators import (
-    device, action, ActionInputHandle, ActionOutputHandle, DataSource, topic_config, not_action
-)
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-from unilabos.resources.resource_tracker import SampleUUIDsType, LabSample
+from unilabos.utils.decorator import not_action, always_free
+from unilabos.resources.resource_tracker import SampleUUIDsType, LabSample, RETURN_UNILABOS_SAMPLES
 
 
 # ============ TypedDict 返回类型定义 ============
@@ -59,8 +57,6 @@ class MoveToOutputResult(TypedDict):
     success: bool
     station_id: int
     material_id: str
-    output_position: str
-    message: str
     unilabos_samples: List[LabSample]
 
 
@@ -85,9 +81,9 @@ class HeatingStationState(Enum):
     """加热台状态枚举"""
 
     IDLE = "idle"  # 空闲
-    OCCUPIED = "occupied"  # 已放置物料, 等待加热
+    OCCUPIED = "occupied"  # 已放置物料，等待加热
     HEATING = "heating"  # 加热中
-    COMPLETED = "completed"  # 加热完成, 等待取走
+    COMPLETED = "completed"  # 加热完成，等待取走
 
 
 class ArmState(Enum):
@@ -109,24 +105,19 @@ class HeatingStation:
     heating_progress: float = 0.0
 
 
-@device(
-    id="virtual_workbench",
-    category=["virtual_device"],
-    description="Virtual Workbench with 1 robotic arm and 3 heating stations for concurrent material processing",
-)
 class VirtualWorkbench:
     """
     Virtual Workbench Device - 虚拟工作台设备
 
     模拟一个包含1个机械臂和3个加热台的工作站
-    - 机械臂操作耗时3秒, 同一时间只能执行一个操作
-    - 加热台加热耗时10秒, 3个加热台可并行工作
+    - 机械臂操作耗时3秒，同一时间只能执行一个操作
+    - 加热台加热耗时10秒，3个加热台可并行工作
 
     工作流:
-    1. 物料A1-A5并发启动(线程池), 竞争机械臂使用权
-    2. 获取机械臂后, 查找空闲加热台
-    3. 机械臂将物料放入加热台, 开始加热
-    4. 加热完成后, 机械臂将物料移动到目标位置Cn
+    1. 物料A1-A5并发启动（线程池），竞争机械臂使用权
+    2. 获取机械臂后，查找空闲加热台
+    3. 机械臂将物料放入加热台，开始加热
+    4. 加热完成后，机械臂将物料移动到目标位置Cn
     """
 
     _ros_node: BaseROS2DeviceNode
@@ -154,19 +145,19 @@ class VirtualWorkbench:
         self.HEATING_TIME = float(self.config.get("heating_time", self.HEATING_TIME))
         self.NUM_HEATING_STATIONS = int(self.config.get("num_heating_stations", self.NUM_HEATING_STATIONS))
 
-        # 机械臂状态和锁
+        # 机械臂状态和锁 (使用threading.Lock)
         self._arm_lock = Lock()
         self._arm_state = ArmState.IDLE
         self._arm_current_task: Optional[str] = None
 
-        # 加热台状态
+        # 加热台状态 (station_id -> HeatingStation) - 立即初始化，不依赖initialize()
         self._heating_stations: Dict[int, HeatingStation] = {
             i: HeatingStation(station_id=i) for i in range(1, self.NUM_HEATING_STATIONS + 1)
         }
-        self._stations_lock = RLock()
+        self._stations_lock = RLock()  # 可重入锁，保护加热台状态
 
         # 任务追踪
-        self._active_tasks: Dict[str, Dict[str, Any]] = {}
+        self._active_tasks: Dict[str, Dict[str, Any]] = {}  # material_id -> task_info
         self._tasks_lock = Lock()
 
         # 处理其他kwargs参数
@@ -192,6 +183,7 @@ class VirtualWorkbench:
         """初始化虚拟工作台"""
         self.logger.info(f"初始化虚拟工作台 {self.device_id}")
 
+        # 重置加热台状态 (已在__init__中创建，这里重置为初始状态)
         with self._stations_lock:
             for station in self._heating_stations.values():
                 station.state = HeatingStationState.IDLE
@@ -199,6 +191,7 @@ class VirtualWorkbench:
                 station.material_number = None
                 station.heating_progress = 0.0
 
+        # 初始化状态
         self.data.update(
             {
                 "status": "Ready",
@@ -264,7 +257,11 @@ class VirtualWorkbench:
             self.data["message"] = message
 
     def _find_available_heating_station(self) -> Optional[int]:
-        """查找空闲的加热台"""
+        """查找空闲的加热台
+
+        Returns:
+            空闲加热台ID，如果没有则返回None
+        """
         with self._stations_lock:
             for station_id, station in self._heating_stations.items():
                 if station.state == HeatingStationState.IDLE:
@@ -272,12 +269,23 @@ class VirtualWorkbench:
         return None
 
     def _acquire_arm(self, task_description: str) -> bool:
-        """获取机械臂使用权(阻塞直到获取)"""
+        """获取机械臂使用权（阻塞直到获取）
+
+        Args:
+            task_description: 任务描述，用于日志
+
+        Returns:
+            是否成功获取
+        """
         self.logger.info(f"[{task_description}] 等待获取机械臂...")
+
+        # 阻塞等待获取锁
         self._arm_lock.acquire()
+
         self._arm_state = ArmState.BUSY
         self._arm_current_task = task_description
         self._update_data_status(f"机械臂执行: {task_description}")
+
         self.logger.info(f"[{task_description}] 成功获取机械臂使用权")
         return True
 
@@ -290,22 +298,6 @@ class VirtualWorkbench:
         self._update_data_status(f"机械臂已释放 (完成: {task})")
         self.logger.info(f"机械臂已释放 (完成: {task})")
 
-    @action(
-        auto_prefix=True,
-        description="批量准备物料 - 虚拟起始节点, 生成A1-A5物料, 输出5个handle供后续节点使用",
-        handles=[
-            ActionOutputHandle(key="channel_1", data_type="workbench_material",
-                         label="实验1", data_key="material_1", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="channel_2", data_type="workbench_material",
-                         label="实验2", data_key="material_2", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="channel_3", data_type="workbench_material",
-                         label="实验3", data_key="material_3", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="channel_4", data_type="workbench_material",
-                         label="实验4", data_key="material_4", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="channel_5", data_type="workbench_material",
-                         label="实验5", data_key="material_5", data_source=DataSource.EXECUTOR),
-        ],
-    )
     def prepare_materials(
         self,
         sample_uuids: SampleUUIDsType,
@@ -314,14 +306,19 @@ class VirtualWorkbench:
         """
         批量准备物料 - 虚拟起始节点
 
-        作为工作流的起始节点, 生成指定数量的物料编号供后续节点使用。
-        输出5个handle (material_1 ~ material_5), 分别对应实验1~5。
+        作为工作流的起始节点，生成指定数量的物料编号供后续节点使用。
+        输出5个handle (material_1 ~ material_5)，分别对应实验1~5。
+
+        Args:
+            count: 待生成的物料数量，默认5 (生成 A1-A5)
+
+        Returns:
+            PrepareMaterialsResult: 包含 material_1 ~ material_5 用于传递给 move_to_heating_station
         """
+        # 生成物料列表 A1 - A{count}
         materials = [i for i in range(1, count + 1)]
 
-        self.logger.info(
-            f"[准备物料] 生成 {count} 个物料: A1-A{count} -> material_1~material_{count}"
-        )
+        self.logger.info(f"[准备物料] 生成 {count} 个物料: " f"A1-A{count} -> material_1~material_{count}")
 
         return {
             "success": True,
@@ -332,28 +329,9 @@ class VirtualWorkbench:
             "material_4": materials[3] if len(materials) > 3 else 0,
             "material_5": materials[4] if len(materials) > 4 else 0,
             "message": f"已准备 {count} 个物料: A1-A{count}",
-            "unilabos_samples": [
-                LabSample(
-                    sample_uuid=sample_uuid,
-                    oss_path="",
-                    extra={"material_uuid": content} if isinstance(content, str) else (content.serialize() if content else {}),
-                )
-                for sample_uuid, content in sample_uuids.items()
-            ],
+            "unilabos_samples": [LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for sample_uuid, content in sample_uuids.items()]
         }
 
-    @action(
-        auto_prefix=True,
-        description="将物料从An位置移动到空闲加热台, 返回分配的加热台ID",
-        handles=[
-            ActionInputHandle(key="material_input", data_type="workbench_material",
-                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
-            ActionOutputHandle(key="heating_station_output", data_type="workbench_station",
-                         label="加热台ID", data_key="station_id", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="material_number_output", data_type="workbench_material",
-                         label="物料编号", data_key="material_number", data_source=DataSource.EXECUTOR),
-        ],
-    )
     def move_to_heating_station(
         self,
         sample_uuids: SampleUUIDsType,
@@ -362,12 +340,20 @@ class VirtualWorkbench:
         """
         将物料从An位置移动到加热台
 
-        多线程并发调用时, 会竞争机械臂使用权, 并自动查找空闲加热台
+        多线程并发调用时，会竞争机械臂使用权，并自动查找空闲加热台
+
+        Args:
+            material_number: 物料编号 (1-5)
+
+        Returns:
+            MoveToHeatingStationResult: 包含 station_id, material_number 等用于传递给下一个节点
         """
+        # 根据物料编号生成物料ID
         material_id = f"A{material_number}"
         task_desc = f"移动{material_id}到加热台"
         self.logger.info(f"[任务] {task_desc} - 开始执行")
 
+        # 记录任务
         with self._tasks_lock:
             self._active_tasks[material_id] = {
                 "status": "waiting_for_arm",
@@ -375,27 +361,33 @@ class VirtualWorkbench:
             }
 
         try:
+            # 步骤1: 等待获取机械臂使用权(竞争)
             with self._tasks_lock:
                 self._active_tasks[material_id]["status"] = "waiting_for_arm"
             self._acquire_arm(task_desc)
 
+            # 步骤2: 查找空闲加热台
             with self._tasks_lock:
                 self._active_tasks[material_id]["status"] = "finding_station"
             station_id = None
 
+            # 循环等待直到找到空闲加热台
             while station_id is None:
                 station_id = self._find_available_heating_station()
                 if station_id is None:
-                    self.logger.info(f"[{material_id}] 没有空闲加热台, 等待中...")
+                    self.logger.info(f"[{material_id}] 没有空闲加热台，等待中...")
+                    # 释放机械臂，等待后重试
                     self._release_arm()
                     time.sleep(0.5)
                     self._acquire_arm(task_desc)
 
+            # 步骤3: 占用加热台 - 立即标记为OCCUPIED，防止其他任务选择同一加热台
             with self._stations_lock:
                 self._heating_stations[station_id].state = HeatingStationState.OCCUPIED
                 self._heating_stations[station_id].current_material = material_id
                 self._heating_stations[station_id].material_number = material_number
 
+            # 步骤4: 模拟机械臂移动操作 (3秒)
             with self._tasks_lock:
                 self._active_tasks[material_id]["status"] = "arm_moving"
                 self._active_tasks[material_id]["assigned_station"] = station_id
@@ -403,11 +395,11 @@ class VirtualWorkbench:
 
             time.sleep(self.ARM_OPERATION_TIME)
 
+            # 步骤5: 放入加热台完成
             self._update_data_status(f"{material_id}已放入加热台{station_id}")
-            self.logger.info(
-                f"[{material_id}] 已放入加热台{station_id} (用时{self.ARM_OPERATION_TIME}s)"
-            )
+            self.logger.info(f"[{material_id}] 已放入加热台{station_id} (用时{self.ARM_OPERATION_TIME}s)")
 
+            # 释放机械臂
             self._release_arm()
 
             with self._tasks_lock:
@@ -420,16 +412,8 @@ class VirtualWorkbench:
                 "material_number": material_number,
                 "message": f"{material_id}已成功移动到加热台{station_id}",
                 "unilabos_samples": [
-                    LabSample(
-                        sample_uuid=sample_uuid,
-                        oss_path="",
-                        extra=(
-                            {"material_uuid": content}
-                            if isinstance(content, str) else (content.serialize() if content else {})
-                        ),
-                    )
-                    for sample_uuid, content in sample_uuids.items()
-                ],
+                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
+                    sample_uuid, content in sample_uuids.items()]
             }
 
         except Exception as e:
@@ -443,33 +427,11 @@ class VirtualWorkbench:
                 "material_number": material_number,
                 "message": f"移动失败: {str(e)}",
                 "unilabos_samples": [
-                    LabSample(
-                        sample_uuid=sample_uuid,
-                        oss_path="",
-                        extra=(
-                            {"material_uuid": content}
-                            if isinstance(content, str) else (content.serialize() if content else {})
-                        ),
-                    )
-                    for sample_uuid, content in sample_uuids.items()
-                ],
+                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
+                    sample_uuid, content in sample_uuids.items()]
             }
 
-    @action(
-        auto_prefix=True,
-        always_free=True,
-        description="启动指定加热台的加热程序",
-        handles=[
-            ActionInputHandle(key="station_id_input", data_type="workbench_station",
-                        label="加热台ID", data_key="station_id", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="material_number_input", data_type="workbench_material",
-                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
-            ActionOutputHandle(key="heating_done_station", data_type="workbench_station",
-                         label="加热完成-加热台ID", data_key="station_id", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="heating_done_material", data_type="workbench_material",
-                         label="加热完成-物料编号", data_key="material_number", data_source=DataSource.EXECUTOR),
-        ],
-    )
+    @always_free
     def start_heating(
         self,
         sample_uuids: SampleUUIDsType,
@@ -478,6 +440,13 @@ class VirtualWorkbench:
     ) -> StartHeatingResult:
         """
         启动指定加热台的加热程序
+
+        Args:
+            station_id: 加热台ID (1-3)，从 move_to_heating_station 的 handle 传入
+            material_number: 物料编号，从 move_to_heating_station 的 handle 传入
+
+        Returns:
+            StartHeatingResult: 包含 station_id, material_number 等用于传递给下一个节点
         """
         self.logger.info(f"[加热台{station_id}] 开始加热")
 
@@ -489,16 +458,8 @@ class VirtualWorkbench:
                 "material_number": material_number,
                 "message": f"无效的加热台ID: {station_id}",
                 "unilabos_samples": [
-                    LabSample(
-                        sample_uuid=sample_uuid,
-                        oss_path="",
-                        extra=(
-                            {"material_uuid": content}
-                            if isinstance(content, str) else (content.serialize() if content else {})
-                        ),
-                    )
-                    for sample_uuid, content in sample_uuids.items()
-                ],
+                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
+                    sample_uuid, content in sample_uuids.items()]
             }
 
         with self._stations_lock:
@@ -512,16 +473,8 @@ class VirtualWorkbench:
                     "material_number": material_number,
                     "message": f"加热台{station_id}上没有物料",
                     "unilabos_samples": [
-                        LabSample(
-                            sample_uuid=sample_uuid,
-                            oss_path="",
-                            extra=(
-                                {"material_uuid": content}
-                                if isinstance(content, str) else (content.serialize() if content else {})
-                            ),
-                        )
-                        for sample_uuid, content in sample_uuids.items()
-                    ],
+                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
+                        sample_uuid, content in sample_uuids.items()]
                 }
 
             if station.state == HeatingStationState.HEATING:
@@ -532,20 +485,13 @@ class VirtualWorkbench:
                     "material_number": material_number,
                     "message": f"加热台{station_id}已经在加热中",
                     "unilabos_samples": [
-                        LabSample(
-                            sample_uuid=sample_uuid,
-                            oss_path="",
-                            extra=(
-                                {"material_uuid": content}
-                                if isinstance(content, str) else (content.serialize() if content else {})
-                            ),
-                        )
-                        for sample_uuid, content in sample_uuids.items()
-                    ],
+                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
+                        sample_uuid, content in sample_uuids.items()]
                 }
 
             material_id = station.current_material
 
+            # 开始加热
             station.state = HeatingStationState.HEATING
             station.heating_start_time = time.time()
             station.heating_progress = 0.0
@@ -556,6 +502,7 @@ class VirtualWorkbench:
 
         self._update_data_status(f"加热台{station_id}开始加热{material_id}")
 
+        # 打印当前所有正在加热的台位
         with self._stations_lock:
             heating_list = [
                 f"加热台{sid}:{s.current_material}"
@@ -564,6 +511,7 @@ class VirtualWorkbench:
             ]
         self.logger.info(f"[并行加热] 当前同时加热中: {', '.join(heating_list)}")
 
+        # 模拟加热过程
         start_time = time.time()
         last_countdown_log = start_time
         while True:
@@ -576,6 +524,7 @@ class VirtualWorkbench:
 
             self._update_data_status(f"加热台{station_id}加热中: {progress:.1f}%")
 
+            # 每5秒打印一次倒计时
             if time.time() - last_countdown_log >= 5.0:
                 self.logger.info(f"[加热台{station_id}] {material_id} 剩余 {remaining:.1f}s")
                 last_countdown_log = time.time()
@@ -585,6 +534,7 @@ class VirtualWorkbench:
 
             time.sleep(1.0)
 
+        # 加热完成
         with self._stations_lock:
             self._heating_stations[station_id].state = HeatingStationState.COMPLETED
             self._heating_stations[station_id].heating_progress = 100.0
@@ -603,28 +553,10 @@ class VirtualWorkbench:
             "material_number": material_number,
             "message": f"加热台{station_id}加热完成",
             "unilabos_samples": [
-                LabSample(
-                    sample_uuid=sample_uuid,
-                    oss_path="",
-                    extra=(
-                        {"material_uuid": content}
-                        if isinstance(content, str) else (content.serialize() if content else {})
-                    ),
-                )
-                for sample_uuid, content in sample_uuids.items()
-            ],
+                LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
+                sample_uuid, content in sample_uuids.items()]
         }
 
-    @action(
-        auto_prefix=True,
-        description="将物料从加热台移动到输出位置Cn",
-        handles=[
-            ActionInputHandle(key="output_station_input", data_type="workbench_station",
-                        label="加热台ID", data_key="station_id", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="output_material_input", data_type="workbench_material",
-                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
-        ],
-    )
     def move_to_output(
         self,
         sample_uuids: SampleUUIDsType,
@@ -633,8 +565,15 @@ class VirtualWorkbench:
     ) -> MoveToOutputResult:
         """
         将物料从加热台移动到输出位置Cn
+
+        Args:
+            station_id: 加热台ID (1-3)，从 start_heating 的 handle 传入
+            material_number: 物料编号，从 start_heating 的 handle 传入，用于确定输出位置 Cn
+
+        Returns:
+            MoveToOutputResult: 包含执行结果
         """
-        output_number = material_number
+        output_number = material_number  # 物料编号决定输出位置
 
         if station_id not in self._heating_stations:
             return {
@@ -644,16 +583,8 @@ class VirtualWorkbench:
                 "output_position": f"C{output_number}",
                 "message": f"无效的加热台ID: {station_id}",
                 "unilabos_samples": [
-                    LabSample(
-                        sample_uuid=sample_uuid,
-                        oss_path="",
-                        extra=(
-                            {"material_uuid": content}
-                            if isinstance(content, str) else (content.serialize() if content else {})
-                        ),
-                    )
-                    for sample_uuid, content in sample_uuids.items()
-                ],
+                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
+                    sample_uuid, content in sample_uuids.items()]
             }
 
         with self._stations_lock:
@@ -668,16 +599,8 @@ class VirtualWorkbench:
                     "output_position": f"C{output_number}",
                     "message": f"加热台{station_id}上没有物料",
                     "unilabos_samples": [
-                        LabSample(
-                            sample_uuid=sample_uuid,
-                            oss_path="",
-                            extra=(
-                                {"material_uuid": content}
-                                if isinstance(content, str) else (content.serialize() if content else {})
-                            ),
-                        )
-                        for sample_uuid, content in sample_uuids.items()
-                    ],
+                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
+                        sample_uuid, content in sample_uuids.items()]
                 }
 
             if station.state != HeatingStationState.COMPLETED:
@@ -688,16 +611,8 @@ class VirtualWorkbench:
                     "output_position": f"C{output_number}",
                     "message": f"加热台{station_id}尚未完成加热 (当前状态: {station.state.value})",
                     "unilabos_samples": [
-                        LabSample(
-                            sample_uuid=sample_uuid,
-                            oss_path="",
-                            extra=(
-                                {"material_uuid": content}
-                                if isinstance(content, str) else (content.serialize() if content else {})
-                            ),
-                        )
-                        for sample_uuid, content in sample_uuids.items()
-                    ],
+                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
+                        sample_uuid, content in sample_uuids.items()]
                 }
 
         output_position = f"C{output_number}"
@@ -709,17 +624,18 @@ class VirtualWorkbench:
                 if material_id in self._active_tasks:
                     self._active_tasks[material_id]["status"] = "waiting_for_arm_output"
 
+            # 获取机械臂
             self._acquire_arm(task_desc)
 
             with self._tasks_lock:
                 if material_id in self._active_tasks:
                     self._active_tasks[material_id]["status"] = "arm_moving_to_output"
 
-            self.logger.info(
-                f"[{material_id}] 机械臂正在从加热台{station_id}取出并移动到{output_position}..."
-            )
+            # 模拟机械臂操作 (3秒)
+            self.logger.info(f"[{material_id}] 机械臂正在从加热台{station_id}取出并移动到{output_position}...")
             time.sleep(self.ARM_OPERATION_TIME)
 
+            # 清空加热台
             with self._stations_lock:
                 self._heating_stations[station_id].state = HeatingStationState.IDLE
                 self._heating_stations[station_id].current_material = None
@@ -727,17 +643,17 @@ class VirtualWorkbench:
                 self._heating_stations[station_id].heating_progress = 0.0
                 self._heating_stations[station_id].heating_start_time = None
 
+            # 释放机械臂
             self._release_arm()
 
+            # 任务完成
             with self._tasks_lock:
                 if material_id in self._active_tasks:
                     self._active_tasks[material_id]["status"] = "completed"
                     self._active_tasks[material_id]["end_time"] = time.time()
 
             self._update_data_status(f"{material_id}已移动到{output_position}")
-            self.logger.info(
-                f"[{material_id}] 已成功移动到{output_position} (用时{self.ARM_OPERATION_TIME}s)"
-            )
+            self.logger.info(f"[{material_id}] 已成功移动到{output_position} (用时{self.ARM_OPERATION_TIME}s)")
 
             return {
                 "success": True,
@@ -746,17 +662,8 @@ class VirtualWorkbench:
                 "output_position": output_position,
                 "message": f"{material_id}已成功移动到{output_position}",
                 "unilabos_samples": [
-                    LabSample(
-                        sample_uuid=sample_uuid,
-                        oss_path="",
-                        extra=(
-                            {"material_uuid": content}
-                            if isinstance(content, str)
-                            else (content.serialize() if content is not None else {})
-                        ),
-                    )
-                    for sample_uuid, content in sample_uuids.items()
-                ],
+                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
+                    sample_uuid, content in sample_uuids.items()]
             }
 
         except Exception as e:
@@ -770,105 +677,83 @@ class VirtualWorkbench:
                 "output_position": output_position,
                 "message": f"移动失败: {str(e)}",
                 "unilabos_samples": [
-                    LabSample(
-                        sample_uuid=sample_uuid,
-                        oss_path="",
-                        extra=(
-                            {"material_uuid": content}
-                            if isinstance(content, str) else (content.serialize() if content else {})
-                        ),
-                    )
-                    for sample_uuid, content in sample_uuids.items()
-                ],
+                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
+                    sample_uuid, content in sample_uuids.items()]
             }
 
     # ============ 状态属性 ============
 
     @property
-    @topic_config()
     def status(self) -> str:
         return self.data.get("status", "Unknown")
 
     @property
-    @topic_config()
     def arm_state(self) -> str:
         return self._arm_state.value
 
     @property
-    @topic_config()
     def arm_current_task(self) -> str:
         return self._arm_current_task or ""
 
     @property
-    @topic_config()
     def heating_station_1_state(self) -> str:
         with self._stations_lock:
             station = self._heating_stations.get(1)
             return station.state.value if station else "unknown"
 
     @property
-    @topic_config()
     def heating_station_1_material(self) -> str:
         with self._stations_lock:
             station = self._heating_stations.get(1)
             return station.current_material or "" if station else ""
 
     @property
-    @topic_config()
     def heating_station_1_progress(self) -> float:
         with self._stations_lock:
             station = self._heating_stations.get(1)
             return station.heating_progress if station else 0.0
 
     @property
-    @topic_config()
     def heating_station_2_state(self) -> str:
         with self._stations_lock:
             station = self._heating_stations.get(2)
             return station.state.value if station else "unknown"
 
     @property
-    @topic_config()
     def heating_station_2_material(self) -> str:
         with self._stations_lock:
             station = self._heating_stations.get(2)
             return station.current_material or "" if station else ""
 
     @property
-    @topic_config()
     def heating_station_2_progress(self) -> float:
         with self._stations_lock:
             station = self._heating_stations.get(2)
             return station.heating_progress if station else 0.0
 
     @property
-    @topic_config()
     def heating_station_3_state(self) -> str:
         with self._stations_lock:
             station = self._heating_stations.get(3)
             return station.state.value if station else "unknown"
 
     @property
-    @topic_config()
     def heating_station_3_material(self) -> str:
         with self._stations_lock:
             station = self._heating_stations.get(3)
             return station.current_material or "" if station else ""
 
     @property
-    @topic_config()
     def heating_station_3_progress(self) -> float:
         with self._stations_lock:
             station = self._heating_stations.get(3)
             return station.heating_progress if station else 0.0
 
     @property
-    @topic_config()
     def active_tasks_count(self) -> int:
         with self._tasks_lock:
             return len(self._active_tasks)
 
     @property
-    @topic_config()
     def message(self) -> str:
         return self.data.get("message", "")

unilabos/registry/decorators.py

@@ -1,614 +0,0 @@
-"""
-装饰器注册表系统
-
-通过 @device, @action, @resource 装饰器替代 YAML 配置文件来定义设备/动作/资源注册表信息。
-
-Usage:
-    from unilabos.registry.decorators import (
-        device, action, resource,
-        InputHandle, OutputHandle,
-        ActionInputHandle, ActionOutputHandle,
-        HardwareInterface, Side, DataSource,
-    )
-
-    @device(
-        id="solenoid_valve.mock",
-        category=["pump_and_valve"],
-        description="模拟电磁阀设备",
-        handles=[
-            InputHandle(key="in", data_type="fluid", label="in", side=Side.NORTH),
-            OutputHandle(key="out", data_type="fluid", label="out", side=Side.SOUTH),
-        ],
-        hardware_interface=HardwareInterface(
-            name="hardware_interface",
-            read="send_command",
-            write="send_command",
-        ),
-    )
-    class SolenoidValveMock:
-        @action(action_type=EmptyIn)
-        def close(self):
-            ...
-
-        @action(
-            handles=[
-                ActionInputHandle(key="in", data_type="fluid", label="in"),
-                ActionOutputHandle(key="out", data_type="fluid", label="out"),
-            ],
-        )
-        def set_valve_position(self, position):
-            ...
-
-        # 无 @action 装饰器 => auto- 前缀动作
-        def is_open(self):
-            ...
-"""
-
-from enum import Enum
-from functools import wraps
-from typing import Any, Callable, Dict, List, Optional, TypeVar
-
-from pydantic import BaseModel, ConfigDict, Field
-
-F = TypeVar("F", bound=Callable[..., Any])
-
-# ---------------------------------------------------------------------------
-# 枚举
-# ---------------------------------------------------------------------------
-
-
-class Side(str, Enum):
-    """UI 上 Handle 的显示位置"""
-
-    NORTH = "NORTH"
-    SOUTH = "SOUTH"
-    EAST = "EAST"
-    WEST = "WEST"
-
-
-class DataSource(str, Enum):
-    """Handle 的数据来源"""
-
-    HANDLE = "handle"  # 从上游 handle 获取数据 (用于 InputHandle)
-    EXECUTOR = "executor"  # 从执行器输出数据 (用于 OutputHandle)
-
-
-# ---------------------------------------------------------------------------
-# Device / Resource Handle (设备/资源级别端口, 序列化时包含 io_type)
-# ---------------------------------------------------------------------------
-
-
-class _DeviceHandleBase(BaseModel):
-    """设备/资源端口基类 (内部使用)"""
-
-    model_config = ConfigDict(populate_by_name=True)
-
-    key: str = Field(serialization_alias="handler_key")
-    data_type: str
-    label: str
-    side: Optional[Side] = None
-    data_key: Optional[str] = None
-    data_source: Optional[str] = None
-    description: Optional[str] = None
-
-    # 子类覆盖
-    io_type: str = ""
-
-    def to_registry_dict(self) -> Dict[str, Any]:
-        return self.model_dump(by_alias=True, exclude_none=True)
-
-
-class InputHandle(_DeviceHandleBase):
-    """
-    输入端口 (io_type="target"), 用于 @device / @resource handles
-
-    Example:
-        InputHandle(key="in", data_type="fluid", label="in", side=Side.NORTH)
-    """
-
-    io_type: str = "target"
-
-
-class OutputHandle(_DeviceHandleBase):
-    """
-    输出端口 (io_type="source"), 用于 @device / @resource handles
-
-    Example:
-        OutputHandle(key="out", data_type="fluid", label="out", side=Side.SOUTH)
-    """
-
-    io_type: str = "source"
-
-
-# ---------------------------------------------------------------------------
-# Action Handle (动作级别端口, 序列化时不含 io_type, 按类型自动分组)
-# ---------------------------------------------------------------------------
-
-
-class _ActionHandleBase(BaseModel):
-    """动作端口基类 (内部使用)"""
-
-    model_config = ConfigDict(populate_by_name=True)
-
-    key: str = Field(serialization_alias="handler_key")
-    data_type: str
-    label: str
-    side: Optional[Side] = None
-    data_key: Optional[str] = None
-    data_source: Optional[str] = None
-    description: Optional[str] = None
-    io_type: Optional[str] = None  # source/sink (dataflow) or target/source (device-style)
-
-    def to_registry_dict(self) -> Dict[str, Any]:
-        return self.model_dump(by_alias=True, exclude_none=True)
-
-
-class ActionInputHandle(_ActionHandleBase):
-    """
-    动作输入端口, 用于 @action handles, 序列化后归入 "input" 组
-
-    Example:
-        ActionInputHandle(
-            key="material_input", data_type="workbench_material",
-            label="物料编号", data_key="material_number", data_source="handle",
-        )
-    """
-
-    pass
-
-
-class ActionOutputHandle(_ActionHandleBase):
-    """
-    动作输出端口, 用于 @action handles, 序列化后归入 "output" 组
-
-    Example:
-        ActionOutputHandle(
-            key="station_output", data_type="workbench_station",
-            label="加热台ID", data_key="station_id", data_source="executor",
-        )
-    """
-
-    pass
-
-
-# ---------------------------------------------------------------------------
-# HardwareInterface
-# ---------------------------------------------------------------------------
-
-
-class HardwareInterface(BaseModel):
-    """
-    硬件通信接口定义
-
-    描述设备与底层硬件通信的方式 (串口、Modbus 等)。
-
-    Example:
-        HardwareInterface(name="hardware_interface", read="send_command", write="send_command")
-    """
-
-    name: str
-    read: Optional[str] = None
-    write: Optional[str] = None
-    extra_info: Optional[List[str]] = None
-
-
-# ---------------------------------------------------------------------------
-# 全局注册表 -- 记录所有被装饰器标记的类/函数
-# ---------------------------------------------------------------------------
-_registered_devices: Dict[str, type] = {}  # device_id -> class
-_registered_resources: Dict[str, Any] = {}  # resource_id -> class or function
-
-
-def _device_handles_to_list(
-    handles: Optional[List[_DeviceHandleBase]],
-) -> List[Dict[str, Any]]:
-    """将设备/资源 Handle 列表序列化为字典列表 (含 io_type)"""
-    if handles is None:
-        return []
-    return [h.to_registry_dict() for h in handles]
-
-
-def _action_handles_to_dict(
-    handles: Optional[List[_ActionHandleBase]],
-) -> Dict[str, Any]:
-    """
-    将动作 Handle 列表序列化为 {"input": [...], "output": [...]} 格式。
-
-    ActionInputHandle => "input", ActionOutputHandle => "output"
-    """
-    if handles is None:
-        return {}
-    input_list = [h.to_registry_dict() for h in handles if isinstance(h, ActionInputHandle)]
-    output_list = [h.to_registry_dict() for h in handles if isinstance(h, ActionOutputHandle)]
-    result: Dict[str, Any] = {}
-    if input_list:
-        result["input"] = input_list
-    if output_list:
-        result["output"] = output_list
-    return result
-
-
-# ---------------------------------------------------------------------------
-# @device 类装饰器
-# ---------------------------------------------------------------------------
-
-
-# noinspection PyShadowingBuiltins
-def device(
-    id: Optional[str] = None,
-    ids: Optional[List[str]] = None,
-    id_meta: Optional[Dict[str, Dict[str, Any]]] = None,
-    category: Optional[List[str]] = None,
-    description: str = "",
-    display_name: str = "",
-    icon: str = "",
-    version: str = "1.0.0",
-    handles: Optional[List[_DeviceHandleBase]] = None,
-    model: Optional[Dict[str, Any]] = None,
-    device_type: str = "python",
-    hardware_interface: Optional[HardwareInterface] = None,
-):
-    """
-    设备类装饰器
-
-    将类标记为一个 UniLab-OS 设备，并附加注册表元数据。
-
-    支持两种模式:
-      1. 单设备: id="xxx", category=[...]
-      2. 多设备: ids=["id1","id2"], id_meta={"id1":{handles:[...]}, "id2":{...}}
-
-    Args:
-        id: 单设备时的注册表唯一标识
-        ids: 多设备时的 id 列表，与 id_meta 配合使用
-        id_meta: 每个 device_id 的覆盖元数据 (handles/description/icon/model)
-        category: 设备分类标签列表 (必填)
-        description: 设备描述
-        display_name: 人类可读的设备显示名称，缺失时默认使用 id
-        icon: 图标路径
-        version: 版本号
-        handles: 设备端口列表 (单设备或 id_meta 未覆盖时使用)
-        model: 可选的 3D 模型配置
-        device_type: 设备实现类型 ("python" / "ros2")
-        hardware_interface: 硬件通信接口 (HardwareInterface)
-    """
-    # Resolve device ids
-    if ids is not None:
-        device_ids = list(ids)
-        if not device_ids:
-            raise ValueError("@device ids 不能为空")
-        id_meta = id_meta or {}
-    elif id is not None:
-        device_ids = [id]
-        id_meta = {}
-    else:
-        raise ValueError("@device 必须提供 id 或 ids")
-
-    if category is None:
-        raise ValueError("@device category 必填")
-
-    base_meta = {
-        "category": category,
-        "description": description,
-        "display_name": display_name,
-        "icon": icon,
-        "version": version,
-        "handles": _device_handles_to_list(handles),
-        "model": model,
-        "device_type": device_type,
-        "hardware_interface": (hardware_interface.model_dump(exclude_none=True) if hardware_interface else None),
-    }
-
-    def decorator(cls):
-        cls._device_registry_meta = base_meta
-        cls._device_registry_id_meta = id_meta
-        cls._device_registry_ids = device_ids
-
-        for did in device_ids:
-            if did in _registered_devices:
-                raise ValueError(f"@device id 重复: '{did}' 已被 {_registered_devices[did]} 注册")
-            _registered_devices[did] = cls
-
-        return cls
-
-    return decorator
-
-
-# ---------------------------------------------------------------------------
-# @action 方法装饰器
-# ---------------------------------------------------------------------------
-
-# 区分 "用户没传 action_type" 和 "用户传了 None"
-_ACTION_TYPE_UNSET = object()
-
-
-# noinspection PyShadowingNames
-def action(
-    action_type: Any = _ACTION_TYPE_UNSET,
-    goal: Optional[Dict[str, str]] = None,
-    feedback: Optional[Dict[str, str]] = None,
-    result: Optional[Dict[str, str]] = None,
-    handles: Optional[List[_ActionHandleBase]] = None,
-    goal_default: Optional[Dict[str, Any]] = None,
-    placeholder_keys: Optional[Dict[str, str]] = None,
-    always_free: bool = False,
-    is_protocol: bool = False,
-    description: str = "",
-    auto_prefix: bool = False,
-    parent: bool = False,
-):
-    """
-    动作方法装饰器
-
-    标记方法为注册表动作。有三种用法:
-      1. @action(action_type=EmptyIn, ...)  -- 非 auto, 使用指定 ROS Action 类型
-      2. @action()                          -- 非 auto, UniLabJsonCommand (从方法签名生成 schema)
-      3. 不加 @action                       -- auto- 前缀, UniLabJsonCommand
-
-    Protocol 用法:
-      @action(action_type=Add, is_protocol=True)
-      def AddProtocol(self): ...
-      标记该动作为高级协议 (protocol)，运行时通过 ROS Action 路由到
-      protocol generator 执行。action_type 指向 unilabos_msgs 的 Action 类型。
-
-    Args:
-        action_type: ROS Action 消息类型 (如 EmptyIn, SendCmd, HeatChill).
-                     不传/默认 = UniLabJsonCommand (非 auto).
-        goal: Goal 字段映射 (ROS字段名 -> 设备参数名).
-              protocol 模式下可留空，系统自动生成 identity 映射.
-        feedback: Feedback 字段映射
-        result: Result 字段映射
-        handles: 动作端口列表 (ActionInputHandle / ActionOutputHandle)
-        goal_default: Goal 字段默认值映射 (字段名 -> 默认值), 与自动生成的 goal_default 合并
-        placeholder_keys: 参数占位符配置
-        always_free: 是否为永久闲置动作 (不受排队限制)
-        is_protocol: 是否为工作站协议 (protocol)。True 时运行时走 protocol generator 路径。
-        description: 动作描述
-        auto_prefix: 若为 True，动作名使用 auto-{method_name} 形式（与无 @action 时一致）
-        parent: 若为 True，当方法参数为空 (*args, **kwargs) 时，通过 MRO 从父类获取真实方法参数
-    """
-
-    def decorator(func: F) -> F:
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
-
-        # action_type 为哨兵值 => 用户没传, 视为 None (UniLabJsonCommand)
-        resolved_type = None if action_type is _ACTION_TYPE_UNSET else action_type
-
-        meta = {
-            "action_type": resolved_type,
-            "goal": goal or {},
-            "feedback": feedback or {},
-            "result": result or {},
-            "handles": _action_handles_to_dict(handles),
-            "goal_default": goal_default or {},
-            "placeholder_keys": placeholder_keys or {},
-            "always_free": always_free,
-            "is_protocol": is_protocol,
-            "description": description,
-            "auto_prefix": auto_prefix,
-            "parent": parent,
-        }
-        wrapper._action_registry_meta = meta  # type: ignore[attr-defined]
-
-        # 设置 _is_always_free 保持与旧 @always_free 装饰器兼容
-        if always_free:
-            wrapper._is_always_free = True  # type: ignore[attr-defined]
-
-        return wrapper  # type: ignore[return-value]
-
-    return decorator
-
-
-def get_action_meta(func) -> Optional[Dict[str, Any]]:
-    """获取方法上的 @action 装饰器元数据"""
-    return getattr(func, "_action_registry_meta", None)
-
-
-def has_action_decorator(func) -> bool:
-    """检查函数是否带有 @action 装饰器"""
-    return hasattr(func, "_action_registry_meta")
-
-
-# ---------------------------------------------------------------------------
-# @resource 类/函数装饰器
-# ---------------------------------------------------------------------------
-
-
-def resource(
-    id: str,
-    category: List[str],
-    description: str = "",
-    icon: str = "",
-    version: str = "1.0.0",
-    handles: Optional[List[_DeviceHandleBase]] = None,
-    model: Optional[Dict[str, Any]] = None,
-    class_type: str = "pylabrobot",
-):
-    """
-    资源类/函数装饰器
-
-    将类或工厂函数标记为一个 UniLab-OS 资源，附加注册表元数据。
-
-    Args:
-        id: 注册表唯一标识 (必填, 不可重复)
-        category: 资源分类标签列表 (必填)
-        description: 资源描述
-        icon: 图标路径
-        version: 版本号
-        handles: 端口列表 (InputHandle / OutputHandle)
-        model: 可选的 3D 模型配置
-        class_type: 资源实现类型 ("python" / "pylabrobot" / "unilabos")
-    """
-
-    def decorator(obj):
-        meta = {
-            "resource_id": id,
-            "category": category,
-            "description": description,
-            "icon": icon,
-            "version": version,
-            "handles": _device_handles_to_list(handles),
-            "model": model,
-            "class_type": class_type,
-        }
-        obj._resource_registry_meta = meta
-
-        if id in _registered_resources:
-            raise ValueError(f"@resource id 重复: '{id}' 已被 {_registered_resources[id]} 注册")
-        _registered_resources[id] = obj
-
-        return obj
-
-    return decorator
-
-
-def get_device_meta(cls, device_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
-    """
-    获取类上的 @device 装饰器元数据。
-
-    当 device_id 存在且类使用 ids+id_meta 时，返回合并后的 meta
-    (base_meta 与 id_meta[device_id] 深度合并)。
-    """
-    base = getattr(cls, "_device_registry_meta", None)
-    if base is None:
-        return None
-    id_meta = getattr(cls, "_device_registry_id_meta", None) or {}
-    if device_id is None or device_id not in id_meta:
-        result = dict(base)
-        ids = getattr(cls, "_device_registry_ids", None)
-        result["device_id"] = device_id if device_id is not None else (ids[0] if ids else None)
-        return result
-
-    overrides = id_meta[device_id]
-    result = dict(base)
-    result["device_id"] = device_id
-    for key in ["handles", "description", "icon", "model"]:
-        if key in overrides:
-            val = overrides[key]
-            if key == "handles" and isinstance(val, list):
-                # handles 必须是 Handle 对象列表
-                result[key] = [h.to_registry_dict() for h in val]
-            else:
-                result[key] = val
-    return result
-
-
-def get_resource_meta(obj) -> Optional[Dict[str, Any]]:
-    """获取对象上的 @resource 装饰器元数据"""
-    return getattr(obj, "_resource_registry_meta", None)
-
-
-def get_all_registered_devices() -> Dict[str, type]:
-    """获取所有已注册的设备类"""
-    return _registered_devices.copy()
-
-
-def get_all_registered_resources() -> Dict[str, Any]:
-    """获取所有已注册的资源"""
-    return _registered_resources.copy()
-
-
-def clear_registry():
-    """清空全局注册表 (用于测试)"""
-    _registered_devices.clear()
-    _registered_resources.clear()
-
-
-# ---------------------------------------------------------------------------
-# topic_config / not_action / always_free 装饰器
-# ---------------------------------------------------------------------------
-
-
-def topic_config(
-    period: Optional[float] = None,
-    print_publish: Optional[bool] = None,
-    qos: Optional[int] = None,
-    name: Optional[str] = None,
-) -> Callable[[F], F]:
-    """
-    Topic发布配置装饰器
-
-    用于装饰 get_{attr_name} 方法或 @property，控制对应属性的ROS topic发布行为。
-
-    Args:
-        period: 发布周期（秒）。None 表示使用默认值 5.0
-        print_publish: 是否打印发布日志。None 表示使用节点默认配置
-        qos: QoS深度配置。None 表示使用默认值 10
-        name: 自定义发布名称。None 表示使用方法名（去掉 get_ 前缀）
-
-    Note:
-        与 @property 连用时，@topic_config 必须放在 @property 下面，
-        这样装饰器执行顺序为：先 topic_config 添加配置，再 property 包装。
-    """
-
-    def decorator(func: F) -> F:
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
-
-        wrapper._topic_period = period  # type: ignore[attr-defined]
-        wrapper._topic_print_publish = print_publish  # type: ignore[attr-defined]
-        wrapper._topic_qos = qos  # type: ignore[attr-defined]
-        wrapper._topic_name = name  # type: ignore[attr-defined]
-        wrapper._has_topic_config = True  # type: ignore[attr-defined]
-
-        return wrapper  # type: ignore[return-value]
-
-    return decorator
-
-
-def get_topic_config(func) -> dict:
-    """获取函数上的 topic 配置 (period, print_publish, qos, name)"""
-    if hasattr(func, "_has_topic_config") and getattr(func, "_has_topic_config", False):
-        return {
-            "period": getattr(func, "_topic_period", None),
-            "print_publish": getattr(func, "_topic_print_publish", None),
-            "qos": getattr(func, "_topic_qos", None),
-            "name": getattr(func, "_topic_name", None),
-        }
-    return {}
-
-
-def always_free(func: F) -> F:
-    """
-    标记动作为永久闲置(不受busy队列限制)的装饰器
-
-    被此装饰器标记的 action 方法，在执行时不会受到设备级别的排队限制，
-    任何时候请求都可以立即执行。适用于查询类、状态读取类等轻量级操作。
-    """
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        return func(*args, **kwargs)
-
-    wrapper._is_always_free = True  # type: ignore[attr-defined]
-
-    return wrapper  # type: ignore[return-value]
-
-
-def is_always_free(func) -> bool:
-    """检查函数是否被标记为永久闲置"""
-    return getattr(func, "_is_always_free", False)
-
-
-def not_action(func: F) -> F:
-    """
-    标记方法为非动作的装饰器
-
-    用于装饰 driver 类中的方法，使其在注册表扫描时不被识别为动作。
-    适用于辅助方法、内部工具方法等不应暴露为设备动作的公共方法。
-    """
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        return func(*args, **kwargs)
-
-    wrapper._is_not_action = True  # type: ignore[attr-defined]
-
-    return wrapper  # type: ignore[return-value]
-
-
-def is_not_action(func) -> bool:
-    """检查函数是否被标记为非动作"""
-    return getattr(func, "_is_not_action", False)

unilabos/registry/devices/Qone_nmr.yaml

@@ -13,18 +13,21 @@ Qone_nmr:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -68,6 +71,31 @@ Qone_nmr:
           title: monitor_folder_for_new_content参数
           type: object
         type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: string
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       auto-strings_to_txt:
         feedback: {}
         goal: {}
@@ -110,18 +138,21 @@ Qone_nmr:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -136,31 +167,32 @@ Qone_nmr:
         goal_default:
           string: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 string:
                   type: string
+              required:
+              - string
               title: StrSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: StrSingleInput_Result
               type: object
           required:

unilabos/registry/devices/bioyond_cell.yaml

@@ -22,8 +22,7 @@ bioyond_cell:
               required:
               - xlsx_path
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: auto_batch_outbound_from_xlsx参数
@@ -491,9 +490,7 @@ bioyond_cell:
             goal:
               properties:
                 material_names:
-                  items:
-                    type: string
-                  type: array
+                  type: string
                 type_id:
                   default: 3a190ca0-b2f6-9aeb-8067-547e72c11469
                   type: string
@@ -502,8 +499,7 @@ bioyond_cell:
                   type: string
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: create_and_inbound_materials参数
@@ -539,8 +535,7 @@ bioyond_cell:
               - type_id
               - warehouse_name
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: create_material参数
@@ -561,16 +556,11 @@ bioyond_cell:
             goal:
               properties:
                 mappings:
-                  additionalProperties:
-                    type: object
                   type: object
               required:
               - mappings
               type: object
-            result:
-              items:
-                type: object
-              type: array
+            result: {}
           required:
           - goal
           title: create_materials参数
@@ -602,8 +592,7 @@ bioyond_cell:
               required:
               - xlsx_path
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: create_orders参数
@@ -635,8 +624,7 @@ bioyond_cell:
               required:
               - xlsx_path
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: create_orders_v2参数
@@ -677,8 +665,7 @@ bioyond_cell:
               - bottle_type
               - location_code
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: create_sample参数
@@ -731,8 +718,7 @@ bioyond_cell:
                   type: string
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: order_list_v2参数
@@ -835,8 +821,7 @@ bioyond_cell:
               required:
               - material_obj
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: report_material_change参数
@@ -890,8 +875,7 @@ bioyond_cell:
               properties: {}
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: scheduler_continue参数
@@ -912,8 +896,7 @@ bioyond_cell:
               properties: {}
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: scheduler_reset参数
@@ -934,8 +917,7 @@ bioyond_cell:
               properties: {}
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: scheduler_start参数
@@ -1380,8 +1362,7 @@ bioyond_cell:
                   type: string
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: scheduler_start_and_auto_feeding参数
@@ -1826,8 +1807,7 @@ bioyond_cell:
                   type: string
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: scheduler_start_and_auto_feeding_v2参数
@@ -1848,8 +1828,7 @@ bioyond_cell:
               properties: {}
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: scheduler_stop参数
@@ -1871,15 +1850,12 @@ bioyond_cell:
               properties:
                 items:
                   items:
-                    additionalProperties:
-                      type: string
                     type: object
                   type: array
               required:
               - items
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: storage_batch_inbound参数
@@ -1908,8 +1884,7 @@ bioyond_cell:
               - material_id
               - location_id
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: storage_inbound参数
@@ -1930,8 +1905,7 @@ bioyond_cell:
               properties: {}
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: transfer_1_to_2参数
@@ -1972,8 +1946,7 @@ bioyond_cell:
                   type: integer
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: transfer_3_to_2参数
@@ -2010,8 +1983,7 @@ bioyond_cell:
                   type: integer
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: transfer_3_to_2_to_1参数
@@ -2035,11 +2007,10 @@ bioyond_cell:
                 ip:
                   type: string
                 port:
-                  type: integer
+                  type: string
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: update_push_ip参数
@@ -2068,8 +2039,7 @@ bioyond_cell:
               required:
               - order_code
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: wait_for_order_finish参数
@@ -2102,8 +2072,7 @@ bioyond_cell:
               required:
               - order_code
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: wait_for_order_finish_polling参数
@@ -2135,8 +2104,7 @@ bioyond_cell:
                   type: integer
               required: []
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: wait_for_transfer_task参数
@@ -2144,7 +2112,8 @@ bioyond_cell:
         type: UniLabJsonCommand
     module: unilabos.devices.workstation.bioyond_studio.bioyond_cell.bioyond_cell_workstation:BioyondCellWorkstation
     status_types:
-      device_id: ''
+      device_id: String
+      material_info: dict
     type: python
   config_info: []
   description: ''
@@ -2165,7 +2134,11 @@ bioyond_cell:
       properties:
         device_id:
           type: string
+        material_info:
+          type: object
       required:
       - device_id
+      - material_info
       type: object
+  registry_type: device
   version: 1.0.0

unilabos/registry/devices/bioyond_dispensing_station.yaml

@@ -24,8 +24,7 @@ bioyond_dispensing_station:
               required:
               - data
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: brief_step_parameters参数
@@ -54,8 +53,7 @@ bioyond_dispensing_station:
               - report_request
               - used_materials
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: process_order_finish_report参数
@@ -80,8 +78,7 @@ bioyond_dispensing_station:
               required:
               - order_id
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: project_order_report参数
@@ -131,8 +128,7 @@ bioyond_dispensing_station:
               required:
               - workflow_id
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: workflow_sample_locations参数
@@ -148,12 +144,12 @@ bioyond_dispensing_station:
           temperature: temperature
           titration: titration
         goal_default:
-          delay_time: null
-          hold_m_name: null
+          delay_time: '600'
+          hold_m_name: ''
           liquid_material_name: NMP
-          speed: null
-          temperature: null
-          titration: null
+          speed: '400'
+          temperature: '40'
+          titration: ''
         handles:
           input:
           - data_key: titration
@@ -169,16 +165,20 @@ bioyond_dispensing_station:
             handler_key: BATCH_CREATE_RESULT
             io_type: sink
             label: Complete Batch Create Result JSON (contains order_codes and order_ids)
-        placeholder_keys: {}
-        result: {}
+        result:
+          return_info: return_info
         schema:
           description: 批量创建90%10%小瓶投料任务。从计算节点接收titration数据,包含物料名称、主称固体质量、滴定固体质量和滴定溶剂体积。返回的return_info中包含order_codes和order_ids列表。
           properties:
             feedback:
+              properties: {}
+              required: []
               title: BatchCreate9010VialFeedingTasks_Feedback
+              type: object
             goal:
               properties:
                 delay_time:
+                  default: '600'
                   description: 延迟时间(秒),默认600
                   type: string
                 hold_m_name:
@@ -189,9 +189,11 @@ bioyond_dispensing_station:
                   description: 10%物料的液体物料名称,默认为"NMP"
                   type: string
                 speed:
+                  default: '400'
                   description: 搅拌速度,默认400
                   type: string
                 temperature:
+                  default: '40'
                   description: 温度(℃),默认40
                   type: string
                 titration:
@@ -200,14 +202,21 @@ bioyond_dispensing_station:
                   type: string
               required:
               - titration
+              - hold_m_name
               title: BatchCreate9010VialFeedingTasks_Goal
               type: object
             result:
+              properties:
+                return_info:
+                  description: 批量任务创建结果汇总JSON字符串，包含total(总数)、success(成功数)、failed(失败数)、order_codes(任务编码数组)、order_ids(任务ID数组)、details(每个任务的详细信息)
+                  type: string
+              required:
+              - return_info
               title: BatchCreate9010VialFeedingTasks_Result
-              type: string
+              type: object
           required:
           - goal
-          title: batch_create_90_10_vial_feeding_tasks参数
+          title: BatchCreate9010VialFeedingTasks
           type: object
         type: UniLabJsonCommand
       batch_create_diamine_solution_tasks:
@@ -219,11 +228,11 @@ bioyond_dispensing_station:
           speed: speed
           temperature: temperature
         goal_default:
-          delay_time: null
+          delay_time: '600'
           liquid_material_name: NMP
-          solutions: null
-          speed: null
-          temperature: null
+          solutions: ''
+          speed: '400'
+          temperature: '20'
         handles:
           input:
           - data_key: solutions
@@ -239,16 +248,20 @@ bioyond_dispensing_station:
             handler_key: BATCH_CREATE_RESULT
             io_type: sink
             label: Complete Batch Create Result JSON (contains order_codes and order_ids)
-        placeholder_keys: {}
-        result: {}
+        result:
+          return_info: return_info
         schema:
           description: 批量创建二胺溶液配置任务。自动为多个二胺样品创建溶液配置任务，每个任务包含固体物料称量、溶剂添加、搅拌混合等步骤。返回的return_info中包含order_codes和order_ids列表。
           properties:
             feedback:
+              properties: {}
+              required: []
               title: BatchCreateDiamineSolutionTasks_Feedback
+              type: object
             goal:
               properties:
                 delay_time:
+                  default: '600'
                   description: 溶液配置完成后的延迟时间（秒），用于充分混合和溶解，默认600秒
                   type: string
                 liquid_material_name:
@@ -262,9 +275,11 @@ bioyond_dispensing_station:
                     4.5, "solvent_volume": 18}]'
                   type: string
                 speed:
+                  default: '400'
                   description: 搅拌速度（rpm），用于混合溶液，默认400转/分钟
                   type: string
                 temperature:
+                  default: '20'
                   description: 配置温度（℃），溶液配置过程的目标温度，默认20℃（室温）
                   type: string
               required:
@@ -272,11 +287,17 @@ bioyond_dispensing_station:
               title: BatchCreateDiamineSolutionTasks_Goal
               type: object
             result:
+              properties:
+                return_info:
+                  description: 批量任务创建结果汇总JSON字符串，包含total(总数)、success(成功数)、failed(失败数)、order_codes(任务编码数组)、order_ids(任务ID数组)、details(每个任务的详细信息)
+                  type: string
+              required:
+              - return_info
               title: BatchCreateDiamineSolutionTasks_Result
-              type: string
+              type: object
           required:
           - goal
-          title: batch_create_diamine_solution_tasks参数
+          title: BatchCreateDiamineSolutionTasks
           type: object
         type: UniLabJsonCommand
       compute_experiment_design:
@@ -288,7 +309,7 @@ bioyond_dispensing_station:
           wt_percent: wt_percent
         goal_default:
           m_tot: '70'
-          ratio: null
+          ratio: ''
           titration_percent: '0.03'
           wt_percent: '0.25'
         handles:
@@ -317,8 +338,12 @@ bioyond_dispensing_station:
             handler_key: feeding_order
             io_type: sink
             label: Feeding Order Data From Calculation Node
-        placeholder_keys: {}
-        result: {}
+        result:
+          feeding_order: feeding_order
+          return_info: return_info
+          solutions: solutions
+          solvents: solvents
+          titration: titration
         schema:
           description: 计算实验设计，输出solutions/titration/solvents/feeding_order用于后续节点。
           properties:
@@ -331,7 +356,7 @@ bioyond_dispensing_station:
                   type: string
                 ratio:
                   description: 组分摩尔比的对象，保持输入顺序，如{"MDA":1,"BTDA":1}
-                  type: object
+                  type: string
                 titration_percent:
                   default: '0.03'
                   description: 滴定比例(10%部分)
@@ -346,23 +371,14 @@ bioyond_dispensing_station:
             result:
               properties:
                 feeding_order:
-                  items: {}
-                  title: Feeding Order
                   type: array
                 return_info:
-                  title: Return Info
                   type: string
                 solutions:
-                  items: {}
-                  title: Solutions
                   type: array
                 solvents:
-                  additionalProperties: true
-                  title: Solvents
                   type: object
                 titration:
-                  additionalProperties: true
-                  title: Titration
                   type: object
               required:
               - solutions
@@ -370,11 +386,11 @@ bioyond_dispensing_station:
               - solvents
               - feeding_order
               - return_info
-              title: ComputeExperimentDesignReturn
+              title: ComputeExperimentDesign_Result
               type: object
           required:
           - goal
-          title: compute_experiment_design参数
+          title: ComputeExperimentDesign
           type: object
         type: UniLabJsonCommand
       create_90_10_vial_feeding_task:
@@ -428,18 +444,17 @@ bioyond_dispensing_station:
           speed: ''
           temperature: ''
         handles: {}
-        placeholder_keys: {}
         result:
           return_info: return_info
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: DispenStationVialFeed_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 delay_time:
                   type: string
@@ -487,13 +502,38 @@ bioyond_dispensing_station:
                   type: string
                 temperature:
                   type: string
+              required:
+              - order_name
+              - percent_90_1_assign_material_name
+              - percent_90_1_target_weigh
+              - percent_90_2_assign_material_name
+              - percent_90_2_target_weigh
+              - percent_90_3_assign_material_name
+              - percent_90_3_target_weigh
+              - percent_10_1_assign_material_name
+              - percent_10_1_target_weigh
+              - percent_10_1_volume
+              - percent_10_1_liquid_material_name
+              - percent_10_2_assign_material_name
+              - percent_10_2_target_weigh
+              - percent_10_2_volume
+              - percent_10_2_liquid_material_name
+              - percent_10_3_assign_material_name
+              - percent_10_3_target_weigh
+              - percent_10_3_volume
+              - percent_10_3_liquid_material_name
+              - speed
+              - temperature
+              - delay_time
+              - hold_m_name
               title: DispenStationVialFeed_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: DispenStationVialFeed_Result
               type: object
           required:
@@ -524,18 +564,17 @@ bioyond_dispensing_station:
           temperature: ''
           volume: ''
         handles: {}
-        placeholder_keys: {}
         result:
           return_info: return_info
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: DispenStationSolnPrep_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 delay_time:
                   type: string
@@ -555,13 +594,24 @@ bioyond_dispensing_station:
                   type: string
                 volume:
                   type: string
+              required:
+              - order_name
+              - material_name
+              - target_weigh
+              - volume
+              - liquid_material_name
+              - speed
+              - temperature
+              - delay_time
+              - hold_m_name
               title: DispenStationSolnPrep_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: DispenStationSolnPrep_Result
               type: object
           required:
@@ -574,8 +624,8 @@ bioyond_dispensing_station:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result: {}
+        result:
+          return_info: return_info
         schema:
           description: 启动调度器 - 启动Bioyond配液站的任务调度器，开始执行队列中的任务
           properties:
@@ -585,6 +635,12 @@ bioyond_dispensing_station:
               required: []
               type: object
             result:
+              properties:
+                return_info:
+                  description: 调度器启动结果，成功返回1，失败返回0
+                  type: integer
+              required:
+              - return_info
               title: scheduler_start结果
               type: object
           required:
@@ -598,8 +654,8 @@ bioyond_dispensing_station:
           target_device_id: target_device_id
           transfer_groups: transfer_groups
         goal_default:
-          target_device_id: null
-          transfer_groups: null
+          target_device_id: ''
+          transfer_groups: ''
         handles: {}
         placeholder_keys:
           target_device_id: unilabos_devices
@@ -615,13 +671,32 @@ bioyond_dispensing_station:
                   type: string
                 transfer_groups:
                   description: 转移任务组列表，每组包含物料名称、目标堆栈和目标库位，可以添加多组
+                  items:
+                    properties:
+                      materials:
+                        description: 物料名称（手动输入，系统将通过RPC查询验证）
+                        type: string
+                      target_sites:
+                        description: 目标库位（手动输入，如"A01"）
+                        type: string
+                      target_stack:
+                        description: 目标堆栈名称（从列表选择）
+                        enum:
+                        - 堆栈1左
+                        - 堆栈1右
+                        - 站内试剂存放堆栈
+                        type: string
+                    required:
+                    - materials
+                    - target_stack
+                    - target_sites
+                    type: object
                   type: array
               required:
               - target_device_id
               - transfer_groups
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: transfer_materials_to_reaction_station参数
@@ -634,9 +709,9 @@ bioyond_dispensing_station:
           check_interval: check_interval
           timeout: timeout
         goal_default:
-          batch_create_result: null
-          check_interval: 10
-          timeout: 7200
+          batch_create_result: ''
+          check_interval: '10'
+          timeout: '7200'
         handles:
           input:
           - data_key: batch_create_result
@@ -652,35 +727,47 @@ bioyond_dispensing_station:
             handler_key: batch_reports_result
             io_type: sink
             label: Batch Order Completion Reports
-        placeholder_keys: {}
-        result: {}
+        result:
+          return_info: return_info
         schema:
           description: 同时等待多个任务完成并获取所有实验报告。从上游batch_create任务接收包含order_codes和order_ids的结果对象，并行监控所有任务状态并返回每个任务的报告。
           properties:
             feedback:
+              properties: {}
+              required: []
               title: WaitForMultipleOrdersAndGetReports_Feedback
+              type: object
             goal:
               properties:
                 batch_create_result:
                   description: 批量创建任务的返回结果对象，包含order_codes和order_ids数组。从上游batch_create节点通过handle传递
                   type: string
                 check_interval:
-                  default: 10
+                  default: '10'
                   description: 检查任务状态的时间间隔（秒），默认每10秒检查一次所有待完成任务
-                  type: integer
+                  type: string
                 timeout:
-                  default: 7200
+                  default: '7200'
                   description: 等待超时时间（秒），默认7200秒（2小时）。超过此时间未完成的任务将标记为timeout
-                  type: integer
-              required: []
+                  type: string
+              required:
+              - batch_create_result
               title: WaitForMultipleOrdersAndGetReports_Goal
               type: object
             result:
+              properties:
+                return_info:
+                  description: 'JSON格式的批量任务完成信息，包含: total(总数), completed(成功数), timeout(超时数),
+                    error(错误数), elapsed_time(总耗时), reports(报告数组，每个元素包含order_code,
+                    order_id, status, completion_status, report, elapsed_time)'
+                  type: string
+              required:
+              - return_info
               title: WaitForMultipleOrdersAndGetReports_Result
               type: object
           required:
           - goal
-          title: wait_for_multiple_orders_and_get_reports参数
+          title: WaitForMultipleOrdersAndGetReports
           type: object
         type: UniLabJsonCommand
     module: unilabos.devices.workstation.bioyond_studio.dispensing_station.dispensing_station:BioyondDispensingStation

unilabos/registry/devices/camera.yaml

@@ -0,0 +1,81 @@
+camera:
+  category:
+  - camera
+  class:
+    action_value_mappings:
+      auto-destroy_node:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 用于安全地关闭摄像头设备，释放摄像头资源，停止视频采集和发布服务。调用此函数将清理OpenCV摄像头连接并销毁ROS2节点。
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: destroy_node参数
+          type: object
+        type: UniLabJsonCommand
+      auto-timer_callback:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 定时器回调函数的参数schema。此函数负责定期采集摄像头视频帧，将OpenCV格式的图像转换为ROS Image消息格式，并发布到指定的视频话题。默认以10Hz频率执行，确保视频流的连续性和实时性。
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: timer_callback参数
+          type: object
+        type: UniLabJsonCommand
+    module: unilabos.ros.nodes.presets.camera:VideoPublisher
+    status_types: {}
+    type: ros2
+  config_info: []
+  description: VideoPublisher摄像头设备节点，用于实时视频采集和流媒体发布。该设备通过OpenCV连接本地摄像头（如USB摄像头、内置摄像头等），定时采集视频帧并将其转换为ROS2的sensor_msgs/Image消息格式发布到视频话题。主要用于实验室自动化系统中的视觉监控、图像分析、实时观察等应用场景。支持可配置的摄像头索引、发布频率等参数。
+  handles: []
+  icon: ''
+  init_param_schema:
+    config:
+      properties:
+        camera_index:
+          default: 0
+          type: string
+        device_id:
+          default: video_publisher
+          type: string
+        device_uuid:
+          default: ''
+          type: string
+        period:
+          default: 0.1
+          type: number
+        registry_name:
+          default: ''
+          type: string
+        resource_tracker:
+          type: object
+      required: []
+      type: object
+    data:
+      properties: {}
+      required: []
+      type: object
+  version: 1.0.0

unilabos/registry/devices/cameraSII.yaml

@@ -18,7 +18,7 @@ cameracontroller_device:
             goal:
               properties:
                 config:
-                  type: object
+                  type: string
               required: []
               type: object
             result: {}
@@ -42,8 +42,7 @@ cameracontroller_device:
               properties: {}
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: stop参数
@@ -51,7 +50,7 @@ cameracontroller_device:
         type: UniLabJsonCommand
     module: unilabos.devices.cameraSII.cameraUSB:CameraController
     status_types:
-      status: Dict[str, Any]
+      status: dict
     type: python
   config_info: []
   description: Uni-Lab-OS 摄像头驱动（Linux USB 摄像头版，无 PTZ）
@@ -104,4 +103,5 @@ cameracontroller_device:
       required:
       - status
       type: object
+  registry_type: device
   version: 1.0.0

unilabos/registry/devices/characterization_chromatic.yaml

@@ -141,26 +141,30 @@ hplc.agilent:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -171,6 +175,7 @@ hplc.agilent:
     module: unilabos.devices.hplc.AgilentHPLC:HPLCDriver
     status_types:
       could_run: bool
+      data_file: String
       device_status: str
       driver_init_ok: bool
       finish_status: str
@@ -194,6 +199,10 @@ hplc.agilent:
       properties:
         could_run:
           type: boolean
+        data_file:
+          items:
+            type: string
+          type: array
         device_status:
           type: string
         driver_init_ok:
@@ -207,13 +216,14 @@ hplc.agilent:
         success:
           type: boolean
       required:
-      - could_run
-      - device_status
-      - driver_init_ok
-      - finish_status
-      - is_running
       - status_text
+      - device_status
+      - could_run
+      - driver_init_ok
+      - is_running
       - success
+      - finish_status
+      - data_file
       type: object
   version: 1.0.0
 hplc.agilent-zhida:
@@ -226,25 +236,26 @@ hplc.agilent-zhida:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -304,18 +315,21 @@ hplc.agilent-zhida:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -327,35 +341,35 @@ hplc.agilent-zhida:
         feedback: {}
         goal:
           string: string
-          text: text
         goal_default:
           string: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 string:
                   type: string
+              required:
+              - string
               title: StrSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: StrSingleInput_Result
               type: object
           required:
@@ -393,7 +407,7 @@ hplc.agilent-zhida:
         status:
           type: object
       required:
-      - methods
       - status
+      - methods
       type: object
   version: 1.0.0

unilabos/registry/devices/characterization_optic.yaml

@@ -120,41 +120,42 @@ raman.home_made:
           type: object
         type: UniLabJsonCommand
       raman_cmd:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:

unilabos/registry/devices/chinwe.yaml

@@ -19,8 +19,7 @@ separator.chinwe:
               properties: {}
               required: []
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: connect参数
@@ -66,145 +65,135 @@ separator.chinwe:
               required:
               - command_dict
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: execute_command_from_outer参数
           type: object
         type: UniLabJsonCommand
       motor_rotate_quarter:
-        feedback: {}
         goal:
           direction: 顺时针
           motor_id: 4
           speed: 60
-        goal_default:
-          direction: 顺时针
-          motor_id: null
-          speed: 60
         handles: {}
-        placeholder_keys: {}
-        result: {}
         schema:
           description: 电机旋转 1/4 圈
           properties:
-            feedback: {}
             goal:
               properties:
                 direction:
                   default: 顺时针
                   description: 旋转方向
+                  enum:
+                  - 顺时针
+                  - 逆时针
                   type: string
                 motor_id:
+                  default: '4'
                   description: 选择电机 (4:搅拌, 5:旋钮)
-                  type: integer
+                  enum:
+                  - '4'
+                  - '5'
+                  type: string
                 speed:
                   default: 60
                   description: 速度 (RPM)
                   type: integer
               required:
               - motor_id
+              - speed
               type: object
-            result: {}
-          required:
-          - goal
-          title: motor_rotate_quarter参数
-          type: object
         type: UniLabJsonCommand
       motor_run_continuous:
-        feedback: {}
         goal:
           direction: 顺时针
           motor_id: 4
           speed: 60
-        goal_default:
-          direction: 顺时针
-          motor_id: null
-          speed: null
         handles: {}
-        placeholder_keys: {}
-        result: {}
         schema:
           description: 电机一直旋转 (速度模式)
           properties:
-            feedback: {}
             goal:
               properties:
                 direction:
                   default: 顺时针
                   description: 旋转方向
+                  enum:
+                  - 顺时针
+                  - 逆时针
                   type: string
                 motor_id:
+                  default: '4'
                   description: 选择电机 (4:搅拌, 5:旋钮)
-                  type: integer
+                  enum:
+                  - '4'
+                  - '5'
+                  type: string
                 speed:
+                  default: 60
                   description: 速度 (RPM)
                   type: integer
               required:
               - motor_id
               - speed
               type: object
-            result: {}
-          required:
-          - goal
-          title: motor_run_continuous参数
-          type: object
         type: UniLabJsonCommand
       motor_stop:
-        feedback: {}
         goal:
           motor_id: 4
-        goal_default:
-          motor_id: null
         handles: {}
-        placeholder_keys: {}
-        result: {}
         schema:
           description: 停止指定步进电机
           properties:
-            feedback: {}
             goal:
               properties:
                 motor_id:
+                  default: '4'
                   description: 选择电机
+                  enum:
+                  - '4'
+                  - '5'
                   title: '注: 4=搅拌, 5=旋钮'
-                  type: integer
+                  type: string
               required:
               - motor_id
               type: object
-            result: {}
-          required:
-          - goal
-          title: motor_stop参数
-          type: object
         type: UniLabJsonCommand
       pump_aspirate:
-        feedback: {}
         goal:
           pump_id: 1
           valve_port: 1
           volume: 1000
-        goal_default:
-          pump_id: null
-          valve_port: null
-          volume: null
         handles: {}
-        placeholder_keys: {}
-        result: {}
         schema:
           description: 注射泵吸液
           properties:
-            feedback: {}
             goal:
               properties:
                 pump_id:
+                  default: '1'
                   description: 选择泵
-                  type: integer
+                  enum:
+                  - '1'
+                  - '2'
+                  - '3'
+                  type: string
                 valve_port:
+                  default: '1'
                   description: 阀门端口
-                  type: integer
+                  enum:
+                  - '1'
+                  - '2'
+                  - '3'
+                  - '4'
+                  - '5'
+                  - '6'
+                  - '7'
+                  - '8'
+                  type: string
                 volume:
+                  default: 1000
                   description: 吸液步数
                   type: integer
               required:
@@ -212,38 +201,41 @@ separator.chinwe:
               - volume
               - valve_port
               type: object
-            result: {}
-          required:
-          - goal
-          title: pump_aspirate参数
-          type: object
         type: UniLabJsonCommand
       pump_dispense:
-        feedback: {}
         goal:
           pump_id: 1
           valve_port: 1
           volume: 1000
-        goal_default:
-          pump_id: null
-          valve_port: null
-          volume: null
         handles: {}
-        placeholder_keys: {}
-        result: {}
         schema:
           description: 注射泵排液
           properties:
-            feedback: {}
             goal:
               properties:
                 pump_id:
+                  default: '1'
                   description: 选择泵
-                  type: integer
+                  enum:
+                  - '1'
+                  - '2'
+                  - '3'
+                  type: string
                 valve_port:
+                  default: '1'
                   description: 阀门端口
-                  type: integer
+                  enum:
+                  - '1'
+                  - '2'
+                  - '3'
+                  - '4'
+                  - '5'
+                  - '6'
+                  - '7'
+                  - '8'
+                  type: string
                 volume:
+                  default: 1000
                   description: 排液步数
                   type: integer
               required:
@@ -251,152 +243,121 @@ separator.chinwe:
               - volume
               - valve_port
               type: object
-            result: {}
-          required:
-          - goal
-          title: pump_dispense参数
-          type: object
         type: UniLabJsonCommand
       pump_initialize:
-        feedback: {}
         goal:
           drain_port: 0
           output_port: 0
           pump_id: 1
           speed: 10
-        goal_default:
-          drain_port: 0
-          output_port: 0
-          pump_id: null
-          speed: 10
         handles: {}
-        placeholder_keys: {}
-        result: {}
         schema:
           description: 初始化指定注射泵
           properties:
-            feedback: {}
             goal:
               properties:
                 drain_port:
                   default: 0
                   description: 排液口索引
-                  type: string
+                  type: integer
                 output_port:
                   default: 0
                   description: 输出口索引
-                  type: string
-                pump_id:
-                  description: 选择泵
-                  title: '注: 1号泵, 2号泵, 3号泵'
                   type: integer
+                pump_id:
+                  default: '1'
+                  description: 选择泵
+                  enum:
+                  - '1'
+                  - '2'
+                  - '3'
+                  title: '注: 1号泵, 2号泵, 3号泵'
+                  type: string
                 speed:
                   default: 10
                   description: 运动速度
-                  type: string
+                  type: integer
               required:
               - pump_id
               type: object
-            result: {}
-          required:
-          - goal
-          title: pump_initialize参数
-          type: object
         type: UniLabJsonCommand
       pump_valve:
-        feedback: {}
         goal:
           port: 1
           pump_id: 1
-        goal_default:
-          port: null
-          pump_id: null
         handles: {}
-        placeholder_keys: {}
-        result: {}
         schema:
           description: 切换指定泵的阀门端口
           properties:
-            feedback: {}
             goal:
               properties:
                 port:
+                  default: '1'
                   description: 阀门端口号 (1-8)
-                  type: integer
+                  enum:
+                  - '1'
+                  - '2'
+                  - '3'
+                  - '4'
+                  - '5'
+                  - '6'
+                  - '7'
+                  - '8'
+                  type: string
                 pump_id:
+                  default: '1'
                   description: 选择泵
-                  type: integer
+                  enum:
+                  - '1'
+                  - '2'
+                  - '3'
+                  type: string
               required:
               - pump_id
               - port
               type: object
-            result: {}
-          required:
-          - goal
-          title: pump_valve参数
-          type: object
         type: UniLabJsonCommand
       wait_sensor_level:
-        feedback: {}
         goal:
           target_state: 有液
           timeout: 30
-        goal_default:
-          target_state: 有液
-          timeout: 30
         handles: {}
-        placeholder_keys: {}
-        result: {}
         schema:
           description: 等待传感器液位条件
           properties:
-            feedback: {}
             goal:
               properties:
                 target_state:
                   default: 有液
                   description: 目标液位状态
+                  enum:
+                  - 有液
+                  - 无液
                   type: string
                 timeout:
                   default: 30
                   description: 超时时间 (秒)
                   type: integer
-              required: []
+              required:
+              - target_state
               type: object
-            result:
-              type: boolean
-          required:
-          - goal
-          title: wait_sensor_level参数
-          type: object
         type: UniLabJsonCommand
       wait_time:
-        feedback: {}
         goal:
           duration: 10
-        goal_default:
-          duration: null
         handles: {}
-        placeholder_keys: {}
-        result: {}
         schema:
           description: 等待指定时间
           properties:
-            feedback: {}
             goal:
               properties:
                 duration:
+                  default: 10
                   description: 等待时间 (秒)
                   type: integer
               required:
               - duration
               type: object
-            result:
-              type: boolean
-          required:
-          - goal
-          title: wait_time参数
-          type: object
         type: UniLabJsonCommand
     module: unilabos.devices.separator.chinwe:ChinweDevice
     status_types:
@@ -445,8 +406,8 @@ separator.chinwe:
         sensor_rssi:
           type: integer
       required:
-      - is_connected
       - sensor_level
       - sensor_rssi
+      - is_connected
       type: object
   version: 2.1.0

unilabos/registry/devices/coin_cell_workstation.yaml

@@ -64,8 +64,7 @@ coincellassemblyworkstation_device:
               properties: {}
               required: []
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: fun_wuliao_test参数
@@ -110,8 +109,7 @@ coincellassemblyworkstation_device:
               - elec_num
               - elec_use_num
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: func_allpack_cmd参数
@@ -222,8 +220,7 @@ coincellassemblyworkstation_device:
               - elec_num
               - elec_use_num
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: func_allpack_cmd_simp参数
@@ -312,8 +309,7 @@ coincellassemblyworkstation_device:
                   type: boolean
               required: []
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: func_pack_device_init_auto_start_combined参数
@@ -355,8 +351,7 @@ coincellassemblyworkstation_device:
               properties: {}
               required: []
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: func_pack_device_stop参数
@@ -381,8 +376,7 @@ coincellassemblyworkstation_device:
                   type: string
               required: []
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: func_pack_get_msg_cmd参数
@@ -436,8 +430,7 @@ coincellassemblyworkstation_device:
               properties: {}
               required: []
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: func_pack_send_finished_cmd参数
@@ -474,8 +467,7 @@ coincellassemblyworkstation_device:
               - assembly_type
               - assembly_pressure
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: func_pack_send_msg_cmd参数
@@ -619,8 +611,7 @@ coincellassemblyworkstation_device:
               - elec_num
               - elec_use_num
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: func_sendbottle_allpack_multi参数
@@ -672,6 +663,31 @@ coincellassemblyworkstation_device:
           title: modify_deck_name参数
           type: object
         type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       auto-qiming_coin_cell_code:
         feedback: {}
         goal: {}
@@ -719,8 +735,7 @@ coincellassemblyworkstation_device:
               required:
               - fujipian_panshu
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: qiming_coin_cell_code参数
@@ -811,24 +826,25 @@ coincellassemblyworkstation_device:
         sys_status:
           type: string
       required:
+      - sys_status
+      - sys_mode
+      - request_rec_msg_status
+      - request_send_msg_status
       - data_assembly_coin_cell_num
-      - data_assembly_pressure
       - data_assembly_time
+      - data_open_circuit_voltage
       - data_axis_x_pos
       - data_axis_y_pos
       - data_axis_z_pos
-      - data_coin_cell_code
-      - data_coin_num
-      - data_electrolyte_code
-      - data_electrolyte_volume
-      - data_glove_box_o2_content
-      - data_glove_box_pressure
-      - data_glove_box_water_content
-      - data_open_circuit_voltage
       - data_pole_weight
-      - request_rec_msg_status
-      - request_send_msg_status
-      - sys_mode
-      - sys_status
+      - data_assembly_pressure
+      - data_electrolyte_volume
+      - data_coin_num
+      - data_coin_cell_code
+      - data_electrolyte_code
+      - data_glove_box_pressure
+      - data_glove_box_o2_content
+      - data_glove_box_water_content
       type: object
+  registry_type: device
   version: 1.0.0

unilabos/registry/devices/gas_handler.yaml

@@ -50,25 +50,26 @@ gas_source.mock:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -81,25 +82,26 @@ gas_source.mock:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -114,31 +116,32 @@ gas_source.mock:
         goal_default:
           string: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 string:
                   type: string
+              required:
+              - string
               title: StrSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: StrSingleInput_Result
               type: object
           required:
@@ -229,25 +232,26 @@ vacuum_pump.mock:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -260,25 +264,26 @@ vacuum_pump.mock:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -293,31 +298,32 @@ vacuum_pump.mock:
         goal_default:
           string: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 string:
                   type: string
+              required:
+              - string
               title: StrSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: StrSingleInput_Result
               type: object
           required:

unilabos/registry/devices/hotel.yaml

@@ -5,7 +5,7 @@ hotel.thermo_orbitor_rs2_hotel:
     action_value_mappings: {}
     module: unilabos.devices.resource_container.container:HotelContainer
     status_types:
-      rotation: ''
+      rotation: String
     type: python
   config_info: []
   description: Thermo Orbitor RS2 Hotel容器设备，用于实验室样品的存储和管理。该设备通过HotelContainer类实现容器的旋转控制和状态监控，主要用于存储实验样品、试剂瓶或其他实验器具，支持旋转功能以便于样品的自动化存取。适用于需要有序存储和快速访问大量样品的实验室自动化场景。

unilabos/registry/devices/laiyu_liquid_test.yaml

@@ -22,8 +22,7 @@ xyz_stepper_controller:
               required:
               - degrees
               type: object
-            result:
-              type: integer
+            result: {}
           required:
           - goal
           title: degrees_to_steps参数
@@ -48,8 +47,7 @@ xyz_stepper_controller:
               required:
               - axis
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: emergency_stop参数
@@ -74,10 +72,7 @@ xyz_stepper_controller:
                   type: boolean
               required: []
               type: object
-            result:
-              additionalProperties:
-                type: boolean
-              type: object
+            result: {}
           required:
           - goal
           title: enable_all_axes参数
@@ -106,8 +101,7 @@ xyz_stepper_controller:
               required:
               - axis
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: enable_motor参数
@@ -128,10 +122,7 @@ xyz_stepper_controller:
               properties: {}
               required: []
               type: object
-            result:
-              additionalProperties:
-                type: boolean
-              type: object
+            result: {}
           required:
           - goal
           title: home_all_axes参数
@@ -156,8 +147,7 @@ xyz_stepper_controller:
               required:
               - axis
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: home_axis参数
@@ -198,8 +188,7 @@ xyz_stepper_controller:
               - axis
               - position
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: move_to_position参数
@@ -240,8 +229,7 @@ xyz_stepper_controller:
               - axis
               - degrees
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: move_to_position_degrees参数
@@ -282,8 +270,7 @@ xyz_stepper_controller:
               - axis
               - revolutions
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: move_to_position_revolutions参数
@@ -314,17 +301,14 @@ xyz_stepper_controller:
                   default: 5000
                   type: integer
                 x:
-                  type: integer
+                  type: string
                 y:
-                  type: integer
+                  type: string
                 z:
-                  type: integer
+                  type: string
               required: []
               type: object
-            result:
-              additionalProperties:
-                type: boolean
-              type: object
+            result: {}
           required:
           - goal
           title: move_xyz参数
@@ -355,17 +339,14 @@ xyz_stepper_controller:
                   default: 5000
                   type: integer
                 x_deg:
-                  type: number
+                  type: string
                 y_deg:
-                  type: number
+                  type: string
                 z_deg:
-                  type: number
+                  type: string
               required: []
               type: object
-            result:
-              additionalProperties:
-                type: boolean
-              type: object
+            result: {}
           required:
           - goal
           title: move_xyz_degrees参数
@@ -396,17 +377,14 @@ xyz_stepper_controller:
                   default: 5000
                   type: integer
                 x_rev:
-                  type: number
+                  type: string
                 y_rev:
-                  type: number
+                  type: string
                 z_rev:
-                  type: number
+                  type: string
               required: []
               type: object
-            result:
-              additionalProperties:
-                type: boolean
-              type: object
+            result: {}
           required:
           - goal
           title: move_xyz_revolutions参数
@@ -431,8 +409,7 @@ xyz_stepper_controller:
               required:
               - revolutions
               type: object
-            result:
-              type: integer
+            result: {}
           required:
           - goal
           title: revolutions_to_steps参数
@@ -465,8 +442,7 @@ xyz_stepper_controller:
               - axis
               - speed
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: set_speed_mode参数
@@ -491,8 +467,7 @@ xyz_stepper_controller:
               required:
               - steps
               type: object
-            result:
-              type: number
+            result: {}
           required:
           - goal
           title: steps_to_degrees参数
@@ -517,8 +492,7 @@ xyz_stepper_controller:
               required:
               - steps
               type: object
-            result:
-              type: number
+            result: {}
           required:
           - goal
           title: steps_to_revolutions参数
@@ -539,10 +513,7 @@ xyz_stepper_controller:
               properties: {}
               required: []
               type: object
-            result:
-              additionalProperties:
-                type: boolean
-              type: object
+            result: {}
           required:
           - goal
           title: stop_all_axes参数
@@ -571,8 +542,7 @@ xyz_stepper_controller:
               required:
               - axis
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: wait_for_completion参数
@@ -580,7 +550,8 @@ xyz_stepper_controller:
         type: UniLabJsonCommand
     module: unilabos.devices.liquid_handling.laiyu.drivers.xyz_stepper_driver:XYZStepperController
     status_types:
-      all_positions: Dict[MotorAxis, MotorPosition]
+      all_positions: dict
+      motor_status: unilabos.devices.liquid_handling.laiyu.drivers.xyz_stepper_driver:MotorPosition
     type: python
   config_info: []
   description: 新XYZ控制器
@@ -603,10 +574,12 @@ xyz_stepper_controller:
     data:
       properties:
         all_positions:
-          additionalProperties:
-            type: object
+          type: object
+        motor_status:
           type: object
       required:
+      - motor_status
       - all_positions
       type: object
+  registry_type: device
   version: 1.0.0

unilabos/registry/devices/neware_battery_test_system.yaml

@@ -5,6 +5,31 @@ neware_battery_test_system:
   - battery_test
   class:
     action_value_mappings:
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: string
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       auto-print_status_summary:
         feedback: {}
         goal: {}
@@ -41,8 +66,7 @@ neware_battery_test_system:
               properties: {}
               required: []
               type: object
-            result:
-              type: boolean
+            result: {}
           required:
           - goal
           title: test_connection参数
@@ -53,8 +77,9 @@ neware_battery_test_system:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result: {}
+        result:
+          return_info: return_info
+          success: success
         schema:
           description: 调试方法：显示所有资源的实际名称
           properties:
@@ -64,10 +89,19 @@ neware_battery_test_system:
               required: []
               type: object
             result:
+              properties:
+                return_info:
+                  description: 资源调试信息
+                  type: string
+                success:
+                  description: 是否成功
+                  type: boolean
+              required:
+              - return_info
+              - success
               type: object
           required:
           - goal
-          title: debug_resource_names参数
           type: object
         type: UniLabJsonCommand
       export_status_json:
@@ -77,8 +111,9 @@ neware_battery_test_system:
         goal_default:
           filepath: bts_status.json
         handles: {}
-        placeholder_keys: {}
-        result: {}
+        result:
+          return_info: return_info
+          success: success
         schema:
           description: 导出当前状态数据到JSON文件
           properties:
@@ -92,10 +127,19 @@ neware_battery_test_system:
               required: []
               type: object
             result:
+              properties:
+                return_info:
+                  description: 导出操作结果信息
+                  type: string
+                success:
+                  description: 导出是否成功
+                  type: boolean
+              required:
+              - return_info
+              - success
               type: object
           required:
           - goal
-          title: export_status_json参数
           type: object
         type: UniLabJsonCommand
       get_device_summary:
@@ -137,8 +181,10 @@ neware_battery_test_system:
         goal_default:
           plate_num: null
         handles: {}
-        placeholder_keys: {}
-        result: {}
+        result:
+          plate_data: plate_data
+          return_info: return_info
+          success: success
         schema:
           description: 获取指定盘或所有盘的状态信息
           properties:
@@ -147,14 +193,29 @@ neware_battery_test_system:
               properties:
                 plate_num:
                   description: 盘号 (1 或 2)，如果为null则返回所有盘的状态
+                  maximum: 2
+                  minimum: 1
                   type: integer
               required: []
               type: object
             result:
+              properties:
+                plate_data:
+                  description: 盘状态数据（单盘或所有盘）
+                  type: object
+                return_info:
+                  description: 操作结果信息
+                  type: string
+                success:
+                  description: 查询是否成功
+                  type: boolean
+              required:
+              - return_info
+              - success
+              - plate_data
               type: object
           required:
           - goal
-          title: get_plate_status参数
           type: object
         type: UniLabJsonCommand
       print_status_summary_action:
@@ -162,8 +223,9 @@ neware_battery_test_system:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result: {}
+        result:
+          return_info: return_info
+          success: success
         schema:
           description: 打印通道状态摘要信息到控制台
           properties:
@@ -173,21 +235,28 @@ neware_battery_test_system:
               required: []
               type: object
             result:
+              properties:
+                return_info:
+                  description: 打印操作结果信息
+                  type: string
+                success:
+                  description: 打印是否成功
+                  type: boolean
+              required:
+              - return_info
+              - success
               type: object
           required:
           - goal
-          title: print_status_summary_action参数
           type: object
         type: UniLabJsonCommand
       query_plate_action:
         feedback: {}
         goal:
-          plate_id: plate_id
-          string: string
+          string: plate_id
         goal_default:
           string: ''
         handles: {}
-        placeholder_keys: {}
         result:
           return_info: return_info
           success: success
@@ -195,23 +264,27 @@ neware_battery_test_system:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 string:
                   type: string
+              required:
+              - string
               title: StrSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: StrSingleInput_Result
               type: object
           required:
@@ -225,11 +298,13 @@ neware_battery_test_system:
           csv_path: string
           output_dir: string
         goal_default:
-          csv_path: null
+          csv_path: ''
           output_dir: .
         handles: {}
-        placeholder_keys: {}
-        result: {}
+        result:
+          return_info: return_info
+          submitted_count: submitted_count
+          success: success
         schema:
           description: 从CSV文件批量提交Neware测试任务
           properties:
@@ -240,17 +315,31 @@ neware_battery_test_system:
                   description: 输入CSV文件的绝对路径
                   type: string
                 output_dir:
-                  default: .
                   description: 输出目录（用于存储XML和备份文件），默认当前目录
                   type: string
               required:
               - csv_path
               type: object
             result:
+              properties:
+                return_info:
+                  description: 执行结果详细信息
+                  type: string
+                submitted_count:
+                  description: 成功提交的任务数量
+                  type: integer
+                success:
+                  description: 是否成功
+                  type: boolean
+                total_count:
+                  description: CSV文件中的总行数
+                  type: integer
+              required:
+              - return_info
+              - success
               type: object
           required:
           - goal
-          title: submit_from_csv参数
           type: object
         type: UniLabJsonCommand
       test_connection_action:
@@ -258,8 +347,9 @@ neware_battery_test_system:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result: {}
+        result:
+          return_info: return_info
+          success: success
         schema:
           description: 测试与电池测试系统的TCP连接
           properties:
@@ -269,10 +359,19 @@ neware_battery_test_system:
               required: []
               type: object
             result:
+              properties:
+                return_info:
+                  description: 连接测试结果信息
+                  type: string
+                success:
+                  description: 连接测试是否成功
+                  type: boolean
+              required:
+              - return_info
+              - success
               type: object
           required:
           - goal
-          title: test_connection_action参数
           type: object
         type: UniLabJsonCommand
       upload_backup_to_oss:
@@ -293,8 +392,12 @@ neware_battery_test_system:
             handler_key: uploaded_files
             io_type: sink
             label: Uploaded Files (with standard flow info)
-        placeholder_keys: {}
-        result: {}
+        result:
+          failed_files: failed_files
+          return_info: return_info
+          success: success
+          total_count: total_count
+          uploaded_count: uploaded_count
         schema:
           description: 上传备份文件到阿里云OSS
           properties:
@@ -314,17 +417,65 @@ neware_battery_test_system:
               required: []
               type: object
             result:
+              properties:
+                failed_files:
+                  description: 上传失败的文件名列表
+                  items:
+                    type: string
+                  type: array
+                return_info:
+                  description: 上传操作结果信息
+                  type: string
+                success:
+                  description: 上传是否成功
+                  type: boolean
+                total_count:
+                  description: 总文件数
+                  type: integer
+                uploaded_count:
+                  description: 成功上传的文件数
+                  type: integer
+                uploaded_files:
+                  description: 成功上传的文件详情列表
+                  items:
+                    properties:
+                      Battery_Code:
+                        description: 电池编码
+                        type: string
+                      Electrolyte_Code:
+                        description: 电解液编码
+                        type: string
+                      filename:
+                        description: 文件名
+                        type: string
+                      url:
+                        description: OSS下载链接
+                        type: string
+                    required:
+                    - filename
+                    - url
+                    - Battery_Code
+                    - Electrolyte_Code
+                    type: object
+                  type: array
+              required:
+              - return_info
+              - success
+              - uploaded_count
+              - total_count
+              - failed_files
+              - uploaded_files
               type: object
           required:
           - goal
-          title: upload_backup_to_oss参数
           type: object
         type: UniLabJsonCommand
     module: unilabos.devices.neware_battery_test_system.neware_battery_test_system:NewareBatteryTestSystem
     status_types:
-      channel_status: Dict[int, Dict]
-      connection_info: Dict[str, str]
+      channel_status: dict
+      connection_info: dict
       device_summary: dict
+      plate_status: dict
       status: str
       total_channels: int
     type: python
@@ -366,24 +517,23 @@ neware_battery_test_system:
     data:
       properties:
         channel_status:
-          additionalProperties:
-            type: object
           type: object
         connection_info:
-          additionalProperties:
-            type: string
           type: object
         device_summary:
           type: object
+        plate_status:
+          type: object
         status:
           type: string
         total_channels:
           type: integer
       required:
+      - status
       - channel_status
       - connection_info
-      - device_summary
-      - status
       - total_channels
+      - plate_status
+      - device_summary
       type: object
   version: 1.0.0

unilabos/registry/devices/opcua_example.yaml

@@ -142,7 +142,8 @@ opcua_example:
           type: object
         type: UniLabJsonCommand
     module: unilabos.device_comms.opcua_client.client:OpcUaClient
-    status_types: {}
+    status_types:
+      node_value: String
     type: python
   config_info: []
   description: null
@@ -166,7 +167,10 @@ opcua_example:
       - url
       type: object
     data:
-      properties: {}
-      required: []
+      properties:
+        node_value:
+          type: string
+      required:
+      - node_value
       type: object
   version: 1.0.0

unilabos/registry/devices/opsky_ATR30007.yaml

@@ -80,8 +80,7 @@ opsky_ATR30007:
                   type: string
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: run_once参数

unilabos/registry/devices/organic_miscellaneous.yaml

@@ -100,41 +100,42 @@ rotavap.one:
           type: object
         type: UniLabJsonCommand
       set_timer:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -249,13 +250,9 @@ separator.homemade:
         feedback:
           status: status
         goal:
-          event: event
           settling_time: settling_time
           stir_speed: stir_speed
-          stir_time: stir_time
-          time: time
-          time_spec: time_spec
-          vessel: vessel
+          stir_time: stir_time,
         goal_default:
           event: ''
           settling_time: ''
@@ -284,42 +281,34 @@ separator.homemade:
             sample_id: ''
             type: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          message: message
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: Stir_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 event:
                   type: string
                 settling_time:
                   type: string
                 stir_speed:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 stir_time:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 time:
                   type: string
                 time_spec:
                   type: string
                 vessel:
-                  additionalProperties: false
                   properties:
                     category:
                       type: string
@@ -338,26 +327,16 @@ separator.homemade:
                     parent:
                       type: string
                     pose:
-                      additionalProperties: false
                       properties:
                         orientation:
-                          additionalProperties: false
                           properties:
                             w:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             x:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             y:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             z:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                           required:
                           - x
@@ -367,19 +346,12 @@ separator.homemade:
                           title: orientation
                           type: object
                         position:
-                          additionalProperties: false
                           properties:
                             x:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             y:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             z:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                           required:
                           - x
@@ -409,10 +381,17 @@ separator.homemade:
                   - data
                   title: vessel
                   type: object
+              required:
+              - vessel
+              - time
+              - event
+              - time_spec
+              - stir_time
+              - stir_speed
+              - settling_time
               title: Stir_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 message:
                   type: string
@@ -420,6 +399,10 @@ separator.homemade:
                   type: string
                 success:
                   type: boolean
+              required:
+              - success
+              - message
+              - return_info
               title: Stir_Result
               type: object
           required:
@@ -435,34 +418,36 @@ separator.homemade:
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:

unilabos/registry/devices/post_process_station.yaml

@@ -28,6 +28,31 @@ post_process_station:
           title: load_config参数
           type: object
         type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: string
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       auto-print_cache_stats:
         feedback: {}
         goal: {}
@@ -79,41 +104,42 @@ post_process_station:
           type: object
         type: UniLabJsonCommand
       disconnect:
-        feedback:
-          status: status
+        feedback: {}
         goal:
-          command: command
+          command: {}
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -123,41 +149,42 @@ post_process_station:
         type: SendCmd
       read_node:
         feedback:
-          status: status
+          result: result
         goal:
-          command: command
-          node_name: node_name
+          command: node_name
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -256,19 +283,17 @@ post_process_station:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: PostProcessTriggerClean_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 acetone_inner_wall_cleaning_count:
                   maximum: 2147483647
                   minimum: -2147483648
                   type: integer
                 acetone_inner_wall_cleaning_injection:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 acetone_inner_wall_cleaning_waste_time:
                   maximum: 2147483647
@@ -279,8 +304,6 @@ post_process_station:
                   minimum: -2147483648
                   type: integer
                 acetone_outer_wall_cleaning_injection:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 acetone_outer_wall_cleaning_wait_time:
                   maximum: 2147483647
@@ -299,8 +322,6 @@ post_process_station:
                   minimum: -2147483648
                   type: integer
                 acetone_stirrer_cleaning_injection:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 acetone_stirrer_cleaning_wait_time:
                   maximum: 2147483647
@@ -327,8 +348,6 @@ post_process_station:
                   minimum: -2147483648
                   type: integer
                 nmp_inner_wall_cleaning_injection:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 nmp_inner_wall_cleaning_waste_time:
                   maximum: 2147483647
@@ -339,8 +358,6 @@ post_process_station:
                   minimum: -2147483648
                   type: integer
                 nmp_outer_wall_cleaning_injection:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 nmp_outer_wall_cleaning_wait_time:
                   maximum: 2147483647
@@ -359,8 +376,6 @@ post_process_station:
                   minimum: -2147483648
                   type: integer
                 nmp_stirrer_cleaning_injection:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 nmp_stirrer_cleaning_wait_time:
                   maximum: 2147483647
@@ -379,8 +394,6 @@ post_process_station:
                   minimum: -2147483648
                   type: integer
                 water_inner_wall_cleaning_injection:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 water_inner_wall_cleaning_waste_time:
                   maximum: 2147483647
@@ -391,8 +404,6 @@ post_process_station:
                   minimum: -2147483648
                   type: integer
                 water_outer_wall_cleaning_injection:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 water_outer_wall_cleaning_wait_time:
                   maximum: 2147483647
@@ -411,8 +422,6 @@ post_process_station:
                   minimum: -2147483648
                   type: integer
                 water_stirrer_cleaning_injection:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 water_stirrer_cleaning_wait_time:
                   maximum: 2147483647
@@ -422,13 +431,55 @@ post_process_station:
                   maximum: 2147483647
                   minimum: -2147483648
                   type: integer
+              required:
+              - nmp_outer_wall_cleaning_injection
+              - nmp_outer_wall_cleaning_count
+              - nmp_outer_wall_cleaning_wait_time
+              - nmp_outer_wall_cleaning_waste_time
+              - nmp_inner_wall_cleaning_injection
+              - nmp_inner_wall_cleaning_count
+              - nmp_pump_cleaning_suction_count
+              - nmp_inner_wall_cleaning_waste_time
+              - nmp_stirrer_cleaning_injection
+              - nmp_stirrer_cleaning_count
+              - nmp_stirrer_cleaning_wait_time
+              - nmp_stirrer_cleaning_waste_time
+              - water_outer_wall_cleaning_injection
+              - water_outer_wall_cleaning_count
+              - water_outer_wall_cleaning_wait_time
+              - water_outer_wall_cleaning_waste_time
+              - water_inner_wall_cleaning_injection
+              - water_inner_wall_cleaning_count
+              - water_pump_cleaning_suction_count
+              - water_inner_wall_cleaning_waste_time
+              - water_stirrer_cleaning_injection
+              - water_stirrer_cleaning_count
+              - water_stirrer_cleaning_wait_time
+              - water_stirrer_cleaning_waste_time
+              - acetone_outer_wall_cleaning_injection
+              - acetone_outer_wall_cleaning_count
+              - acetone_outer_wall_cleaning_wait_time
+              - acetone_outer_wall_cleaning_waste_time
+              - acetone_inner_wall_cleaning_injection
+              - acetone_inner_wall_cleaning_count
+              - acetone_pump_cleaning_suction_count
+              - acetone_inner_wall_cleaning_waste_time
+              - acetone_stirrer_cleaning_injection
+              - acetone_stirrer_cleaning_count
+              - acetone_stirrer_cleaning_wait_time
+              - acetone_stirrer_cleaning_waste_time
+              - pipe_blowing_time
+              - injection_pump_forward_empty_suction_count
+              - injection_pump_reverse_empty_suction_count
+              - filtration_liquid_selection
               title: PostProcessTriggerClean_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: PostProcessTriggerClean_Result
               type: object
           required:
@@ -451,11 +502,11 @@ post_process_station:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: PostProcessGrab_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 raw_tank_number:
                   maximum: 2147483647
@@ -465,13 +516,17 @@ post_process_station:
                   maximum: 2147483647
                   minimum: -2147483648
                   type: integer
+              required:
+              - reaction_tank_number
+              - raw_tank_number
               title: PostProcessGrab_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: PostProcessGrab_Result
               type: object
           required:
@@ -518,15 +573,13 @@ post_process_station:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: PostProcessTriggerPostPro_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 atomization_fast_speed:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 atomization_pressure_kpa:
                   maximum: 2147483647
@@ -541,12 +594,8 @@ post_process_station:
                   minimum: -2147483648
                   type: integer
                 first_wash_water_amount:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 initial_water_amount:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 injection_pump_push_speed:
                   maximum: 2147483647
@@ -573,20 +622,32 @@ post_process_station:
                   minimum: -2147483648
                   type: integer
                 second_wash_water_amount:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 wash_slow_speed:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
+              required:
+              - atomization_fast_speed
+              - wash_slow_speed
+              - injection_pump_suction_speed
+              - injection_pump_push_speed
+              - raw_liquid_suction_count
+              - first_wash_water_amount
+              - second_wash_water_amount
+              - first_powder_mixing_tim
+              - second_powder_mixing_time
+              - first_powder_wash_count
+              - second_powder_wash_count
+              - initial_water_amount
+              - pre_filtration_mixing_time
+              - atomization_pressure_kpa
               title: PostProcessTriggerPostPro_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: PostProcessTriggerPostPro_Result
               type: object
           required:
@@ -608,26 +669,30 @@ post_process_station:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -637,7 +702,8 @@ post_process_station:
         type: SendCmd
     module: unilabos.devices.workstation.post_process.post_process:OpcUaClient
     status_types:
-      cache_stats: Dict[str, Any]
+      cache_stats: dict
+      node_value: String
     type: python
   config_info: []
   description: 后处理站
@@ -652,9 +718,7 @@ post_process_station:
         config_path:
           type: string
         deck:
-          anyOf:
-          - type: object
-          - type: object
+          type: string
         password:
           type: string
         subscription_interval:
@@ -674,7 +738,10 @@ post_process_station:
       properties:
         cache_stats:
           type: object
+        node_value:
+          type: string
       required:
+      - node_value
       - cache_stats
       type: object
   version: 1.0.0

unilabos/registry/devices/pump_and_valve.yaml

@@ -136,36 +136,36 @@ solenoid_valve:
       set_valve_position:
         feedback: {}
         goal:
-          position: position
-          string: string
+          string: position
         goal_default:
           string: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 string:
                   type: string
+              required:
+              - string
               title: StrSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: StrSingleInput_Result
               type: object
           required:
@@ -278,25 +278,26 @@ solenoid_valve.mock:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -309,25 +310,26 @@ solenoid_valve.mock:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -420,27 +422,6 @@ syringe_pump_with_valve.runze.SY03B-T06:
           title: initialize参数
           type: object
         type: UniLabJsonCommand
-      auto-list:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: list的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: list参数
-          type: object
-        type: UniLabJsonCommand
       auto-pull_plunger:
         feedback: {}
         goal: {}
@@ -714,10 +695,7 @@ syringe_pump_with_valve.runze.SY03B-T06:
             goal:
               properties:
                 position:
-                  anyOf:
-                  - type: integer
-                  - type: string
-                  - type: number
+                  type: string
               required:
               - position
               type: object
@@ -742,9 +720,7 @@ syringe_pump_with_valve.runze.SY03B-T06:
             goal:
               properties:
                 velocity:
-                  anyOf:
-                  - type: integer
-                  - type: string
+                  type: string
               required:
               - velocity
               type: object
@@ -804,13 +780,13 @@ syringe_pump_with_valve.runze.SY03B-T06:
     status_types:
       max_velocity: float
       mode: int
-      plunger_position: ''
+      plunger_position: String
       position: float
       status: str
       valve_position: str
-      velocity_end: ''
-      velocity_grade: ''
-      velocity_init: ''
+      velocity_end: String
+      velocity_grade: String
+      velocity_init: String
     type: python
   config_info: []
   description: 润泽精密注射泵设备，集成阀门控制的高精度流体输送系统。该设备通过串口通信控制，支持多种运行模式和精确的体积控制。具备可变速度控制、精密定位、阀门切换、实时状态监控等功能。适用于微量液体输送、精密进样、流速控制、化学反应进料等需要高精度流体操作的实验室自动化应用。
@@ -909,15 +885,15 @@ syringe_pump_with_valve.runze.SY03B-T06:
         velocity_init:
           type: string
       required:
-      - max_velocity
-      - mode
-      - plunger_position
-      - position
       - status
-      - valve_position
-      - velocity_end
+      - mode
+      - max_velocity
       - velocity_grade
       - velocity_init
+      - velocity_end
+      - valve_position
+      - position
+      - plunger_position
       type: object
   version: 1.0.0
 syringe_pump_with_valve.runze.SY03B-T08:
@@ -967,27 +943,6 @@ syringe_pump_with_valve.runze.SY03B-T08:
           title: initialize参数
           type: object
         type: UniLabJsonCommand
-      auto-list:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: list的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: list参数
-          type: object
-        type: UniLabJsonCommand
       auto-pull_plunger:
         feedback: {}
         goal: {}
@@ -1261,10 +1216,7 @@ syringe_pump_with_valve.runze.SY03B-T08:
             goal:
               properties:
                 position:
-                  anyOf:
-                  - type: integer
-                  - type: string
-                  - type: number
+                  type: string
               required:
               - position
               type: object
@@ -1289,9 +1241,7 @@ syringe_pump_with_valve.runze.SY03B-T08:
             goal:
               properties:
                 velocity:
-                  anyOf:
-                  - type: integer
-                  - type: string
+                  type: string
               required:
               - velocity
               type: object
@@ -1351,13 +1301,13 @@ syringe_pump_with_valve.runze.SY03B-T08:
     status_types:
       max_velocity: float
       mode: int
-      plunger_position: ''
+      plunger_position: String
       position: float
       status: str
       valve_position: str
-      velocity_end: ''
-      velocity_grade: ''
-      velocity_init: ''
+      velocity_end: String
+      velocity_grade: String
+      velocity_init: String
     type: python
   config_info: []
   description: 润泽精密注射泵设备，集成阀门控制的高精度流体输送系统。该设备通过串口通信控制，支持多种运行模式和精确的体积控制。具备可变速度控制、精密定位、阀门切换、实时状态监控等功能。适用于微量液体输送、精密进样、流速控制、化学反应进料等需要高精度流体操作的实验室自动化应用。
@@ -1472,14 +1422,14 @@ syringe_pump_with_valve.runze.SY03B-T08:
         velocity_init:
           type: string
       required:
-      - max_velocity
-      - mode
-      - plunger_position
-      - position
       - status
-      - valve_position
-      - velocity_end
+      - mode
+      - max_velocity
       - velocity_grade
       - velocity_init
+      - velocity_end
+      - valve_position
+      - position
+      - plunger_position
       type: object
   version: 1.0.0

unilabos/registry/devices/reaction_station_bioyond.yaml

@@ -13,13 +13,12 @@ reaction_station.bioyond:
           start_point: start_point
           start_step_key: start_step_key
         goal_default:
-          duration: null
+          duration: 0
           end_point: 0
           end_step_key: ''
           start_point: 0
           start_step_key: ''
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 添加时间约束 - 在两个工作流之间添加时间约束
@@ -31,19 +30,23 @@ reaction_station.bioyond:
                   description: 时间(秒)
                   type: integer
                 end_point:
-                  default: 0
+                  default: Start
                   description: 终点计时点 (Start=开始前, End=结束后)
-                  type: integer
+                  enum:
+                  - Start
+                  - End
+                  type: string
                 end_step_key:
-                  default: ''
                   description: 终点步骤Key (可选, 默认为空则自动选择)
                   type: string
                 start_point:
-                  default: 0
+                  default: Start
                   description: 起点计时点 (Start=开始前, End=结束后)
-                  type: integer
+                  enum:
+                  - Start
+                  - End
+                  type: string
                 start_step_key:
-                  default: ''
                   description: 起点步骤Key (例如 "feeding", "liquid", 可选, 默认为空则自动选择)
                   type: string
               required:
@@ -95,8 +98,7 @@ reaction_station.bioyond:
               required:
               - json_str
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: create_order参数
@@ -123,8 +125,7 @@ reaction_station.bioyond:
               required:
               - workflow_ids
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: hard_delete_merged_workflows参数
@@ -149,8 +150,7 @@ reaction_station.bioyond:
               required:
               - json_str
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: merge_workflow_with_parameters参数
@@ -175,8 +175,7 @@ reaction_station.bioyond:
               required:
               - report_request
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: process_temperature_cutoff_report参数
@@ -201,12 +200,7 @@ reaction_station.bioyond:
               required:
               - web_workflow_json
               type: object
-            result:
-              items:
-                additionalProperties:
-                  type: string
-                type: object
-              type: array
+            result: {}
           required:
           - goal
           title: process_web_workflows参数
@@ -235,8 +229,7 @@ reaction_station.bioyond:
               - reactor_id
               - temperature
               type: object
-            result:
-              type: string
+            result: {}
           required:
           - goal
           title: set_reactor_temperature参数
@@ -261,8 +254,7 @@ reaction_station.bioyond:
               required:
               - preintake_id
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: skip_titration_steps参数
@@ -283,8 +275,7 @@ reaction_station.bioyond:
               properties: {}
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: sync_workflow_sequence_from_bioyond参数
@@ -316,8 +307,7 @@ reaction_station.bioyond:
                   type: integer
               required: []
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: wait_for_multiple_orders_and_get_reports参数
@@ -369,8 +359,7 @@ reaction_station.bioyond:
               required:
               - workflow_id
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: workflow_step_query参数
@@ -381,8 +370,9 @@ reaction_station.bioyond:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result: {}
+        result:
+          code: code
+          message: message
         schema:
           description: 清空服务端所有非核心工作流 (保留核心流程)
           properties:
@@ -392,6 +382,13 @@ reaction_station.bioyond:
               required: []
               type: object
             result:
+              properties:
+                code:
+                  description: 操作结果代码(1表示成功)
+                  type: integer
+                message:
+                  description: 结果描述
+                  type: string
               type: object
           required:
           - goal
@@ -408,14 +405,13 @@ reaction_station.bioyond:
           torque_variation: torque_variation
           volume: volume
         goal_default:
-          assign_material_name: null
-          temperature: 25.0
-          time: '90'
-          titration_type: '1'
-          torque_variation: 2
-          volume: null
+          assign_material_name: ''
+          temperature: ''
+          time: ''
+          titration_type: ''
+          torque_variation: ''
+          volume: ''
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 滴回去
@@ -427,27 +423,33 @@ reaction_station.bioyond:
                   description: 物料名称（不能为空）
                   type: string
                 temperature:
-                  default: 25.0
                   description: 温度设定(°C)
-                  type: number
+                  type: string
                 time:
-                  default: '90'
                   description: 观察时间(分钟)
                   type: string
                 titration_type:
-                  default: '1'
                   description: 是否滴定(NO=否, YES=是)
+                  enum:
+                  - 'NO'
+                  - 'YES'
                   type: string
                 torque_variation:
-                  default: 2
                   description: 是否观察 (NO=否, YES=是)
-                  type: integer
+                  enum:
+                  - 'NO'
+                  - 'YES'
+                  type: string
                 volume:
                   description: 分液公式(mL)
                   type: string
               required:
-              - assign_material_name
               - volume
+              - assign_material_name
+              - time
+              - torque_variation
+              - titration_type
+              - temperature
               type: object
             result: {}
           required:
@@ -460,7 +462,7 @@ reaction_station.bioyond:
         goal:
           batch_reports_result: batch_reports_result
         goal_default:
-          batch_reports_result: null
+          batch_reports_result: ''
         handles:
           input:
           - data_key: batch_reports_result
@@ -476,8 +478,8 @@ reaction_station.bioyond:
             handler_key: ACTUALS_EXTRACTED
             io_type: sink
             label: Extracted Actuals
-        placeholder_keys: {}
-        result: {}
+        result:
+          return_info: return_info
         schema:
           description: 从批量任务完成报告中提取每个订单的实际加料量，输出extracted列表。
           properties:
@@ -491,6 +493,13 @@ reaction_station.bioyond:
               - batch_reports_result
               type: object
             result:
+              properties:
+                return_info:
+                  description: JSON字符串，包含actuals数组，每项含order_code, order_id, actualTargetWeigh,
+                    actualVolume
+                  type: string
+              required:
+              - return_info
               title: extract_actuals_from_batch_reports结果
               type: object
           required:
@@ -508,14 +517,13 @@ reaction_station.bioyond:
           torque_variation: torque_variation
           volume: volume
         goal_default:
-          assign_material_name: BAPP
-          temperature: 25.0
-          time: '0'
-          titration_type: '1'
-          torque_variation: 1
-          volume: '350'
+          assign_material_name: ''
+          temperature: ''
+          time: ''
+          titration_type: ''
+          torque_variation: ''
+          volume: ''
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 液体进料烧杯
@@ -524,30 +532,36 @@ reaction_station.bioyond:
             goal:
               properties:
                 assign_material_name:
-                  default: BAPP
                   description: 物料名称
                   type: string
                 temperature:
-                  default: 25.0
                   description: 温度设定(°C)
-                  type: number
+                  type: string
                 time:
-                  default: '0'
                   description: 观察时间(分钟)
                   type: string
                 titration_type:
-                  default: '1'
                   description: 是否滴定(NO=否, YES=是)
+                  enum:
+                  - 'NO'
+                  - 'YES'
                   type: string
                 torque_variation:
-                  default: 1
                   description: 是否观察 (NO=否, YES=是)
-                  type: integer
+                  enum:
+                  - 'NO'
+                  - 'YES'
+                  type: string
                 volume:
-                  default: '350'
                   description: 分液公式(mL)
                   type: string
-              required: []
+              required:
+              - volume
+              - assign_material_name
+              - time
+              - torque_variation
+              - titration_type
+              - temperature
               type: object
             result: {}
           required:
@@ -566,13 +580,13 @@ reaction_station.bioyond:
           torque_variation: torque_variation
           volume: volume
         goal_default:
-          assign_material_name: null
-          solvents: null
-          temperature: 25.0
+          assign_material_name: ''
+          solvents: ''
+          temperature: '25.00'
           time: '360'
           titration_type: '1'
-          torque_variation: 2
-          volume: null
+          torque_variation: '2'
+          volume: ''
         handles:
           input:
           - data_key: solvents
@@ -581,7 +595,6 @@ reaction_station.bioyond:
             handler_key: solvents
             io_type: source
             label: Solvents Data From Calculation Node
-        placeholder_keys: {}
         result: {}
         schema:
           description: 液体投料-溶剂。可以直接提供volume(mL),或通过solvents对象自动从additional_solvent(mL)计算volume。
@@ -596,21 +609,27 @@ reaction_station.bioyond:
                   description: '溶剂信息对象(可选),包含: additional_solvent(溶剂体积mL), total_liquid_volume(总液体体积mL)。如果提供,将自动计算volume'
                   type: string
                 temperature:
-                  default: 25.0
+                  default: '25.00'
                   description: 温度设定(°C),默认25.00
-                  type: number
+                  type: string
                 time:
                   default: '360'
                   description: 观察时间(分钟),默认360
                   type: string
                 titration_type:
-                  default: '1'
+                  default: 'NO'
                   description: 是否滴定(NO=否, YES=是),默认NO
+                  enum:
+                  - 'NO'
+                  - 'YES'
                   type: string
                 torque_variation:
-                  default: 2
+                  default: 'YES'
                   description: 是否观察 (NO=否, YES=是),默认YES
-                  type: integer
+                  enum:
+                  - 'NO'
+                  - 'YES'
+                  type: string
                 volume:
                   description: 分液量(mL)。可直接提供,或通过solvents参数自动计算
                   type: string
@@ -636,15 +655,15 @@ reaction_station.bioyond:
           volume_formula: volume_formula
           x_value: x_value
         goal_default:
-          assign_material_name: null
-          extracted_actuals: null
-          feeding_order_data: null
-          temperature: 25.0
+          assign_material_name: ''
+          extracted_actuals: ''
+          feeding_order_data: ''
+          temperature: '25.00'
           time: '90'
           titration_type: '2'
-          torque_variation: 2
-          volume_formula: null
-          x_value: null
+          torque_variation: '2'
+          volume_formula: ''
+          x_value: ''
         handles:
           input:
           - data_key: extracted_actuals
@@ -659,7 +678,6 @@ reaction_station.bioyond:
             handler_key: feeding_order
             io_type: source
             label: Feeding Order Data From Calculation Node
-        placeholder_keys: {}
         result: {}
         schema:
           description: 液体进料(滴定)。支持两种模式:1)直接提供volume_formula;2)自动计算-提供x_value+feeding_order_data+extracted_actuals,系统自动生成公式"1000*(m二酐-x)*V二酐滴定/m二酐滴定"
@@ -678,21 +696,27 @@ reaction_station.bioyond:
                     {"feeding_order": [{"type": "main_anhydride", "amount": 1.915}]}'
                   type: string
                 temperature:
-                  default: 25.0
+                  default: '25.00'
                   description: 温度设定(°C),默认25.00
-                  type: number
+                  type: string
                 time:
                   default: '90'
                   description: 观察时间(分钟),默认90
                   type: string
                 titration_type:
-                  default: '2'
+                  default: 'YES'
                   description: 是否滴定(NO=否, YES=是),默认YES
+                  enum:
+                  - 'NO'
+                  - 'YES'
                   type: string
                 torque_variation:
-                  default: 2
+                  default: 'YES'
                   description: 是否观察 (NO=否, YES=是),默认YES
-                  type: integer
+                  enum:
+                  - 'NO'
+                  - 'YES'
+                  type: string
                 volume_formula:
                   description: 分液公式(mL)。可直接提供固定公式,或留空由系统根据x_value、feeding_order_data、extracted_actuals自动生成
                   type: string
@@ -718,14 +742,13 @@ reaction_station.bioyond:
           torque_variation: torque_variation
           volume_formula: volume_formula
         goal_default:
-          assign_material_name: null
-          temperature: 25.0
-          time: '0'
-          titration_type: '1'
-          torque_variation: 1
-          volume_formula: null
+          assign_material_name: ''
+          temperature: ''
+          time: ''
+          titration_type: ''
+          torque_variation: ''
+          volume_formula: ''
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 液体进料小瓶(非滴定)
@@ -737,27 +760,33 @@ reaction_station.bioyond:
                   description: 物料名称
                   type: string
                 temperature:
-                  default: 25.0
                   description: 温度设定(°C)
-                  type: number
+                  type: string
                 time:
-                  default: '0'
                   description: 观察时间(分钟)
                   type: string
                 titration_type:
-                  default: '1'
                   description: 是否滴定(NO=否, YES=是)
+                  enum:
+                  - 'NO'
+                  - 'YES'
                   type: string
                 torque_variation:
-                  default: 1
                   description: 是否观察 (NO=否, YES=是)
-                  type: integer
+                  enum:
+                  - 'NO'
+                  - 'YES'
+                  type: string
                 volume_formula:
                   description: 分液公式(mL)
                   type: string
               required:
               - volume_formula
               - assign_material_name
+              - time
+              - torque_variation
+              - titration_type
+              - temperature
               type: object
             result: {}
           required:
@@ -771,10 +800,9 @@ reaction_station.bioyond:
           task_name: task_name
           workflow_name: workflow_name
         goal_default:
-          task_name: null
-          workflow_name: null
+          task_name: ''
+          workflow_name: ''
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 处理并执行工作流
@@ -792,8 +820,7 @@ reaction_station.bioyond:
               - workflow_name
               - task_name
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: process_and_execute_workflow参数
@@ -806,11 +833,10 @@ reaction_station.bioyond:
           cutoff: cutoff
           temperature: temperature
         goal_default:
-          assign_material_name: null
-          cutoff: '900000'
-          temperature: -10.0
+          assign_material_name: ''
+          cutoff: ''
+          temperature: ''
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 反应器放入 - 将反应器放入工作站，配置物料名称、粘度上限和温度参数
@@ -822,14 +848,14 @@ reaction_station.bioyond:
                   description: 物料名称
                   type: string
                 cutoff:
-                  default: '900000'
                   description: 粘度上限
                   type: string
                 temperature:
-                  default: -10.0
                   description: 温度设定(°C)
-                  type: number
+                  type: string
               required:
+              - cutoff
+              - temperature
               - assign_material_name
               type: object
             result: {}
@@ -843,7 +869,6 @@ reaction_station.bioyond:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 反应器取出 - 从工作站中取出反应器，无需参数的简单操作
@@ -853,7 +878,15 @@ reaction_station.bioyond:
               properties: {}
               required: []
               type: object
-            result: {}
+            result:
+              properties:
+                code:
+                  description: 操作结果代码(1表示成功,0表示失败)
+                  type: integer
+                return_info:
+                  description: 操作结果详细信息
+                  type: string
+              type: object
           required:
           - goal
           title: reactor_taken_out参数
@@ -864,8 +897,8 @@ reaction_station.bioyond:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result: {}
+        result:
+          return_info: return_info
         schema:
           description: 启动调度器 - 启动Bioyond工作站的任务调度器，开始执行队列中的任务
           properties:
@@ -875,6 +908,12 @@ reaction_station.bioyond:
               required: []
               type: object
             result:
+              properties:
+                return_info:
+                  description: 调度器启动结果，成功返回1，失败返回0
+                  type: integer
+              required:
+              - return_info
               title: scheduler_start结果
               type: object
           required:
@@ -891,13 +930,12 @@ reaction_station.bioyond:
           time: time
           torque_variation: torque_variation
         goal_default:
-          assign_material_name: null
-          material_id: null
-          temperature: 25.0
-          time: '0'
-          torque_variation: 1
+          assign_material_name: ''
+          material_id: ''
+          temperature: ''
+          time: ''
+          torque_variation: ''
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 固体进料小瓶 - 通过小瓶向反应器中添加固体物料，支持多种粉末类型(盐、面粉、BTDA)
@@ -910,21 +948,29 @@ reaction_station.bioyond:
                   type: string
                 material_id:
                   description: 粉末类型ID，Salt=盐（21分钟），Flour=面粉（27分钟），BTDA=BTDA（38分钟）
+                  enum:
+                  - Salt
+                  - Flour
+                  - BTDA
                   type: string
                 temperature:
-                  default: 25.0
                   description: 温度设定(°C)
-                  type: number
+                  type: string
                 time:
-                  default: '0'
                   description: 观察时间(分钟)
                   type: string
                 torque_variation:
-                  default: 1
                   description: 是否观察 (NO=否, YES=是)
-                  type: integer
+                  enum:
+                  - 'NO'
+                  - 'YES'
+                  type: string
               required:
+              - assign_material_name
               - material_id
+              - time
+              - torque_variation
+              - temperature
               type: object
             result: {}
           required:

unilabos/registry/devices/robot_agv.yaml

@@ -37,41 +37,42 @@ agv.SEER:
           type: object
         type: UniLabJsonCommand
       send_nav_task:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:

unilabos/registry/devices/robot_arm.yaml

@@ -122,6 +122,31 @@ robotic_arm.SCARA_with_slider.moveit.virtual:
           title: moveit_task参数
           type: object
         type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: post_init的参数schema
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       auto-resource_manager:
         feedback: {}
         goal: {}
@@ -173,41 +198,41 @@ robotic_arm.SCARA_with_slider.moveit.virtual:
           type: object
         type: UniLabJsonCommand
       pick_and_place:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -216,41 +241,41 @@ robotic_arm.SCARA_with_slider.moveit.virtual:
           type: object
         type: SendCmd
       set_position:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -259,41 +284,41 @@ robotic_arm.SCARA_with_slider.moveit.virtual:
           type: object
         type: SendCmd
       set_status:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -430,41 +455,42 @@ robotic_arm.UR:
           type: object
         type: UniLabJsonCommand
       move_pos_task:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -506,8 +532,8 @@ robotic_arm.UR:
           type: string
       required:
       - arm_pose
-      - arm_status
       - gripper_pose
+      - arm_status
       - gripper_status
       type: object
   version: 1.0.0
@@ -700,41 +726,41 @@ robotic_arm.elite:
           type: object
         type: UniLabJsonCommand
       modbus_task_cmd:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -744,8 +770,8 @@ robotic_arm.elite:
         type: SendCmd
     module: unilabos.devices.arm.elite_robot:EliteRobot
     status_types:
-      actual_joint_positions: ''
-      arm_pose: list[float]
+      actual_joint_positions: String
+      arm_pose: String
     type: python
   config_info: []
   description: Elite robot arm
@@ -771,8 +797,8 @@ robotic_arm.elite:
             type: number
           type: array
       required:
-      - actual_joint_positions
       - arm_pose
+      - actual_joint_positions
       type: object
   model:
     mesh: elite_robot

unilabos/registry/devices/robot_gripper.yaml

@@ -114,12 +114,11 @@ gripper.misumi_rz:
             goal:
               properties:
                 data:
-                  type: object
+                  type: string
               required:
               - data
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: modbus_crc参数
@@ -399,26 +398,30 @@ gripper.misumi_rz:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -501,82 +504,71 @@ gripper.mock:
         type: UniLabJsonCommand
       push_to:
         feedback:
-          effort: effort
+          effort: torque
           position: position
-          reached_goal: reached_goal
-          stalled: stalled
         goal:
-          command: command
-          position: position
-          torque: torque
-          velocity: velocity
+          command.max_effort: torque
+          command.position: position
         goal_default:
           command:
             max_effort: 0.0
             position: 0.0
         handles: {}
-        placeholder_keys: {}
         result:
-          effort: effort
+          effort: torque
           position: position
-          reached_goal: reached_goal
-          stalled: stalled
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 effort:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 position:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 reached_goal:
                   type: boolean
                 stalled:
                   type: boolean
+              required:
+              - position
+              - effort
+              - stalled
+              - reached_goal
               title: GripperCommand_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
-                  additionalProperties: false
                   properties:
                     max_effort:
-                      maximum: 1.7976931348623157e+308
-                      minimum: -1.7976931348623157e+308
                       type: number
                     position:
-                      maximum: 1.7976931348623157e+308
-                      minimum: -1.7976931348623157e+308
                       type: number
                   required:
                   - position
                   - max_effort
                   title: command
                   type: object
+              required:
+              - command
               title: GripperCommand_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 effort:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 position:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 reached_goal:
                   type: boolean
                 stalled:
                   type: boolean
+              required:
+              - position
+              - effort
+              - stalled
+              - reached_goal
               title: GripperCommand_Result
               type: object
           required:
@@ -612,8 +604,8 @@ gripper.mock:
           type: number
       required:
       - position
-      - status
-      - torque
       - velocity
+      - torque
+      - status
       type: object
   version: 1.0.0

unilabos/registry/devices/robot_linear_motion.yaml

@@ -24,27 +24,6 @@ linear_motion.grbl:
           title: initialize参数
           type: object
         type: UniLabJsonCommand
-      auto-list:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: list的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: list参数
-          type: object
-        type: UniLabJsonCommand
       auto-set_position:
         feedback: {}
         goal: {}
@@ -114,39 +93,44 @@ linear_motion.grbl:
         type: UniLabJsonCommandAsync
       move_through_points:
         feedback:
-          current_pose: current_pose
-          distance_remaining: distance_remaining
-          estimated_time_remaining: estimated_time_remaining
-          navigation_time: navigation_time
-          number_of_poses_remaining: number_of_poses_remaining
-          number_of_recoveries: number_of_recoveries
+          current_pose.pose.position: position
+          estimated_time_remaining.sec: time_remaining
+          navigation_time.sec: time_spent
+          number_of_poses_remaining: pose_number_remaining
         goal:
-          behavior_tree: behavior_tree
-          poses: poses
-          positions: positions
+          poses[].pose.position: positions[]
         goal_default:
           behavior_tree: ''
-          poses: []
+          poses:
+          - header:
+              frame_id: ''
+              stamp:
+                nanosec: 0
+                sec: 0
+            pose:
+              orientation:
+                w: 1.0
+                x: 0.0
+                y: 0.0
+                z: 0.0
+              position:
+                x: 0.0
+                y: 0.0
+                z: 0.0
         handles: {}
-        placeholder_keys: {}
-        result:
-          result: result
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 current_pose:
-                  additionalProperties: false
                   properties:
                     header:
-                      additionalProperties: false
                       properties:
                         frame_id:
                           type: string
                         stamp:
-                          additionalProperties: false
                           properties:
                             nanosec:
                               maximum: 4294967295
@@ -167,26 +151,16 @@ linear_motion.grbl:
                       title: header
                       type: object
                     pose:
-                      additionalProperties: false
                       properties:
                         orientation:
-                          additionalProperties: false
                           properties:
                             w:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             x:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             y:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             z:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                           required:
                           - x
@@ -196,19 +170,12 @@ linear_motion.grbl:
                           title: orientation
                           type: object
                         position:
-                          additionalProperties: false
                           properties:
                             x:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             y:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             z:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                           required:
                           - x
@@ -227,11 +194,8 @@ linear_motion.grbl:
                   title: current_pose
                   type: object
                 distance_remaining:
-                  maximum: 3.4028235e+38
-                  minimum: -3.4028235e+38
                   type: number
                 estimated_time_remaining:
-                  additionalProperties: false
                   properties:
                     nanosec:
                       maximum: 4294967295
@@ -247,7 +211,6 @@ linear_motion.grbl:
                   title: estimated_time_remaining
                   type: object
                 navigation_time:
-                  additionalProperties: false
                   properties:
                     nanosec:
                       maximum: 4294967295
@@ -270,10 +233,16 @@ linear_motion.grbl:
                   maximum: 32767
                   minimum: -32768
                   type: integer
+              required:
+              - current_pose
+              - navigation_time
+              - estimated_time_remaining
+              - number_of_recoveries
+              - distance_remaining
+              - number_of_poses_remaining
               title: NavigateThroughPoses_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 behavior_tree:
                   type: string
@@ -287,8 +256,12 @@ linear_motion.grbl:
                           stamp:
                             properties:
                               nanosec:
+                                maximum: 4294967295
+                                minimum: 0
                                 type: integer
                               sec:
+                                maximum: 2147483647
+                                minimum: -2147483648
                                 type: integer
                             required:
                             - sec
@@ -341,17 +314,23 @@ linear_motion.grbl:
                     required:
                     - header
                     - pose
+                    title: poses
                     type: object
                   type: array
+              required:
+              - poses
+              - behavior_tree
               title: NavigateThroughPoses_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 result:
-                  additionalProperties: true
+                  properties: {}
+                  required: []
                   title: result
                   type: object
+              required:
+              - result
               title: NavigateThroughPoses_Result
               type: object
           required:
@@ -361,15 +340,9 @@ linear_motion.grbl:
         type: NavigateThroughPoses
       set_spindle_speed:
         feedback:
-          error: error
-          header: header
-          position: position
-          velocity: velocity
+          position: spindle_speed
         goal:
-          max_velocity: max_velocity
-          min_duration: min_duration
-          position: position
-          spindle_speed: spindle_speed
+          position: spindle_speed
         goal_default:
           max_velocity: 0.0
           min_duration:
@@ -377,25 +350,19 @@ linear_motion.grbl:
             sec: 0
           position: 0.0
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 error:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 header:
-                  additionalProperties: false
                   properties:
                     frame_id:
                       type: string
                     stamp:
-                      additionalProperties: false
                       properties:
                         nanosec:
                           maximum: 4294967295
@@ -416,24 +383,21 @@ linear_motion.grbl:
                   title: header
                   type: object
                 position:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 velocity:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
+              required:
+              - header
+              - position
+              - velocity
+              - error
               title: SingleJointPosition_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 max_velocity:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 min_duration:
-                  additionalProperties: false
                   properties:
                     nanosec:
                       maximum: 4294967295
@@ -449,13 +413,16 @@ linear_motion.grbl:
                   title: min_duration
                   type: object
                 position:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
+              required:
+              - position
+              - min_duration
+              - max_velocity
               title: SingleJointPosition_Goal
               type: object
             result:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: SingleJointPosition_Result
               type: object
           required:
@@ -465,7 +432,7 @@ linear_motion.grbl:
         type: SingleJointPosition
     module: unilabos.devices.cnc.grbl_sync:GrblCNC
     status_types:
-      position: Point3D
+      position: unilabos.messages:Point3D
       spindle_speed: float
       status: str
     type: python
@@ -504,9 +471,9 @@ linear_motion.grbl:
         status:
           type: string
       required:
+      - status
       - position
       - spindle_speed
-      - status
       type: object
   version: 1.0.0
 linear_motion.toyo_xyz.sim:
@@ -633,6 +600,31 @@ linear_motion.toyo_xyz.sim:
           title: moveit_task参数
           type: object
         type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: post_init的参数schema
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       auto-resource_manager:
         feedback: {}
         goal: {}
@@ -684,41 +676,41 @@ linear_motion.toyo_xyz.sim:
           type: object
         type: UniLabJsonCommand
       pick_and_place:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -727,41 +719,41 @@ linear_motion.toyo_xyz.sim:
           type: object
         type: SendCmd
       set_position:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -770,41 +762,41 @@ linear_motion.toyo_xyz.sim:
           type: object
         type: SendCmd
       set_status:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -947,26 +939,30 @@ motor.iCL42:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -1004,8 +1000,8 @@ motor.iCL42:
         success:
           type: boolean
       required:
-      - is_executing_run
       - motor_position
+      - is_executing_run
       - success
       type: object
   version: 1.0.0

unilabos/registry/devices/solid_dispenser.yaml

@@ -14,24 +14,19 @@ solid_dispenser.laiyu:
           powder_tube_number: 0
           target_tube_position: ''
         handles: {}
-        placeholder_keys: {}
         result:
           actual_mass_mg: actual_mass_mg
-          return_info: return_info
-          success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: SolidDispenseAddPowderTube_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 compound_mass:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 powder_tube_number:
                   maximum: 2147483647
@@ -39,19 +34,24 @@ solid_dispenser.laiyu:
                   type: integer
                 target_tube_position:
                   type: string
+              required:
+              - powder_tube_number
+              - target_tube_position
+              - compound_mass
               title: SolidDispenseAddPowderTube_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 actual_mass_mg:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - actual_mass_mg
+              - success
               title: SolidDispenseAddPowderTube_Result
               type: object
           required:
@@ -74,12 +74,11 @@ solid_dispenser.laiyu:
             goal:
               properties:
                 data:
-                  type: object
+                  type: string
               required:
               - data
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: calculate_crc参数
@@ -100,12 +99,11 @@ solid_dispenser.laiyu:
             goal:
               properties:
                 command:
-                  type: object
+                  type: string
               required:
               - command
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: send_command参数
@@ -114,37 +112,36 @@ solid_dispenser.laiyu:
       discharge:
         feedback: {}
         goal:
-          float_in: float_in
+          float_input: float_input
         goal_default:
           float_in: 0.0
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: FloatSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 float_in:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
+              required:
+              - float_in
               title: FloatSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: FloatSingleInput_Result
               type: object
           required:
@@ -159,31 +156,32 @@ solid_dispenser.laiyu:
         goal_default:
           string: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 string:
                   type: string
+              required:
+              - string
               title: StrSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: StrSingleInput_Result
               type: object
           required:
@@ -202,41 +200,38 @@ solid_dispenser.laiyu:
           y: 0.0
           z: 0.0
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: Point3DSeparateInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 x:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 y:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 z:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
+              required:
+              - x
+              - y
+              - z
               title: Point3DSeparateInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: Point3DSeparateInput_Result
               type: object
           required:
@@ -251,33 +246,34 @@ solid_dispenser.laiyu:
         goal_default:
           int_input: 0
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: IntSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 int_input:
                   maximum: 2147483647
                   minimum: -2147483648
                   type: integer
+              required:
+              - int_input
               title: IntSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: IntSingleInput_Result
               type: object
           required:
@@ -292,33 +288,34 @@ solid_dispenser.laiyu:
         goal_default:
           int_input: 0
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: IntSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 int_input:
                   maximum: 2147483647
                   minimum: -2147483648
                   type: integer
+              required:
+              - int_input
               title: IntSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: IntSingleInput_Result
               type: object
           required:
@@ -331,25 +328,26 @@ solid_dispenser.laiyu:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:

unilabos/registry/devices/temperature.yaml

@@ -34,8 +34,7 @@ chiller:
               - register_address
               - value
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: build_modbus_frame参数
@@ -64,8 +63,7 @@ chiller:
               required:
               - temperature
               type: object
-            result:
-              type: integer
+            result: {}
           required:
           - goal
           title: convert_temperature_to_modbus_value参数
@@ -86,12 +84,11 @@ chiller:
             goal:
               properties:
                 data:
-                  type: object
+                  type: string
               required:
               - data
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: modbus_crc参数
@@ -119,41 +116,42 @@ chiller:
           type: object
         type: UniLabJsonCommand
       set_temperature:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -268,15 +266,9 @@ heaterstirrer.dalong:
         feedback:
           status: status
         goal:
-          pressure: pressure
           purpose: purpose
-          reflux_solvent: reflux_solvent
-          stir: stir
-          stir_speed: stir_speed
           temp: temp
-          temp_spec: temp_spec
           time: time
-          time_spec: time_spec
           vessel: vessel
         goal_default:
           pressure: ''
@@ -309,23 +301,20 @@ heaterstirrer.dalong:
             sample_id: ''
             type: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          message: message
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: HeatChill_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 pressure:
                   type: string
@@ -336,12 +325,8 @@ heaterstirrer.dalong:
                 stir:
                   type: boolean
                 stir_speed:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 temp:
-                  maximum: 1.7976931348623157e+308
-                  minimum: -1.7976931348623157e+308
                   type: number
                 temp_spec:
                   type: string
@@ -350,7 +335,6 @@ heaterstirrer.dalong:
                 time_spec:
                   type: string
                 vessel:
-                  additionalProperties: false
                   properties:
                     category:
                       type: string
@@ -369,26 +353,16 @@ heaterstirrer.dalong:
                     parent:
                       type: string
                     pose:
-                      additionalProperties: false
                       properties:
                         orientation:
-                          additionalProperties: false
                           properties:
                             w:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             x:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             y:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             z:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                           required:
                           - x
@@ -398,19 +372,12 @@ heaterstirrer.dalong:
                           title: orientation
                           type: object
                         position:
-                          additionalProperties: false
                           properties:
                             x:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             y:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                             z:
-                              maximum: 1.7976931348623157e+308
-                              minimum: -1.7976931348623157e+308
                               type: number
                           required:
                           - x
@@ -440,10 +407,20 @@ heaterstirrer.dalong:
                   - data
                   title: vessel
                   type: object
+              required:
+              - vessel
+              - temp
+              - time
+              - temp_spec
+              - time_spec
+              - pressure
+              - reflux_solvent
+              - stir
+              - stir_speed
+              - purpose
               title: HeatChill_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 message:
                   type: string
@@ -451,6 +428,10 @@ heaterstirrer.dalong:
                   type: string
                 success:
                   type: boolean
+              required:
+              - success
+              - message
+              - return_info
               title: HeatChill_Result
               type: object
           required:
@@ -459,42 +440,42 @@ heaterstirrer.dalong:
           type: object
         type: HeatChill
       set_temp_target:
-        feedback:
-          status: status
+        feedback: {}
         goal:
-          command: command
-          temp: temp
+          command: temp
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -503,42 +484,42 @@ heaterstirrer.dalong:
           type: object
         type: SendCmd
       set_temp_warning:
-        feedback:
-          status: status
+        feedback: {}
         goal:
-          command: command
-          temp: temp
+          command: temp
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:
@@ -588,8 +569,8 @@ heaterstirrer.dalong:
       - status
       - stir_speed
       - temp
-      - temp_target
       - temp_warning
+      - temp_target
       type: object
   version: 1.0.0
 tempsensor:
@@ -710,41 +691,42 @@ tempsensor:
           type: object
         type: UniLabJsonCommand
       set_warning:
-        feedback:
-          status: status
+        feedback: {}
         goal:
           command: command
         goal_default:
           command: ''
         handles: {}
-        placeholder_keys: {}
         result:
-          return_info: return_info
           success: success
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: false
               properties:
                 status:
                   type: string
+              required:
+              - status
               title: SendCmd_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 command:
                   type: string
+              required:
+              - command
               title: SendCmd_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: SendCmd_Result
               type: object
           required:

unilabos/registry/devices/xrd_d7mate.yaml

@@ -45,6 +45,31 @@ xrd_d7mate:
           title: connect参数
           type: object
         type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: string
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       auto-start_from_string:
         feedback: {}
         goal: {}
@@ -60,14 +85,11 @@ xrd_d7mate:
             goal:
               properties:
                 params:
-                  anyOf:
-                  - type: string
-                  - type: object
+                  type: string
               required:
               - params
               type: object
-            result:
-              type: object
+            result: {}
           required:
           - goal
           title: start_from_string参数
@@ -83,18 +105,21 @@ xrd_d7mate:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -105,38 +130,38 @@ xrd_d7mate:
       get_sample_down:
         feedback: {}
         goal:
-          int_input: int_input
-          sample_station: sample_station
+          sample_station: 1
         goal_default:
           int_input: 0
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: IntSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 int_input:
                   maximum: 2147483647
                   minimum: -2147483648
                   type: integer
+              required:
+              - int_input
               title: IntSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: IntSingleInput_Result
               type: object
           required:
@@ -154,18 +179,21 @@ xrd_d7mate:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -183,18 +211,21 @@ xrd_d7mate:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -207,25 +238,26 @@ xrd_d7mate:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -242,35 +274,42 @@ xrd_d7mate:
           sample_id: ''
           start_theta: 10.0
         goal_default:
-          end_theta: null
-          exp_time: null
-          increment: null
-          sample_id: null
-          start_theta: null
+          end_theta: 80.0
+          exp_time: 0.5
+          increment: 0.02
+          sample_id: Sample001
+          start_theta: 10.0
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 送样完成后，发送样品信息和采集参数
           properties:
             feedback:
+              properties: {}
+              required: []
               title: SampleReadyInput_Feedback
+              type: object
             goal:
               properties:
                 end_theta:
                   description: 结束角度（≥5.5°，且必须大于start_theta）
+                  minimum: 5.5
                   type: number
                 exp_time:
                   description: 曝光时间（0.1-5.0秒）
+                  maximum: 5.0
+                  minimum: 0.1
                   type: number
                 increment:
                   description: 角度增量（≥0.005）
+                  minimum: 0.005
                   type: number
                 sample_id:
                   description: 样品标识符
                   type: string
                 start_theta:
                   description: 起始角度（≥5°）
+                  minimum: 5.0
                   type: number
               required:
               - sample_id
@@ -281,11 +320,19 @@ xrd_d7mate:
               title: SampleReadyInput_Goal
               type: object
             result:
+              properties:
+                return_info:
+                  type: string
+                success:
+                  type: boolean
+              required:
+              - return_info
+              - success
               title: SampleReadyInput_Result
               type: object
           required:
           - goal
-          title: send_sample_ready参数
+          title: SampleReadyInput
           type: object
         type: UniLabJsonCommand
       set_power_off:
@@ -293,25 +340,26 @@ xrd_d7mate:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -324,25 +372,26 @@ xrd_d7mate:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -356,16 +405,18 @@ xrd_d7mate:
           current: 30.0
           voltage: 40.0
         goal_default:
-          current: null
-          voltage: null
+          current: 30.0
+          voltage: 40.0
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 设置高压电源电压和电流
           properties:
             feedback:
+              properties: {}
+              required: []
               title: VoltageCurrentInput_Feedback
+              type: object
             goal:
               properties:
                 current:
@@ -380,11 +431,19 @@ xrd_d7mate:
               title: VoltageCurrentInput_Goal
               type: object
             result:
+              properties:
+                return_info:
+                  type: string
+                success:
+                  type: boolean
+              required:
+              - return_info
+              - success
               title: VoltageCurrentInput_Result
               type: object
           required:
           - goal
-          title: set_voltage_current参数
+          title: VoltageCurrentInput
           type: object
         type: UniLabJsonCommand
       start:
@@ -394,12 +453,11 @@ xrd_d7mate:
           end_theta: 80.0
           exp_time: 0.1
           increment: 0.05
-          sample_id: ''
+          sample_id: 样品名称
           start_theta: 10.0
           string: ''
           wait_minutes: 3.0
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 启动自动模式→上样→等待→样品准备→监控→检测下样位→执行下样流程。
@@ -408,42 +466,54 @@ xrd_d7mate:
             goal:
               properties:
                 end_theta:
-                  default: 80.0
                   description: 结束角度（≥5.5°，且必须大于start_theta）
-                  type: number
+                  minimum: 5.5
+                  type: string
                 exp_time:
-                  default: 0.1
                   description: 曝光时间（0.1-5.0秒）
-                  type: number
+                  maximum: 5.0
+                  minimum: 0.1
+                  type: string
                 increment:
-                  default: 0.05
                   description: 角度增量（≥0.005）
-                  type: number
+                  minimum: 0.005
+                  type: string
                 sample_id:
-                  default: ''
                   description: 样品标识符
                   type: string
                 start_theta:
-                  default: 10.0
                   description: 起始角度（≥5°）
-                  type: number
+                  minimum: 5.0
+                  type: string
                 string:
-                  default: ''
                   description: 字符串格式的参数输入，如果提供则优先解析使用
                   type: string
                 wait_minutes:
-                  default: 3.0
                   description: 允许上样后等待分钟数
+                  minimum: 0.0
                   type: number
-              required: []
+              required:
+              - sample_id
+              - start_theta
+              - end_theta
+              - increment
+              - exp_time
               title: StartWorkflow_Goal
               type: object
             result:
+              properties:
+                return_info:
+                  type: string
+                success:
+                  type: boolean
+              required:
+              - return_info
+              - success
               title: StartWorkflow_Result
               type: object
           required:
           - goal
-          title: start参数
+          title: StartWorkflow
           type: object
         type: UniLabJsonCommand
       start_auto_mode:
@@ -451,15 +521,17 @@ xrd_d7mate:
         goal:
           status: true
         goal_default:
-          status: null
+          status: true
         handles: {}
-        placeholder_keys: {}
         result: {}
         schema:
           description: 启动或停止自动模式
           properties:
             feedback:
+              properties: {}
+              required: []
               title: BoolSingleInput_Feedback
+              type: object
             goal:
               properties:
                 status:
@@ -470,16 +542,25 @@ xrd_d7mate:
               title: BoolSingleInput_Goal
               type: object
             result:
+              properties:
+                return_info:
+                  type: string
+                success:
+                  type: boolean
+              required:
+              - return_info
+              - success
               title: BoolSingleInput_Result
               type: object
           required:
           - goal
-          title: start_auto_mode参数
+          title: BoolSingleInput
           type: object
         type: UniLabJsonCommand
     module: unilabos.devices.xrd_d7mate.xrd_d7mate:XRDClient
     status_types:
       current_acquire_data: dict
+      sample_down: dict
       sample_request: dict
       sample_status: dict
     type: python
@@ -505,13 +586,16 @@ xrd_d7mate:
       properties:
         current_acquire_data:
           type: object
+        sample_down:
+          type: object
         sample_request:
           type: object
         sample_status:
           type: object
       required:
-      - current_acquire_data
       - sample_request
+      - current_acquire_data
       - sample_status
+      - sample_down
       type: object
   version: 1.0.0

unilabos/registry/devices/zhida_gcms.yaml

@@ -8,25 +8,26 @@ zhida_gcms:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -76,6 +77,31 @@ zhida_gcms:
           title: connect参数
           type: object
         type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: string
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       get_methods:
         feedback: {}
         goal: {}
@@ -86,18 +112,21 @@ zhida_gcms:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -115,18 +144,21 @@ zhida_gcms:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -144,18 +176,21 @@ zhida_gcms:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -168,25 +203,26 @@ zhida_gcms:
         goal: {}
         goal_default: {}
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: EmptyIn_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
+              required:
+              - return_info
               title: EmptyIn_Result
               type: object
           required:
@@ -198,35 +234,35 @@ zhida_gcms:
         feedback: {}
         goal:
           string: string
-          text: text
         goal_default:
           string: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 string:
                   type: string
+              required:
+              - string
               title: StrSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: StrSingleInput_Result
               type: object
           required:
@@ -237,36 +273,36 @@ zhida_gcms:
       start_with_csv_file:
         feedback: {}
         goal:
-          csv_file_path: csv_file_path
           string: string
         goal_default:
           string: ''
         handles: {}
-        placeholder_keys: {}
-        result:
-          return_info: return_info
-          success: success
+        result: {}
         schema:
           description: ''
           properties:
             feedback:
-              additionalProperties: true
+              properties: {}
+              required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              additionalProperties: false
               properties:
                 string:
                   type: string
+              required:
+              - string
               title: StrSingleInput_Goal
               type: object
             result:
-              additionalProperties: false
               properties:
                 return_info:
                   type: string
                 success:
                   type: boolean
+              required:
+              - return_info
+              - success
               title: StrSingleInput_Result
               type: object
           required:
@@ -307,8 +343,8 @@ zhida_gcms:
         version:
           type: object
       required:
-      - methods
       - status
+      - methods
       - version
       type: object
   version: 1.0.0

unilabos/registry/resources/bioyond/YB_bottle.yaml

@@ -9,6 +9,7 @@ YB_20ml_fenyeping:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_5ml_fenyeping:
   category:
@@ -21,6 +22,7 @@ YB_5ml_fenyeping:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_jia_yang_tou_da:
   category:
@@ -33,6 +35,7 @@ YB_jia_yang_tou_da:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_pei_ye_da_Bottle:
   category:
@@ -45,6 +48,7 @@ YB_pei_ye_da_Bottle:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_pei_ye_xiao_Bottle:
   category:
@@ -57,6 +61,7 @@ YB_pei_ye_xiao_Bottle:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_qiang_tou:
   category:
@@ -69,6 +74,7 @@ YB_qiang_tou:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_ye_Bottle:
   category:
@@ -82,4 +88,5 @@ YB_ye_Bottle:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/bioyond/YB_bottle_carriers.yaml

@@ -9,6 +9,7 @@ YB_100ml_yeti:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_20ml_fenyepingban:
   category:
@@ -21,6 +22,7 @@ YB_20ml_fenyepingban:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_5ml_fenyepingban:
   category:
@@ -33,6 +35,7 @@ YB_5ml_fenyepingban:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_6StockCarrier:
   category:
@@ -45,6 +48,7 @@ YB_6StockCarrier:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_6VialCarrier:
   category:
@@ -57,6 +61,7 @@ YB_6VialCarrier:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_gao_nian_ye_Bottle:
   category:
@@ -69,6 +74,7 @@ YB_gao_nian_ye_Bottle:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_gaonianye:
   category:
@@ -81,6 +87,7 @@ YB_gaonianye:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_jia_yang_tou_da_Carrier:
   category:
@@ -93,6 +100,7 @@ YB_jia_yang_tou_da_Carrier:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_peiyepingdaban:
   category:
@@ -105,6 +113,7 @@ YB_peiyepingdaban:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_peiyepingxiaoban:
   category:
@@ -117,6 +126,7 @@ YB_peiyepingxiaoban:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_qiang_tou_he:
   category:
@@ -129,6 +139,7 @@ YB_qiang_tou_he:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_shi_pei_qi_kuai:
   category:
@@ -141,6 +152,7 @@ YB_shi_pei_qi_kuai:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_ye:
   category:
@@ -153,6 +165,7 @@ YB_ye:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 YB_ye_100ml_Bottle:
   category:
@@ -165,4 +178,5 @@ YB_ye_100ml_Bottle:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/bioyond/bottle_carriers.yaml

@@ -8,6 +8,7 @@ BIOYOND_PolymerStation_1BottleCarrier:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 BIOYOND_PolymerStation_1FlaskCarrier:
   category:
@@ -19,6 +20,7 @@ BIOYOND_PolymerStation_1FlaskCarrier:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 BIOYOND_PolymerStation_6StockCarrier:
   category:
@@ -30,6 +32,7 @@ BIOYOND_PolymerStation_6StockCarrier:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 BIOYOND_PolymerStation_8StockCarrier:
   category:
@@ -41,4 +44,5 @@ BIOYOND_PolymerStation_8StockCarrier:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/bioyond/deck.yaml

@@ -8,6 +8,7 @@ BIOYOND_PolymerPreparationStation_Deck:
   handles: []
   icon: 配液站.webp
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 BIOYOND_PolymerReactionStation_Deck:
   category:
@@ -19,6 +20,7 @@ BIOYOND_PolymerReactionStation_Deck:
   handles: []
   icon: 反应站.webp
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 BIOYOND_YB_Deck:
   category:
@@ -30,6 +32,7 @@ BIOYOND_YB_Deck:
   handles: []
   icon: 配液站.webp
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 CoincellDeck:
   category:
@@ -41,4 +44,5 @@ CoincellDeck:
   handles: []
   icon: koudian.webp
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/common/resource_container.yaml

@@ -1,3 +1,24 @@
+disposal:
+  category:
+  - disposal
+  - waste
+  - resource_container
+  class:
+    module: unilabos.resources.disposal:Disposal
+    type: unilabos
+  description: 废料处理位置，用于处理实验废料
+  handles:
+  - data_key: disposal_access
+    data_source: handle
+    data_type: fluid
+    handler_key: access
+    io_type: target
+    label: access
+    side: NORTH
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
 hplc_plate:
   category:
   - resource_container
@@ -19,6 +40,56 @@ hplc_plate:
     - 3.1416
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/hplc_plate/modal.xacro
     type: resource
+  registry_type: resource
+  version: 1.0.0
+maintenance:
+  category:
+  - maintenance
+  - position
+  - resource_container
+  class:
+    module: unilabos.resources.maintenance:Maintenance
+    type: unilabos
+  description: 维护位置，用于设备维护和校准
+  handles:
+  - data_key: maintenance_access
+    data_source: handle
+    data_type: mechanical
+    handler_key: access
+    io_type: target
+    label: access
+    side: NORTH
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+plate:
+  category:
+  - plate
+  - labware
+  - resource_container
+  class:
+    module: unilabos.resources.plate:Plate
+    type: unilabos
+  description: 实验板，用于放置样品和试剂
+  handles:
+  - data_key: plate_access
+    data_source: handle
+    data_type: mechanical
+    handler_key: access
+    io_type: target
+    label: access
+    side: NORTH
+  - data_key: sample_wells
+    data_source: handle
+    data_type: fluid
+    handler_key: wells
+    io_type: target
+    label: wells
+    side: CENTER
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 plate_96:
   category:
@@ -41,6 +112,7 @@ plate_96:
     - 0
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/plate_96/modal.xacro
     type: resource
+  registry_type: resource
   version: 1.0.0
 plate_96_high:
   category:
@@ -63,6 +135,35 @@ plate_96_high:
     - 1.5708
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/plate_96_high/modal.xacro
     type: resource
+  registry_type: resource
+  version: 1.0.0
+tip_rack:
+  category:
+  - tip_rack
+  - labware
+  - resource_container
+  class:
+    module: unilabos.resources.tip_rack:TipRack
+    type: unilabos
+  description: 枪头架资源，用于存放和管理移液器枪头
+  handles:
+  - data_key: tip_access
+    data_source: handle
+    data_type: mechanical
+    handler_key: access
+    io_type: target
+    label: access
+    side: NORTH
+  - data_key: tip_pickup
+    data_source: handle
+    data_type: mechanical
+    handler_key: pickup
+    io_type: target
+    label: pickup
+    side: SOUTH
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 tiprack_96_high:
   category:
@@ -94,6 +195,7 @@ tiprack_96_high:
     - 1.5708
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tiprack_96_high/modal.xacro
     type: resource
+  registry_type: resource
   version: 1.0.0
 tiprack_box:
   category:
@@ -125,4 +227,5 @@ tiprack_box:
     - 0
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tiprack_box/modal.xacro
     type: resource
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/laiyu/container.yaml

@@ -29,6 +29,7 @@ bottle_container:
     - 0
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/bottle_container/modal.xacro
     type: resource
+  registry_type: resource
   version: 1.0.0
 tube_container:
   category:
@@ -61,4 +62,5 @@ tube_container:
     - 0
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tube_container/modal.xacro
     type: resource
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/laiyu/deck.yaml

@@ -12,4 +12,5 @@ TransformXYZDeck:
     mesh: liquid_transform_xyz
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/liquid_transform_xyz/macro_device.xacro
     type: device
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/opentrons/deck.yaml

@@ -12,6 +12,7 @@ OTDeck:
     mesh: opentrons_liquid_handler
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/opentrons_liquid_handler/macro_device.xacro
     type: device
+  registry_type: resource
   version: 1.0.0
 hplc_station:
   category:
@@ -27,4 +28,5 @@ hplc_station:
     mesh: hplc_station
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/hplc_station/macro_device.xacro
     type: device
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/opentrons/plate_adapters.yaml

@@ -8,4 +8,5 @@ Opentrons_96_adapter_Vb:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/opentrons/plates.yaml

@@ -8,6 +8,7 @@ appliedbiosystemsmicroamp_384_wellplate_40ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 biorad_384_wellplate_50ul:
   category:
@@ -19,6 +20,7 @@ biorad_384_wellplate_50ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 biorad_96_wellplate_200ul_pcr:
   category:
@@ -30,6 +32,7 @@ biorad_96_wellplate_200ul_pcr:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 corning_12_wellplate_6point9ml_flat:
   category:
@@ -41,6 +44,7 @@ corning_12_wellplate_6point9ml_flat:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 corning_24_wellplate_3point4ml_flat:
   category:
@@ -52,6 +56,7 @@ corning_24_wellplate_3point4ml_flat:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 corning_384_wellplate_112ul_flat:
   category:
@@ -63,6 +68,7 @@ corning_384_wellplate_112ul_flat:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 corning_48_wellplate_1point6ml_flat:
   category:
@@ -74,6 +80,7 @@ corning_48_wellplate_1point6ml_flat:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 corning_6_wellplate_16point8ml_flat:
   category:
@@ -85,6 +92,7 @@ corning_6_wellplate_16point8ml_flat:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 corning_96_wellplate_360ul_flat:
   category:
@@ -96,6 +104,7 @@ corning_96_wellplate_360ul_flat:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 nest_96_wellplate_100ul_pcr_full_skirt:
   category:
@@ -127,6 +136,7 @@ nest_96_wellplate_100ul_pcr_full_skirt:
     - 1.5708
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tecan_nested_tip_rack/modal.xacro
     type: resource
+  registry_type: resource
   version: 1.0.0
 nest_96_wellplate_200ul_flat:
   category:
@@ -138,6 +148,7 @@ nest_96_wellplate_200ul_flat:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 nest_96_wellplate_2ml_deep:
   category:
@@ -160,6 +171,7 @@ nest_96_wellplate_2ml_deep:
     - 1.5708
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tecan_nested_tip_rack/modal.xacro
     type: resource
+  registry_type: resource
   version: 1.0.0
 thermoscientificnunc_96_wellplate_1300ul:
   category:
@@ -171,6 +183,7 @@ thermoscientificnunc_96_wellplate_1300ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 thermoscientificnunc_96_wellplate_2000ul:
   category:
@@ -182,6 +195,7 @@ thermoscientificnunc_96_wellplate_2000ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 usascientific_96_wellplate_2point4ml_deep:
   category:
@@ -193,4 +207,5 @@ usascientific_96_wellplate_2point4ml_deep:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/opentrons/reservoirs.yaml

@@ -8,6 +8,7 @@ agilent_1_reservoir_290ml:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 axygen_1_reservoir_90ml:
   category:
@@ -19,6 +20,7 @@ axygen_1_reservoir_90ml:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 nest_12_reservoir_15ml:
   category:
@@ -30,6 +32,7 @@ nest_12_reservoir_15ml:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 nest_1_reservoir_195ml:
   category:
@@ -41,6 +44,7 @@ nest_1_reservoir_195ml:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 nest_1_reservoir_290ml:
   category:
@@ -52,6 +56,7 @@ nest_1_reservoir_290ml:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 usascientific_12_reservoir_22ml:
   category:
@@ -63,4 +68,5 @@ usascientific_12_reservoir_22ml:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/opentrons/tip_racks.yaml

@@ -8,6 +8,7 @@ eppendorf_96_tiprack_1000ul_eptips:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 eppendorf_96_tiprack_10ul_eptips:
   category:
@@ -19,6 +20,7 @@ eppendorf_96_tiprack_10ul_eptips:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 geb_96_tiprack_1000ul:
   category:
@@ -30,6 +32,7 @@ geb_96_tiprack_1000ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 geb_96_tiprack_10ul:
   category:
@@ -41,6 +44,7 @@ geb_96_tiprack_10ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_96_filtertiprack_1000ul:
   category:
@@ -71,6 +75,7 @@ opentrons_96_filtertiprack_1000ul:
     - 1.5708
     path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tecan_nested_tip_rack/modal.xacro
     type: resource
+  registry_type: resource
   version: 1.0.0
 opentrons_96_filtertiprack_10ul:
   category:
@@ -82,6 +87,7 @@ opentrons_96_filtertiprack_10ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_96_filtertiprack_200ul:
   category:
@@ -93,6 +99,7 @@ opentrons_96_filtertiprack_200ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_96_filtertiprack_20ul:
   category:
@@ -104,6 +111,7 @@ opentrons_96_filtertiprack_20ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_96_tiprack_1000ul:
   category:
@@ -115,6 +123,7 @@ opentrons_96_tiprack_1000ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_96_tiprack_10ul:
   category:
@@ -126,6 +135,7 @@ opentrons_96_tiprack_10ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_96_tiprack_20ul:
   category:
@@ -137,6 +147,7 @@ opentrons_96_tiprack_20ul:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_96_tiprack_300ul:
   category:

unilabos/registry/resources/opentrons/tube_racks.yaml

@@ -8,6 +8,7 @@ opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical_acrylic:
   category:
@@ -19,6 +20,7 @@ opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical_acrylic:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_10_tuberack_nest_4x50ml_6x15ml_conical:
   category:
@@ -30,6 +32,7 @@ opentrons_10_tuberack_nest_4x50ml_6x15ml_conical:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_15_tuberack_falcon_15ml_conical:
   category:
@@ -41,6 +44,7 @@ opentrons_15_tuberack_falcon_15ml_conical:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_15_tuberack_nest_15ml_conical:
   category:
@@ -52,6 +56,7 @@ opentrons_15_tuberack_nest_15ml_conical:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_aluminumblock_generic_2ml_screwcap:
   category:
@@ -63,6 +68,7 @@ opentrons_24_aluminumblock_generic_2ml_screwcap:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_aluminumblock_nest_1point5ml_snapcap:
   category:
@@ -74,6 +80,7 @@ opentrons_24_aluminumblock_nest_1point5ml_snapcap:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_tuberack_eppendorf_1point5ml_safelock_snapcap:
   category:
@@ -85,6 +92,7 @@ opentrons_24_tuberack_eppendorf_1point5ml_safelock_snapcap:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap:
   category:
@@ -96,6 +104,7 @@ opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap_acrylic:
   category:
@@ -107,6 +116,7 @@ opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap_acrylic:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_tuberack_generic_0point75ml_snapcap_acrylic:
   category:
@@ -118,6 +128,7 @@ opentrons_24_tuberack_generic_0point75ml_snapcap_acrylic:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_tuberack_generic_2ml_screwcap:
   category:
@@ -129,6 +140,7 @@ opentrons_24_tuberack_generic_2ml_screwcap:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_tuberack_nest_0point5ml_screwcap:
   category:
@@ -140,6 +152,7 @@ opentrons_24_tuberack_nest_0point5ml_screwcap:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_tuberack_nest_1point5ml_screwcap:
   category:
@@ -151,6 +164,7 @@ opentrons_24_tuberack_nest_1point5ml_screwcap:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_tuberack_nest_1point5ml_snapcap:
   category:
@@ -162,6 +176,7 @@ opentrons_24_tuberack_nest_1point5ml_snapcap:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_tuberack_nest_2ml_screwcap:
   category:
@@ -173,6 +188,7 @@ opentrons_24_tuberack_nest_2ml_screwcap:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_24_tuberack_nest_2ml_snapcap:
   category:
@@ -184,6 +200,7 @@ opentrons_24_tuberack_nest_2ml_snapcap:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_6_tuberack_falcon_50ml_conical:
   category:
@@ -195,6 +212,7 @@ opentrons_6_tuberack_falcon_50ml_conical:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_6_tuberack_nest_50ml_conical:
   category:
@@ -206,6 +224,7 @@ opentrons_6_tuberack_nest_50ml_conical:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 opentrons_96_well_aluminum_block:
   category:
@@ -217,4 +236,5 @@ opentrons_96_well_aluminum_block:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/organic/container.yaml

@@ -29,4 +29,5 @@ container:
     side: WEST
   icon: Flask.webp
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/post_process/bottle_carriers.yaml

@@ -8,6 +8,7 @@ POST_PROCESS_Raw_1BottleCarrier:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 POST_PROCESS_Reaction_1BottleCarrier:
   category:
@@ -19,4 +20,5 @@ POST_PROCESS_Reaction_1BottleCarrier:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/post_process/deck.yaml

@@ -9,4 +9,5 @@ post_process_deck:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/prcxi/plate_adapters.yaml

@@ -9,6 +9,7 @@ PRCXI_30mm_Adapter:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_Adapter:
   category:
@@ -21,6 +22,7 @@ PRCXI_Adapter:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_Deep10_Adapter:
   category:
@@ -33,6 +35,7 @@ PRCXI_Deep10_Adapter:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_Deep300_Adapter:
   category:
@@ -45,6 +48,7 @@ PRCXI_Deep300_Adapter:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_PCR_Adapter:
   category:
@@ -57,6 +61,7 @@ PRCXI_PCR_Adapter:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_Reservoir_Adapter:
   category:
@@ -69,6 +74,7 @@ PRCXI_Reservoir_Adapter:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_Tip10_Adapter:
   category:
@@ -81,6 +87,7 @@ PRCXI_Tip10_Adapter:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_Tip1250_Adapter:
   category:
@@ -93,6 +100,7 @@ PRCXI_Tip1250_Adapter:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_Tip300_Adapter:
   category:
@@ -105,4 +113,5 @@ PRCXI_Tip300_Adapter:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/prcxi/plates.yaml

@@ -9,6 +9,7 @@ PRCXI_48_DeepWell:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_96_DeepWell:
   category:
@@ -21,6 +22,7 @@ PRCXI_96_DeepWell:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_AGenBio_4_troughplate:
   category:
@@ -33,6 +35,7 @@ PRCXI_AGenBio_4_troughplate:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_BioER_96_wellplate:
   category:
@@ -45,6 +48,7 @@ PRCXI_BioER_96_wellplate:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_BioRad_384_wellplate:
   category:
@@ -57,6 +61,7 @@ PRCXI_BioRad_384_wellplate:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_CellTreat_96_wellplate:
   category:
@@ -69,6 +74,7 @@ PRCXI_CellTreat_96_wellplate:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_PCR_Plate_200uL_nonskirted:
   category:
@@ -81,6 +87,7 @@ PRCXI_PCR_Plate_200uL_nonskirted:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_PCR_Plate_200uL_semiskirted:
   category:
@@ -93,6 +100,7 @@ PRCXI_PCR_Plate_200uL_semiskirted:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_PCR_Plate_200uL_skirted:
   category:
@@ -105,6 +113,7 @@ PRCXI_PCR_Plate_200uL_skirted:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_nest_12_troughplate:
   category:
@@ -117,6 +126,7 @@ PRCXI_nest_12_troughplate:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_nest_1_troughplate:
   category:
@@ -129,4 +139,5 @@ PRCXI_nest_1_troughplate:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/prcxi/tip_racks.yaml

@@ -9,6 +9,7 @@ PRCXI_1000uL_Tips:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_10uL_Tips:
   category:
@@ -21,6 +22,7 @@ PRCXI_10uL_Tips:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_10ul_eTips:
   category:
@@ -33,6 +35,7 @@ PRCXI_10ul_eTips:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_1250uL_Tips:
   category:
@@ -45,6 +48,7 @@ PRCXI_1250uL_Tips:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_200uL_Tips:
   category:
@@ -57,6 +61,7 @@ PRCXI_200uL_Tips:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0
 PRCXI_300ul_Tips:
   category:
@@ -69,4 +74,5 @@ PRCXI_300ul_Tips:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/prcxi/trash.yaml

@@ -9,4 +9,5 @@ PRCXI_trash:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/resources/prcxi/tube_racks.yaml

@@ -9,4 +9,5 @@ PRCXI_EP_Adapter:
   handles: []
   icon: ''
   init_param_schema: {}
+  registry_type: resource
   version: 1.0.0

unilabos/registry/utils.py

@@ -1,724 +0,0 @@
-"""
-注册表工具函数
-
-从 registry.py 中提取的纯工具函数，包括：
-- docstring 解析
-- 类型字符串 → JSON Schema 转换
-- AST 类型节点解析
-- TypedDict / Slot / Handle 等辅助检测
-"""
-
-import inspect
-import logging
-import re
-import typing
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-from msgcenterpy.instances.typed_dict_instance import TypedDictMessageInstance
-
-from unilabos.utils.cls_creator import import_class
-
-_logger = logging.getLogger(__name__)
-
-
-# ---------------------------------------------------------------------------
-# 异常
-# ---------------------------------------------------------------------------
-
-
-class ROSMsgNotFound(Exception):
-    pass
-
-
-# ---------------------------------------------------------------------------
-# Docstring 解析 (Google-style)
-# ---------------------------------------------------------------------------
-
-_SECTION_RE = re.compile(r"^(\w[\w\s]*):\s*$")
-
-
-def parse_docstring(docstring: Optional[str]) -> Dict[str, Any]:
-    """
-    解析 Google-style docstring，提取描述和参数说明。
-
-    Returns:
-        {"description": "短描述", "params": {"param1": "参数1描述", ...}}
-    """
-    result: Dict[str, Any] = {"description": "", "params": {}}
-    if not docstring:
-        return result
-
-    lines = docstring.strip().splitlines()
-    if not lines:
-        return result
-
-    result["description"] = lines[0].strip()
-
-    in_args = False
-    current_param: Optional[str] = None
-    current_desc_parts: list = []
-
-    for line in lines[1:]:
-        stripped = line.strip()
-        section_match = _SECTION_RE.match(stripped)
-        if section_match:
-            if current_param is not None:
-                result["params"][current_param] = "\n".join(current_desc_parts).strip()
-                current_param = None
-                current_desc_parts = []
-            section_name = section_match.group(1).lower()
-            in_args = section_name in ("args", "arguments", "parameters", "params")
-            continue
-
-        if not in_args:
-            continue
-
-        if ":" in stripped and not stripped.startswith(" "):
-            if current_param is not None:
-                result["params"][current_param] = "\n".join(current_desc_parts).strip()
-            param_part, _, desc_part = stripped.partition(":")
-            param_name = param_part.strip().split("(")[0].strip()
-            current_param = param_name
-            current_desc_parts = [desc_part.strip()]
-        elif current_param is not None:
-            aline = line
-            if aline.startswith("    "):
-                aline = aline[4:]
-            elif aline.startswith("\t"):
-                aline = aline[1:]
-            current_desc_parts.append(aline.strip())
-
-    if current_param is not None:
-        result["params"][current_param] = "\n".join(current_desc_parts).strip()
-
-    return result
-
-
-# ---------------------------------------------------------------------------
-# 类型常量
-# ---------------------------------------------------------------------------
-
-SIMPLE_TYPE_MAP = {
-    "str": "string",
-    "string": "string",
-    "int": "integer",
-    "integer": "integer",
-    "float": "number",
-    "number": "number",
-    "bool": "boolean",
-    "boolean": "boolean",
-    "list": "array",
-    "array": "array",
-    "dict": "object",
-    "object": "object",
-}
-
-ARRAY_TYPES = {"list", "List", "tuple", "Tuple", "set", "Set", "Sequence", "Iterable"}
-OBJECT_TYPES = {"dict", "Dict", "Mapping"}
-WRAPPER_TYPES = {"Optional"}
-SLOT_TYPES = {"ResourceSlot", "DeviceSlot"}
-
-
-# ---------------------------------------------------------------------------
-# 简单类型映射
-# ---------------------------------------------------------------------------
-
-
-def get_json_schema_type(type_str: str) -> str:
-    """简单类型名 -> JSON Schema type"""
-    return SIMPLE_TYPE_MAP.get(type_str.lower(), "string")
-
-
-# ---------------------------------------------------------------------------
-# AST 类型解析
-# ---------------------------------------------------------------------------
-
-
-def parse_type_node(type_str: str):
-    """将类型注解字符串解析为 AST 节点，失败返回 None。"""
-    import ast as _ast
-
-    try:
-        return _ast.parse(type_str.strip(), mode="eval").body
-    except Exception:
-        return None
-
-
-def _collect_bitor(node, out: list):
-    """递归收集 X | Y | Z 的所有分支。"""
-    import ast as _ast
-
-    if isinstance(node, _ast.BinOp) and isinstance(node.op, _ast.BitOr):
-        _collect_bitor(node.left, out)
-        _collect_bitor(node.right, out)
-    else:
-        out.append(node)
-
-
-def type_node_to_schema(
-    node,
-    import_map: Optional[Dict[str, str]] = None,
-) -> Dict[str, Any]:
-    """将 AST 类型注解节点递归转换为 JSON Schema dict。
-
-    当提供 import_map 时，对于未知类名会尝试通过 import_map 解析模块路径，
-    然后 import 真实类型对象来生成 schema (支持 TypedDict 等)。
-
-    映射规则:
-    - Optional[X]                    → X 的 schema (剥掉 Optional)
-    - Union[X, Y]                    → {"anyOf": [X_schema, Y_schema]}
-    - List[X] / Tuple[X] / Set[X]   → {"type": "array", "items": X_schema}
-    - Dict[K, V]                     → {"type": "object", "additionalProperties": V_schema}
-    - Literal["a", "b"]             → {"type": "string", "enum": ["a", "b"]}
-    - TypedDict (via import_map)     → {"type": "object", "properties": {...}}
-    - 基本类型 str/int/...          → {"type": "string"/"integer"/...}
-    """
-    import ast as _ast
-
-    # --- Name 节点: str / int / dict / ResourceSlot / 自定义类 ---
-    if isinstance(node, _ast.Name):
-        name = node.id
-        if name in SLOT_TYPES:
-            return {"$slot": name}
-        json_type = SIMPLE_TYPE_MAP.get(name.lower())
-        if json_type:
-            return {"type": json_type}
-        # 尝试通过 import_map 解析并 import 真实类型
-        if import_map and name in import_map:
-            type_obj = resolve_type_object(import_map[name])
-            if type_obj is not None:
-                return type_to_schema(type_obj)
-        # 未知类名 → 无法转 schema 的自定义类型默认当 object
-        return {"type": "object"}
-
-    if isinstance(node, _ast.Constant):
-        if isinstance(node.value, str):
-            return {"type": SIMPLE_TYPE_MAP.get(node.value.lower(), "string")}
-        return {"type": "string"}
-
-    # --- Subscript 节点: List[X], Dict[K,V], Optional[X], Literal[...] 等 ---
-    if isinstance(node, _ast.Subscript):
-        base_name = node.value.id if isinstance(node.value, _ast.Name) else ""
-
-        # Optional[X] → 剥掉
-        if base_name in WRAPPER_TYPES:
-            return type_node_to_schema(node.slice, import_map)
-
-        # Union[X, None] → 剥掉 None; Union[X, Y] → anyOf
-        if base_name == "Union":
-            elts = node.slice.elts if isinstance(node.slice, _ast.Tuple) else [node.slice]
-            non_none = [
-                e
-                for e in elts
-                if not (isinstance(e, _ast.Constant) and e.value is None)
-                and not (isinstance(e, _ast.Name) and e.id == "None")
-            ]
-            if len(non_none) == 1:
-                return type_node_to_schema(non_none[0], import_map)
-            if len(non_none) > 1:
-                return {"anyOf": [type_node_to_schema(e, import_map) for e in non_none]}
-            return {"type": "string"}
-
-        # Literal["a", "b", 1] → enum
-        if base_name == "Literal":
-            elts = node.slice.elts if isinstance(node.slice, _ast.Tuple) else [node.slice]
-            values = []
-            for e in elts:
-                if isinstance(e, _ast.Constant):
-                    values.append(e.value)
-                elif isinstance(e, _ast.Name):
-                    values.append(e.id)
-            if values:
-                return {"type": "string", "enum": values}
-            return {"type": "string"}
-
-        # List / Tuple / Set → array
-        if base_name in ARRAY_TYPES:
-            if isinstance(node.slice, _ast.Tuple) and node.slice.elts:
-                inner_node = node.slice.elts[0]
-            else:
-                inner_node = node.slice
-            return {"type": "array", "items": type_node_to_schema(inner_node, import_map)}
-
-        # Dict → object
-        if base_name in OBJECT_TYPES:
-            schema: Dict[str, Any] = {"type": "object"}
-            if isinstance(node.slice, _ast.Tuple) and len(node.slice.elts) >= 2:
-                val_node = node.slice.elts[1]
-                # Dict[str, Any] → 不加 additionalProperties (Any 等同于无约束)
-                is_any = (isinstance(val_node, _ast.Name) and val_node.id == "Any") or (
-                    isinstance(val_node, _ast.Constant) and val_node.value is None
-                )
-                if not is_any:
-                    val_schema = type_node_to_schema(val_node, import_map)
-                    schema["additionalProperties"] = val_schema
-            return schema
-
-    # --- BinOp: X | Y (Python 3.10+) → 当 Union 处理 ---
-    if isinstance(node, _ast.BinOp) and isinstance(node.op, _ast.BitOr):
-        parts: list = []
-        _collect_bitor(node, parts)
-        non_none = [
-            p
-            for p in parts
-            if not (isinstance(p, _ast.Constant) and p.value is None)
-            and not (isinstance(p, _ast.Name) and p.id == "None")
-        ]
-        if len(non_none) == 1:
-            return type_node_to_schema(non_none[0], import_map)
-        if len(non_none) > 1:
-            return {"anyOf": [type_node_to_schema(p, import_map) for p in non_none]}
-        return {"type": "string"}
-
-    return {"type": "string"}
-
-
-# ---------------------------------------------------------------------------
-# 真实类型对象解析 (import-based)
-# ---------------------------------------------------------------------------
-
-
-def resolve_type_object(type_ref: str) -> Optional[Any]:
-    """通过 'module.path:ClassName' 格式的引用 import 并返回真实类型对象。
-
-    对于 typing 内置名 (str, int, List 等) 直接返回 None (由 AST 路径处理)。
-    import 失败时静默返回 None。
-    """
-    if ":" not in type_ref:
-        return None
-    try:
-        return import_class(type_ref)
-    except Exception:
-        return None
-
-
-def is_typed_dict_class(obj: Any) -> bool:
-    """检查对象是否是 TypedDict 类。"""
-    if obj is None:
-        return False
-    try:
-        from typing_extensions import is_typeddict
-
-        return is_typeddict(obj)
-    except ImportError:
-        if isinstance(obj, type):
-            return hasattr(obj, "__required_keys__") and hasattr(obj, "__optional_keys__")
-        return False
-
-
-def type_to_schema(tp: Any) -> Dict[str, Any]:
-    """将真实 typing 对象递归转换为 JSON Schema dict。
-
-    支持:
-    - 基本类型: str, int, float, bool → {"type": "string"/"integer"/...}
-    - typing 泛型: List[X], Dict[K,V], Optional[X], Union[X,Y], Literal[...]
-    - TypedDict → {"type": "object", "properties": {...}, "required": [...]}
-    - 自定义类 (ResourceSlot 等) → {"$slot": "..."} 或 {"type": "string"}
-    """
-    origin = getattr(tp, "__origin__", None)
-    args = getattr(tp, "__args__", None)
-
-    # --- None / NoneType ---
-    if tp is type(None):
-        return {"type": "null"}
-
-    # --- 基本类型 ---
-    if tp is str:
-        return {"type": "string"}
-    if tp is int:
-        return {"type": "integer"}
-    if tp is float:
-        return {"type": "number"}
-    if tp is bool:
-        return {"type": "boolean"}
-
-    # --- TypedDict ---
-    if is_typed_dict_class(tp):
-        try:
-            return TypedDictMessageInstance.get_json_schema_from_typed_dict(tp)
-        except Exception:
-            return {"type": "object"}
-
-    # --- Literal ---
-    if origin is typing.Literal:
-        values = list(args) if args else []
-        return {"type": "string", "enum": values}
-
-    # --- Optional / Union ---
-    if origin is typing.Union:
-        non_none = [a for a in (args or ()) if a is not type(None)]
-        if len(non_none) == 1:
-            return type_to_schema(non_none[0])
-        if len(non_none) > 1:
-            return {"anyOf": [type_to_schema(a) for a in non_none]}
-        return {"type": "string"}
-
-    # --- List / Sequence / Set / Tuple / Iterable ---
-    if origin in (list, tuple, set, frozenset) or (
-        origin is not None
-        and getattr(origin, "__name__", "") in ("Sequence", "Iterable", "Iterator", "MutableSequence")
-    ):
-        if args:
-            return {"type": "array", "items": type_to_schema(args[0])}
-        return {"type": "array"}
-
-    # --- Dict / Mapping ---
-    if origin in (dict,) or (origin is not None and getattr(origin, "__name__", "") in ("Mapping", "MutableMapping")):
-        schema: Dict[str, Any] = {"type": "object"}
-        if args and len(args) >= 2:
-            schema["additionalProperties"] = type_to_schema(args[1])
-        return schema
-
-    # --- Slot 类型 ---
-    if isinstance(tp, type):
-        name = tp.__name__
-        if name in SLOT_TYPES:
-            return {"$slot": name}
-
-    # --- 其他未知类型 fallback ---
-    if isinstance(tp, type):
-        return {"type": "object"}
-    return {"type": "string"}
-
-
-# ---------------------------------------------------------------------------
-# Slot / Placeholder 检测
-# ---------------------------------------------------------------------------
-
-
-def detect_slot_type(ptype) -> Tuple[Optional[str], bool]:
-    """检测参数类型是否为 ResourceSlot / DeviceSlot。
-
-    兼容多种格式:
-    - runtime: "unilabos.registry.placeholder_type:ResourceSlot"
-    - runtime tuple: ("list", "unilabos.registry.placeholder_type:ResourceSlot")
-    - AST 裸名: "ResourceSlot", "List[ResourceSlot]", "Optional[ResourceSlot]"
-
-    Returns: (slot_name | None, is_list)
-    """
-    ptype_str = str(ptype)
-
-    # 快速路径: 字符串里根本没有 Slot
-    if "ResourceSlot" not in ptype_str and "DeviceSlot" not in ptype_str:
-        return (None, False)
-
-    # runtime 格式: 完整模块路径
-    if isinstance(ptype, str):
-        if ptype.endswith(":ResourceSlot") or ptype == "ResourceSlot":
-            return ("ResourceSlot", False)
-        if ptype.endswith(":DeviceSlot") or ptype == "DeviceSlot":
-            return ("DeviceSlot", False)
-        # AST 复杂格式: List[ResourceSlot], Optional[ResourceSlot] 等
-        if "[" in ptype:
-            node = parse_type_node(ptype)
-            if node is not None:
-                schema = type_node_to_schema(node)
-                # 直接是 slot
-                if "$slot" in schema:
-                    return (schema["$slot"], False)
-                # array 包裹 slot: {"type": "array", "items": {"$slot": "..."}}
-                items = schema.get("items", {})
-                if isinstance(items, dict) and "$slot" in items:
-                    return (items["$slot"], True)
-        return (None, False)
-
-    # runtime tuple 格式
-    if isinstance(ptype, tuple) and len(ptype) == 2:
-        inner_str = str(ptype[1])
-        if "ResourceSlot" in inner_str:
-            return ("ResourceSlot", True)
-        if "DeviceSlot" in inner_str:
-            return ("DeviceSlot", True)
-
-    return (None, False)
-
-
-def detect_placeholder_keys(params: list) -> Dict[str, str]:
-    """Detect parameters that reference ResourceSlot or DeviceSlot."""
-    result: Dict[str, str] = {}
-    for p in params:
-        ptype = p.get("type", "")
-        if "ResourceSlot" in str(ptype):
-            result[p["name"]] = "unilabos_resources"
-        elif "DeviceSlot" in str(ptype):
-            result[p["name"]] = "unilabos_devices"
-    return result
-
-
-# ---------------------------------------------------------------------------
-# Handle 规范化
-# ---------------------------------------------------------------------------
-
-
-def normalize_ast_handles(handles_raw: Any) -> List[Dict[str, Any]]:
-    """Convert AST-parsed handle structures to the standard registry format."""
-    if not handles_raw:
-        return []
-
-    # handle_type → io_type 映射 (AST 内部类名 → YAML 标准字段值)
-    _HANDLE_TYPE_TO_IO_TYPE = {
-        "input": "target",
-        "output": "source",
-        "action_input": "action_target",
-        "action_output": "action_source",
-    }
-
-    result: List[Dict[str, Any]] = []
-    for h in handles_raw:
-        if isinstance(h, dict):
-            call = h.get("_call", "")
-            if "InputHandle" in call:
-                handle_type = "input"
-            elif "OutputHandle" in call:
-                handle_type = "output"
-            elif "ActionInputHandle" in call:
-                handle_type = "action_input"
-            elif "ActionOutputHandle" in call:
-                handle_type = "action_output"
-            else:
-                handle_type = h.get("handle_type", "unknown")
-
-            io_type = _HANDLE_TYPE_TO_IO_TYPE.get(handle_type, handle_type)
-
-            entry: Dict[str, Any] = {
-                "handler_key": h.get("key", ""),
-                "data_type": h.get("data_type", ""),
-                "io_type": io_type,
-            }
-            side = h.get("side")
-            if side:
-                if isinstance(side, str) and "." in side:
-                    val = side.rsplit(".", 1)[-1]
-                    side = val.lower() if val in ("LEFT", "RIGHT", "TOP", "BOTTOM") else val
-                entry["side"] = side
-            label = h.get("label")
-            if label:
-                entry["label"] = label
-            data_key = h.get("data_key")
-            if data_key:
-                entry["data_key"] = data_key
-            data_source = h.get("data_source")
-            if data_source:
-                if isinstance(data_source, str) and "." in data_source:
-                    val = data_source.rsplit(".", 1)[-1]
-                    data_source = val.lower() if val in ("HANDLE", "EXECUTOR") else val
-                entry["data_source"] = data_source
-            description = h.get("description")
-            if description:
-                entry["description"] = description
-
-            result.append(entry)
-    return result
-
-
-def normalize_ast_action_handles(handles_raw: Any) -> Dict[str, Any]:
-    """Convert AST-parsed action handle list to {"input": [...], "output": [...]}.
-
-    Mirrors the runtime behavior of decorators._action_handles_to_dict:
-      - ActionInputHandle  => grouped under "input"
-      - ActionOutputHandle => grouped under "output"
-    Field mapping: key -> handler_key (matches Pydantic serialization_alias).
-    """
-    if not handles_raw or not isinstance(handles_raw, list):
-        return {}
-
-    input_list: List[Dict[str, Any]] = []
-    output_list: List[Dict[str, Any]] = []
-
-    for h in handles_raw:
-        if not isinstance(h, dict):
-            continue
-        call = h.get("_call", "")
-        is_input = "ActionInputHandle" in call or "InputHandle" in call
-        is_output = "ActionOutputHandle" in call or "OutputHandle" in call
-
-        entry: Dict[str, Any] = {
-            "handler_key": h.get("key", ""),
-            "data_type": h.get("data_type", ""),
-            "label": h.get("label", ""),
-        }
-        for opt_key in ("side", "data_key", "data_source", "description", "io_type"):
-            val = h.get(opt_key)
-            if val is not None:
-                # Only resolve enum-style refs (e.g. DataSource.HANDLE -> handle) for data_source/side
-                # data_key values like "wells.@flatten", "@this.0@@@plate" must be preserved as-is
-                if (
-                    isinstance(val, str)
-                    and "." in val
-                    and opt_key not in ("io_type", "data_key")
-                ):
-                    val = val.rsplit(".", 1)[-1].lower()
-                entry[opt_key] = val
-
-        # io_type: only add when explicitly set; do not default output to "sink" (YAML convention omits it)
-        if "io_type" not in entry and is_input:
-            entry["io_type"] = "source"
-
-        if is_input:
-            input_list.append(entry)
-        elif is_output:
-            output_list.append(entry)
-
-    result: Dict[str, Any] = {}
-    if input_list:
-        result["input"] = input_list
-    # Always include output (empty list when no outputs) to match YAML
-    result["output"] = output_list
-    return result
-
-
-# ---------------------------------------------------------------------------
-# Schema 辅助
-# ---------------------------------------------------------------------------
-
-
-def wrap_action_schema(
-    goal_schema: Dict[str, Any],
-    action_name: str,
-    description: str = "",
-    result_schema: Optional[Dict[str, Any]] = None,
-    feedback_schema: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
-    """
-    将 goal 参数 schema 包装为标准的 action schema 格式:
-    { "properties": { "goal": ..., "feedback": ..., "result": ... }, ... }
-    """
-    # 去掉 auto- 前缀用于 title/description，与 YAML 路径保持一致
-    display_name = action_name.removeprefix("auto-")
-    return {
-        "title": f"{display_name}参数",
-        "description": description or f"{display_name}的参数schema",
-        "type": "object",
-        "properties": {
-            "goal": goal_schema,
-            "feedback": feedback_schema or {},
-            "result": result_schema or {},
-        },
-        "required": ["goal"],
-    }
-
-
-def preserve_field_descriptions(new_schema: Dict[str, Any], prev_schema: Dict[str, Any]):
-    """递归保留之前 schema 中各字段的 description / title。
-
-    覆盖顶层以及嵌套 properties（如 goal.properties.xxx.description）。
-    """
-    if not prev_schema or not new_schema:
-        return
-    prev_props = prev_schema.get("properties", {})
-    new_props = new_schema.get("properties", {})
-    for field_name, prev_field in prev_props.items():
-        if field_name not in new_props:
-            continue
-        new_field = new_props[field_name]
-        if not isinstance(prev_field, dict) or not isinstance(new_field, dict):
-            continue
-        if "title" in prev_field:
-            new_field.setdefault("title", prev_field["title"])
-        if "description" in prev_field:
-            new_field.setdefault("description", prev_field["description"])
-        if "properties" in prev_field and "properties" in new_field:
-            preserve_field_descriptions(new_field, prev_field)
-
-
-def strip_ros_descriptions(schema: Any):
-    """递归清除 ROS schema 中自动生成的无意义 description（含 rosidl_parser 内存地址）。"""
-    if isinstance(schema, dict):
-        desc = schema.get("description", "")
-        if isinstance(desc, str) and "rosidl_parser" in desc:
-            del schema["description"]
-        for v in schema.values():
-            strip_ros_descriptions(v)
-    elif isinstance(schema, list):
-        for item in schema:
-            strip_ros_descriptions(item)
-
-
-# ---------------------------------------------------------------------------
-# 深度对比
-# ---------------------------------------------------------------------------
-
-
-def _short(val, limit=120):
-    """截断过长的值用于日志显示。"""
-    s = repr(val)
-    return s if len(s) <= limit else s[:limit] + "..."
-
-
-def deep_diff(old, new, path="", max_depth=10) -> list:
-    """递归对比两个对象，返回所有差异的描述列表。"""
-    diffs = []
-    if max_depth <= 0:
-        if old != new:
-            diffs.append(f"{path}: (达到最大深度) OLD≠NEW")
-        return diffs
-
-    if type(old) != type(new):
-        diffs.append(f"{path}: 类型不同 OLD={type(old).__name__}({_short(old)}) NEW={type(new).__name__}({_short(new)})")
-        return diffs
-
-    if isinstance(old, dict):
-        old_keys = set(old.keys())
-        new_keys = set(new.keys())
-        for k in sorted(new_keys - old_keys):
-            diffs.append(f"{path}.{k}: 新增字段 (AST有, YAML无) = {_short(new[k])}")
-        for k in sorted(old_keys - new_keys):
-            diffs.append(f"{path}.{k}: 缺失字段 (YAML有, AST无) = {_short(old[k])}")
-        for k in sorted(old_keys & new_keys):
-            diffs.extend(deep_diff(old[k], new[k], f"{path}.{k}", max_depth - 1))
-    elif isinstance(old, (list, tuple)):
-        if len(old) != len(new):
-            diffs.append(f"{path}: 列表长度不同 OLD={len(old)} NEW={len(new)}")
-        for i in range(min(len(old), len(new))):
-            diffs.extend(deep_diff(old[i], new[i], f"{path}[{i}]", max_depth - 1))
-        if len(new) > len(old):
-            for i in range(len(old), len(new)):
-                diffs.append(f"{path}[{i}]: 新增元素 = {_short(new[i])}")
-        elif len(old) > len(new):
-            for i in range(len(new), len(old)):
-                diffs.append(f"{path}[{i}]: 缺失元素 = {_short(old[i])}")
-    else:
-        if old != new:
-            diffs.append(f"{path}: OLD={_short(old)} NEW={_short(new)}")
-    return diffs
-
-
-# ---------------------------------------------------------------------------
-# MRO 方法参数解析
-# ---------------------------------------------------------------------------
-
-
-def resolve_method_params_via_import(module_str: str, method_name: str) -> Dict[str, str]:
-    """当 AST 方法参数为空 (如 *args, **kwargs) 时, import class 并通过 MRO 获取真实方法参数.
-
-    返回 identity mapping {param_name: param_name}.
-    """
-    if not module_str or ":" not in module_str:
-        return {}
-    try:
-        cls = import_class(module_str)
-    except Exception as e:
-        _logger.debug(f"[AST] resolve_method_params_via_import: import_class('{module_str}') failed: {e}")
-        return {}
-
-    try:
-        for base_cls in cls.__mro__:
-            if method_name not in base_cls.__dict__:
-                continue
-            method = base_cls.__dict__[method_name]
-            actual = getattr(method, "__wrapped__", method)
-            if isinstance(actual, (staticmethod, classmethod)):
-                actual = actual.__func__
-            if not callable(actual):
-                continue
-            sig = inspect.signature(actual, follow_wrapped=True)
-            params = [
-                p.name for p in sig.parameters.values()
-                if p.name not in ("self", "cls")
-                and p.kind not in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
-            ]
-            if params:
-                return {p: p for p in params}
-    except Exception as e:
-        _logger.debug(f"[AST] resolve_method_params_via_import: MRO walk for '{method_name}' failed: {e}")
-    return {}

unilabos/resources/container.py

@@ -1,6 +1,10 @@
+import json
 from typing import Dict, Any
 
 from pylabrobot.resources import Container
+from unilabos_msgs.msg import Resource
+
+from unilabos.ros.msgs.message_converter import convert_from_ros_msg
 
 
 class RegularContainer(Container):
@@ -12,14 +16,12 @@ class RegularContainer(Container):
             kwargs["size_y"] = 0
         if "size_z" not in kwargs:
             kwargs["size_z"] = 0
-        if "category" not in kwargs:
-            kwargs["category"] = "container"
-
         self.kwargs = kwargs
-        super().__init__(*args, **kwargs)
+        self.state = {}
+        super().__init__(*args, category="container", **kwargs)
 
     def load_state(self, state: Dict[str, Any]):
-        super().load_state(state)
+        self.state = state
 
 
 def get_regular_container(name="container"):
@@ -27,6 +29,7 @@ def get_regular_container(name="container"):
     r.category = "container"
     return r
 
+#
 # class RegularContainer(object):
 #     # 第一个参数必须是id传入
 #     # noinspection PyShadowingBuiltins
@@ -86,4 +89,4 @@ def get_regular_container(name="container"):
 #         return to_dict
 #
 #     def __str__(self):
-#         return f"{self.id}"
+#         return f"{self.id}"

unilabos/resources/graphio.py

@@ -42,7 +42,7 @@ def canonicalize_nodes_data(
     Returns:
         ResourceTreeSet: 标准化后的资源树集合
     """
-    print_status(f"{len(nodes)} Resources loaded:", "info")
+    print_status(f"{len(nodes)} Resources loaded", "info")
 
     # 第一步：基本预处理（处理graphml的label字段）
     outer_host_node_id = None
@@ -76,7 +76,7 @@ def canonicalize_nodes_data(
             if sample_id:
                 logger.error(f"{node}的sample_id参数已弃用，sample_id: {sample_id}")
         for k in list(node.keys()):
-            if k not in ["id", "uuid", "name", "description", "schema", "model", "icon", "parent_uuid", "parent", "type", "class", "position", "config", "data", "children", "pose", "extra", "machine_name"]:
+            if k not in ["id", "uuid", "name", "description", "schema", "model", "icon", "parent_uuid", "parent", "type", "class", "position", "config", "data", "children", "pose", "extra"]:
                 v = node.pop(k)
                 node["config"][k] = v
     if outer_host_node_id is not None:
@@ -288,15 +288,6 @@ def read_node_link_json(
     physical_setup_graph = nx.node_link_graph(graph_data, edges="links", multigraph=False)
     handle_communications(physical_setup_graph)
 
-    # Stamp machine_name on device trees only (resources are cloud-managed)
-    local_machine = BasicConfig.machine_name or "本地"
-    for tree in resource_tree_set.trees:
-        if tree.root_node.res_content.type != "device":
-            continue
-        for node in tree.get_all_nodes():
-            if not node.res_content.machine_name:
-                node.res_content.machine_name = local_machine
-
     return physical_setup_graph, resource_tree_set, standardized_links
 
 
@@ -381,15 +372,6 @@ def read_graphml(graphml_file: str) -> tuple[nx.Graph, ResourceTreeSet, List[Dic
     physical_setup_graph = nx.node_link_graph(graph_data, link="links", multigraph=False)
     handle_communications(physical_setup_graph)
 
-    # Stamp machine_name on device trees only (resources are cloud-managed)
-    local_machine = BasicConfig.machine_name or "本地"
-    for tree in resource_tree_set.trees:
-        if tree.root_node.res_content.type != "device":
-            continue
-        for node in tree.get_all_nodes():
-            if not node.res_content.machine_name:
-                node.res_content.machine_name = local_machine
-
     return physical_setup_graph, resource_tree_set, standardized_links
 
 

unilabos/resources/resource_tracker.py

@@ -16,7 +16,6 @@ if TYPE_CHECKING:
 
 
 EXTRA_CLASS = "unilabos_resource_class"
-FRONTEND_POSE_EXTRA = "unilabos_frontend_pose_extra"
 EXTRA_SAMPLE_UUID = "sample_uuid"
 EXTRA_UNILABOS_SAMPLE_UUID = "unilabos_sample_uuid"
 
@@ -101,7 +100,6 @@ class ResourceDictPosition(BaseModel):
     cross_section_type: Literal["rectangle", "circle", "rounded_rectangle"] = Field(
         description="Cross section type", default="rectangle"
     )
-    extra: Optional[Dict[str, Any]] = Field(description="Extra data", default=None)
 
 
 class ResourceDictType(TypedDict):
@@ -120,7 +118,6 @@ class ResourceDictType(TypedDict):
     config: Dict[str, Any]
     data: Dict[str, Any]
     extra: Dict[str, Any]
-    machine_name: str
 
 
 # 统一的资源字典模型，parent 自动序列化为 parent_uuid，children 不序列化
@@ -142,7 +139,6 @@ class ResourceDict(BaseModel):
     config: Dict[str, Any] = Field(description="Resource configuration")
     data: Dict[str, Any] = Field(description="Resource data, eg: container liquid data")
     extra: Dict[str, Any] = Field(description="Extra data, eg: slot index")
-    machine_name: str = Field(description="Machine this resource belongs to", default="")
 
     @field_serializer("parent_uuid")
     def _serialize_parent(self, parent_uuid: Optional["ResourceDict"]):
@@ -198,30 +194,22 @@ class ResourceDictInstance(object):
         self.typ = "dict"
 
     @classmethod
-    def get_resource_instance_from_dict(cls, content: ResourceDictType) -> "ResourceDictInstance":
+    def get_resource_instance_from_dict(cls, content: Dict[str, Any]) -> "ResourceDictInstance":
         """从字典创建资源实例"""
         if "id" not in content:
             content["id"] = content["name"]
         if "uuid" not in content:
             content["uuid"] = str(uuid.uuid4())
         if "description" in content and content["description"] is None:
-            # noinspection PyTypedDict
             del content["description"]
         if "model" in content and content["model"] is None:
-            # noinspection PyTypedDict
             del content["model"]
-        # noinspection PyTypedDict
         if "schema" in content and content["schema"] is None:
-            # noinspection PyTypedDict
             del content["schema"]
-        # noinspection PyTypedDict
         if "x" in content.get("position", {}):
             # 说明是老版本的position格式，转换成新的
-            # noinspection PyTypedDict
             content["position"] = {"position": content["position"]}
-        # noinspection PyTypedDict
         if not content.get("class"):
-            # noinspection PyTypedDict
             content["class"] = ""
         if not content.get("config"):  # todo: 后续从后端保证字段非空
             content["config"] = {}
@@ -232,18 +220,16 @@ class ResourceDictInstance(object):
         if "position" in content:
             pose = content.get("pose", {})
             if "position" not in pose:
-                # noinspection PyTypedDict
                 if "position" in content["position"]:
-                    # noinspection PyTypedDict
                     pose["position"] = content["position"]["position"]
                 else:
-                    pose["position"] = ResourceDictPositionObjectType(x=0, y=0, z=0)
+                    pose["position"] = {"x": 0, "y": 0, "z": 0}
             if "size" not in pose:
-                pose["size"] = ResourceDictPositionSizeType(
-                    width= content["config"].get("size_x", 0),
-                    height= content["config"].get("size_y", 0),
-                    depth= content["config"].get("size_z", 0),
-                )
+                pose["size"] = {
+                    "width": content["config"].get("size_x", 0),
+                    "height": content["config"].get("size_y", 0),
+                    "depth": content["config"].get("size_z", 0),
+                }
             content["pose"] = pose
         try:
             res_dict = ResourceDict.model_validate(content)
@@ -411,7 +397,7 @@ class ResourceTreeSet(object):
             )
 
     @classmethod
-    def from_plr_resources(cls, resources: List["PLRResource"], known_newly_created=False, old_size=False) -> "ResourceTreeSet":
+    def from_plr_resources(cls, resources: List["PLRResource"], known_newly_created=False) -> "ResourceTreeSet":
         """
         从plr资源创建ResourceTreeSet
         """
@@ -434,20 +420,13 @@ class ResourceTreeSet(object):
                 "resource_group": "resource_group",
                 "trash": "trash",
                 "plate_adapter": "plate_adapter",
-                "consumable": "consumable",
-                "tool": "tool",
-                "condenser": "condenser",
-                "crucible": "crucible",
-                "reagent_bottle": "reagent_bottle",
-                "flask": "flask",
-                "beaker": "beaker",
             }
             if source in replace_info:
                 return replace_info[source]
             elif source is None:
                 return ""
             else:
-                logger.trace(f"转换pylabrobot的时候，出现未知类型 {source}")
+                print("转换pylabrobot的时候，出现未知类型", source)
                 return source
 
         def build_uuid_mapping(res: "PLRResource", uuid_list: list, parent_uuid: Optional[str] = None):
@@ -484,7 +463,6 @@ class ResourceTreeSet(object):
                 "position3d": raw_pos,
                 "rotation": d["rotation"],
                 "cross_section_type": d.get("cross_section_type", "rectangle"),
-                "extra": extra.get(FRONTEND_POSE_EXTRA)
             }
 
             # 先构建当前节点的字典（不包含children）
@@ -502,7 +480,7 @@ class ResourceTreeSet(object):
                     k: v
                     for k, v in d.items()
                     if k
-                    not in ([
+                    not in [
                         "name",
                         "children",
                         "parent_name",
@@ -513,15 +491,7 @@ class ResourceTreeSet(object):
                         "size_z",
                         "cross_section_type",
                         "bottom_type",
-                    ] if not old_size else [
-                        "name",
-                        "children",
-                        "parent_name",
-                        "location",
-                        "rotation",
-                        "cross_section_type",
-                        "bottom_type",
-                    ])
+                    ]
                 },
                 "data": states[d["name"]],
                 "extra": extra,
@@ -578,7 +548,6 @@ class ResourceTreeSet(object):
             name_to_uuid[node.res_content.name] = node.res_content.uuid
             all_states[node.res_content.name] = node.res_content.data
             name_to_extra[node.res_content.name] = node.res_content.extra
-            name_to_extra[node.res_content.name][FRONTEND_POSE_EXTRA] = node.res_content.pose.extra
             name_to_extra[node.res_content.name][EXTRA_CLASS] = node.res_content.klass
             for child in node.children:
                 collect_node_data(child, name_to_uuid, all_states, name_to_extra)
@@ -820,8 +789,7 @@ class ResourceTreeSet(object):
             if remote_root_type == "device":
                 # 情况1: 一级是 device
                 if remote_root_id not in local_device_map:
-                    if remote_root_id != "host_node":
-                        logger.warning(f"Device '{remote_root_id}' 在本地不存在，跳过该 device 下的物料同步")
+                    logger.warning(f"Device '{remote_root_id}' 在本地不存在，跳过该 device 下的物料同步")
                     continue
 
                 local_device = local_device_map[remote_root_id]
@@ -868,27 +836,14 @@ class ResourceTreeSet(object):
                                 f"从远端同步了 {added_count} 个物料子树"
                             )
                     else:
-                        # 二级物料已存在，比较三级子节点是否缺失
-                        local_material = local_children_map[remote_child_name]
-                        local_material_children_map = {child.res_content.name: child for child in
-                                                       local_material.children}
-                        added_count = 0
-                        for remote_sub in remote_child.children:
-                            remote_sub_name = remote_sub.res_content.name
-                            if remote_sub_name not in local_material_children_map:
-                                remote_sub.res_content.parent = local_material.res_content
-                                local_material.children.append(remote_sub)
-                                added_count += 1
-                            else:
-                                logger.info(
-                                    f"物料 '{remote_root_id}/{remote_child_name}/{remote_sub_name}' "
-                                    f"已存在，跳过"
-                                )
-                        if added_count > 0:
-                            logger.info(
-                                f"物料 '{remote_root_id}/{remote_child_name}': "
-                                f"从远端同步了 {added_count} 个子物料"
-                            )
+                        # 情况2: 二级是物料（不是 device）
+                        if remote_child_name not in local_children_map:
+                            # 引入整个子树
+                            remote_child.res_content.parent = local_device.res_content
+                            local_device.children.append(remote_child)
+                            logger.info(f"Device '{remote_root_id}': 从远端同步物料子树 '{remote_child_name}'")
+                        else:
+                            logger.info(f"物料 '{remote_root_id}/{remote_child_name}' 已存在，跳过")
             else:
                 # 情况1: 一级节点是物料（不是 device）
                 # 检查是否已存在
@@ -911,7 +866,7 @@ class ResourceTreeSet(object):
 
         return self
 
-    def dump(self, old_position=False) -> List[List[Dict[str, Any]]]:
+    def dump(self) -> List[List[Dict[str, Any]]]:
         """
         将 ResourceTreeSet 序列化为嵌套列表格式
 
@@ -927,10 +882,6 @@ class ResourceTreeSet(object):
             # 获取树的所有节点并序列化
             tree_nodes = [node.res_content.model_dump(by_alias=True) for node in tree.get_all_nodes()]
             result.append(tree_nodes)
-        if old_position:
-            for r in result:
-                for rr in r:
-                    rr["position"] = rr["pose"]["position"]
         return result
 
     @classmethod

unilabos/ros/msgs/message_converter.py

@@ -11,7 +11,6 @@ from io import StringIO
 from typing import Iterable, Any, Dict, Type, TypeVar, Union
 
 import yaml
-from msgcenterpy.instances.ros2_instance import ROS2MessageInstance
 from pydantic import BaseModel
 from dataclasses import asdict, is_dataclass
 
@@ -717,19 +716,6 @@ def ros_field_type_to_json_schema(
     # return {'type': 'object', 'description': f'未知类型: {field_type}'}
 
 
-def _strip_rosidl_descriptions(schema: Any) -> None:
-    """递归清除 rosidl_parser 自动生成的无意义 description（含内存地址）。"""
-    if isinstance(schema, dict):
-        desc = schema.get("description", "")
-        if isinstance(desc, str) and "rosidl_parser" in desc:
-            del schema["description"]
-        for v in schema.values():
-            _strip_rosidl_descriptions(v)
-    elif isinstance(schema, list):
-        for item in schema:
-            _strip_rosidl_descriptions(item)
-
-
 def ros_message_to_json_schema(msg_class: Any, field_name: str) -> Dict[str, Any]:
     """
     将 ROS 消息类转换为 JSON Schema
@@ -741,10 +727,46 @@ def ros_message_to_json_schema(msg_class: Any, field_name: str) -> Dict[str, Any
     Returns:
         对应的 JSON Schema 定义
     """
-    schema = ROS2MessageInstance(msg_class()).get_json_schema()
+    schema = {"type": "object", "properties": {}, "required": []}
+
+    # 优先使用字段名作为标题，否则使用类名
     schema["title"] = field_name
-    schema.pop("description", None)
-    _strip_rosidl_descriptions(schema)
+
+    # 获取消息的字段和字段类型
+    try:
+        for ind, slot_info in enumerate(msg_class._fields_and_field_types.items()):
+            slot_name, slot_type = slot_info
+            type_info = msg_class.SLOT_TYPES[ind]
+            field_schema = ros_field_type_to_json_schema(type_info, slot_name)
+            schema["properties"][slot_name] = field_schema
+            schema["required"].append(slot_name)
+        # if hasattr(msg_class, 'get_fields_and_field_types'):
+        #     fields_and_types = msg_class.get_fields_and_field_types()
+        #
+        #     for field_name, field_type in fields_and_types.items():
+        #         # 将 ROS 字段类型转换为 JSON Schema
+        #         field_schema = ros_field_type_to_json_schema(field_type)
+        #
+        #         schema['properties'][field_name] = field_schema
+        #         schema['required'].append(field_name)
+        # elif hasattr(msg_class, '__slots__') and hasattr(msg_class, '_fields_and_field_types'):
+        #     # 直接从实例属性获取
+        #     for field_name in msg_class.__slots__:
+        #         # 移除前导下划线（如果有）
+        #         clean_name = field_name[1:] if field_name.startswith('_') else field_name
+        #
+        #         # 从 _fields_and_field_types 获取类型
+        #         if clean_name in msg_class._fields_and_field_types:
+        #             field_type = msg_class._fields_and_field_types[clean_name]
+        #             field_schema = ros_field_type_to_json_schema(field_type)
+        #
+        #             schema['properties'][clean_name] = field_schema
+        #             schema['required'].append(clean_name)
+    except Exception as e:
+        # 如果获取字段类型失败，添加错误信息
+        schema["description"] = f"解析消息字段时出错: {str(e)}"
+        logger.error(f"解析 {msg_class.__name__} 消息字段失败: {str(e)}")
+
     return schema
 
 
@@ -791,8 +813,6 @@ def ros_action_to_json_schema(
         "required": ["goal"],
     }
 
-    _strip_rosidl_descriptions(schema)
-
     # 保留之前 schema 中 goal/feedback/result 下一级字段的 description
     if previous_schema:
         _preserve_field_descriptions(schema, previous_schema)

unilabos/ros/nodes/base_device_node.py

@@ -34,8 +34,7 @@ from unilabos_msgs.action import SendCmd
 from unilabos_msgs.srv._serial_command import SerialCommand_Request, SerialCommand_Response
 
 from unilabos.config.config import BasicConfig
-from unilabos.registry.decorators import get_topic_config
-from unilabos.utils.decorator import get_all_subscriptions
+from unilabos.utils.decorator import get_topic_config, get_all_subscriptions
 
 from unilabos.resources.container import RegularContainer
 from unilabos.resources.graphio import (
@@ -58,7 +57,6 @@ from unilabos_msgs.msg import Resource  # type: ignore
 
 from unilabos.resources.resource_tracker import (
     DeviceNodeResourceTracker,
-    ResourceDictType,
     ResourceTreeSet,
     ResourceTreeInstance,
     ResourceDictInstance,
@@ -196,9 +194,9 @@ class PropertyPublisher:
         self._value = None
         try:
             self.publisher_ = node.create_publisher(msg_type, f"{name}", qos)
-        except Exception as e:
+        except AttributeError as ex:
             self.node.lab_logger().error(
-                f"StatusError, DeviceId: {self.node.device_id} 创建发布者 {name} 失败，可能由于注册表有误，类型: {msg_type}，错误: {e}"
+                f"创建发布者 {name} 失败，可能由于注册表有误，类型: {msg_type}，错误: {ex}\n{traceback.format_exc()}"
             )
         self.timer = node.create_timer(self.timer_period, self.publish_property)
         self.__loop = ROS2DeviceNode.get_asyncio_loop()
@@ -571,11 +569,9 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 future.add_done_callback(done_cb)
             except ImportError:
                 self.lab_logger().error("Host请求添加物料时，本环境并不存在pylabrobot")
-                res.response = get_result_info_str(traceback.format_exc(), False, {})
             except Exception as e:
                 self.lab_logger().error("Host请求添加物料时出错")
                 self.lab_logger().error(traceback.format_exc())
-                res.response = get_result_info_str(traceback.format_exc(), False, {})
             return res
 
         # noinspection PyTypeChecker
@@ -598,12 +594,6 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 self.s2c_resource_tree,  # type: ignore
                 callback_group=self.callback_group,
             ),
-            "s2c_device_manage": self.create_service(
-                SerialCommand,
-                f"/srv{self.namespace}/s2c_device_manage",
-                self.s2c_device_manage,  # type: ignore
-                callback_group=self.callback_group,
-            ),
         }
 
         # 向全局在线设备注册表添加设备信息
@@ -1072,48 +1062,6 @@ class BaseROS2DeviceNode(Node, Generic[T]):
 
         return res
 
-    async def s2c_device_manage(self, req: SerialCommand_Request, res: SerialCommand_Response):
-        """Handle add/remove device requests from HostNode via SerialCommand."""
-        try:
-            cmd = json.loads(req.command)
-            action = cmd.get("action", "")
-            data = cmd.get("data", {})
-            device_id = data.get("device_id", "")
-
-            if not device_id:
-                res.response = json.dumps({"success": False, "error": "device_id required"})
-                return res
-
-            if action == "add":
-                result = self.create_device(device_id, data)
-            elif action == "remove":
-                result = self.destroy_device(device_id)
-            else:
-                result = {"success": False, "error": f"Unknown action: {action}"}
-
-            res.response = json.dumps(result, ensure_ascii=False)
-
-        except NotImplementedError as e:
-            self.lab_logger().warning(f"[DeviceManage] {e}")
-            res.response = json.dumps({"success": False, "error": str(e)})
-        except Exception as e:
-            self.lab_logger().error(f"[DeviceManage] Error: {e}")
-            res.response = json.dumps({"success": False, "error": str(e)})
-
-        return res
-
-    def create_device(self, device_id: str, config: "ResourceDictType") -> dict:
-        """Create a sub-device dynamically. Override in HostNode / WorkstationNode."""
-        raise NotImplementedError(
-            f"{self.__class__.__name__} does not support dynamic device creation"
-        )
-
-    def destroy_device(self, device_id: str) -> dict:
-        """Destroy a sub-device dynamically. Override in HostNode / WorkstationNode."""
-        raise NotImplementedError(
-            f"{self.__class__.__name__} does not support dynamic device removal"
-        )
-
     async def transfer_resource_to_another(
         self,
         plr_resources: List["ResourcePLR"],
@@ -1256,40 +1204,22 @@ class BaseROS2DeviceNode(Node, Generic[T]):
         return self._lab_logger
 
     def create_ros_publisher(self, attr_name, msg_type, initial_period=5.0):
-        """创建ROS发布者，仅当方法/属性有 @topic_config 装饰器时才创建。"""
-        # 检测 @topic_config 装饰器配置
+        """创建ROS发布者"""
+        # 检测装饰器配置（支持 get_{attr_name} 方法和 @property）
         topic_config = {}
-        driver_class = type(self.driver_instance)
 
-        # 区分 @property 和普通方法两种情况
-        is_prop = hasattr(driver_class, attr_name) and isinstance(
-            getattr(driver_class, attr_name), property
-        )
+        # 优先检测 get_{attr_name} 方法
+        if hasattr(self.driver_instance, f"get_{attr_name}"):
+            getter_method = getattr(self.driver_instance, f"get_{attr_name}")
+            topic_config = get_topic_config(getter_method)
 
-        if is_prop:
-            # @property: 检测 fget 上的 @topic_config
-            class_attr = getattr(driver_class, attr_name)
-            if class_attr.fget is not None:
-                topic_config = get_topic_config(class_attr.fget)
-        else:
-            # 普通方法: 直接检测 attr_name 方法上的 @topic_config
-            if hasattr(self.driver_instance, attr_name):
-                method = getattr(self.driver_instance, attr_name)
-                if callable(method):
-                    topic_config = get_topic_config(method)
-
-        # 没有 @topic_config 装饰器则跳过发布
+        # 如果没有配置，检测 @property 装饰的属性
         if not topic_config:
-            return
-
-        # 发布名称优先级: @topic_config(name=...) > get_ 前缀去除 > attr_name
-        cfg_name = topic_config.get("name")
-        if cfg_name:
-            publish_name = cfg_name
-        elif attr_name.startswith("get_"):
-            publish_name = attr_name[4:]
-        else:
-            publish_name = attr_name
+            driver_class = type(self.driver_instance)
+            if hasattr(driver_class, attr_name):
+                class_attr = getattr(driver_class, attr_name)
+                if isinstance(class_attr, property) and class_attr.fget is not None:
+                    topic_config = get_topic_config(class_attr.fget)
 
         # 使用装饰器配置或默认值
         cfg_period = topic_config.get("period")
@@ -1302,10 +1232,10 @@ class BaseROS2DeviceNode(Node, Generic[T]):
         # 获取属性值的方法
         def get_device_attr():
             try:
-                if is_prop:
-                    return getattr(self.driver_instance, attr_name)
+                if hasattr(self.driver_instance, f"get_{attr_name}"):
+                    return getattr(self.driver_instance, f"get_{attr_name}")()
                 else:
-                    return getattr(self.driver_instance, attr_name)()
+                    return getattr(self.driver_instance, attr_name)
             except AttributeError as ex:
                 if ex.args[0].startswith(f"AttributeError: '{self.driver_instance.__class__.__name__}' object"):
                     self.lab_logger().error(
@@ -1317,8 +1247,8 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                     )
                     self.lab_logger().error(traceback.format_exc())
 
-        self._property_publishers[publish_name] = PropertyPublisher(
-            self, publish_name, get_device_attr, msg_type, period, print_publish, qos
+        self._property_publishers[attr_name] = PropertyPublisher(
+            self, attr_name, get_device_attr, msg_type, period, print_publish, qos
         )
 
     def create_ros_action_server(self, action_name, action_value_mapping):
@@ -1326,17 +1256,14 @@ class BaseROS2DeviceNode(Node, Generic[T]):
         action_type = action_value_mapping["type"]
         str_action_type = str(action_type)[8:-2]
 
-        try:
-            self._action_servers[action_name] = ActionServer(
-                self,
-                action_type,
-                action_name,
-                execute_callback=self._create_execute_callback(action_name, action_value_mapping),
-                callback_group=self.callback_group,
-            )
-        except Exception as e:
-            self.lab_logger().error(f"创建ActionServer失败，Device: {self.device_id}, Action Name: {action_name}, Action Type: {action_type}, Error: {e}")
-            return
+        self._action_servers[action_name] = ActionServer(
+            self,
+            action_type,
+            action_name,
+            execute_callback=self._create_execute_callback(action_name, action_value_mapping),
+            callback_group=self.callback_group,
+        )
+
         self.lab_logger().trace(f"发布动作: {action_name}, 类型: {str_action_type}")
 
     def _setup_decorated_subscribers(self):
@@ -1884,8 +1811,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                     continue
 
                 # 处理单个 ResourceSlot
-                _is_resource_slot = isinstance(arg_type, str) and arg_type.endswith(":ResourceSlot")
-                if _is_resource_slot:
+                if arg_type == "unilabos.registry.placeholder_type:ResourceSlot":
                     resource_data = function_args[arg_name]
                     if isinstance(resource_data, dict) and "id" in resource_data:
                         try:
@@ -1899,7 +1825,8 @@ class BaseROS2DeviceNode(Node, Generic[T]):
 
                 # 处理 ResourceSlot 列表
                 elif isinstance(arg_type, tuple) and len(arg_type) == 2:
-                    if arg_type[0] == "list" and isinstance(arg_type[1], str) and arg_type[1].endswith(":ResourceSlot"):
+                    resource_slot_type = "unilabos.registry.placeholder_type:ResourceSlot"
+                    if arg_type[0] == "list" and arg_type[1] == resource_slot_type:
                         resource_list = function_args[arg_name]
                         if isinstance(resource_list, list):
                             try:

unilabos/ros/nodes/presets/camera.py

@@ -4,14 +4,7 @@ import cv2
 from sensor_msgs.msg import Image
 from cv_bridge import CvBridge
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, DeviceNodeResourceTracker
-from unilabos.registry.decorators import device
 
-
-@device(
-    id="camera",
-    category=["camera"],
-    description="""VideoPublisher摄像头设备节点，用于实时视频采集和流媒体发布。该设备通过OpenCV连接本地摄像头（如USB摄像头、内置摄像头等），定时采集视频帧并将其转换为ROS2的sensor_msgs/Image消息格式发布到视频话题。主要用于实验室自动化系统中的视觉监控、图像分析、实时观察等应用场景。支持可配置的摄像头索引、发布频率等参数。""",
-)
 class VideoPublisher(BaseROS2DeviceNode):
     def __init__(self, device_id='video_publisher', registry_name="", device_uuid='', camera_index=0, period: float = 0.1, resource_tracker: DeviceNodeResourceTracker = None):
         # 初始化BaseROS2DeviceNode，使用自身作为driver_instance

unilabos/ros/nodes/presets/host_node.py

@@ -12,7 +12,6 @@ from geometry_msgs.msg import Point
 from rclpy.action import ActionClient, get_action_server_names_and_types_by_node
 from rclpy.service import Service
 from typing_extensions import TypedDict
-from unilabos_msgs.action import EmptyIn, StrSingleInput, ResourceCreateFromOuterEasy, ResourceCreateFromOuter
 from unilabos_msgs.msg import Resource  # type: ignore
 from unilabos_msgs.srv import (
     ResourceAdd,
@@ -24,7 +23,6 @@ from unilabos_msgs.srv import (
 from unilabos_msgs.srv._serial_command import SerialCommand_Request, SerialCommand_Response
 from unique_identifier_msgs.msg import UUID
 
-from unilabos.registry.decorators import device
 from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
 from unilabos.registry.registry import lab_registry
 from unilabos.resources.container import RegularContainer
@@ -32,7 +30,6 @@ from unilabos.resources.graphio import initialize_resource
 from unilabos.resources.registry import add_schema
 from unilabos.resources.resource_tracker import (
     ResourceDict,
-    ResourceDictType,
     ResourceDictInstance,
     ResourceTreeSet,
     ResourceTreeInstance,
@@ -68,13 +65,7 @@ class DeviceActionStatus:
 class TestResourceReturn(TypedDict):
     resources: List[List[ResourceDict]]
     devices: List[Dict[str, Any]]
-    # unilabos_samples: List[LabSample]
-
-
-class CreateResourceReturn(TypedDict):
-    created_resource_tree: List[List[ResourceDict]]
-    liquid_input_resource_tree: List[Dict[str, Any]]
-    # unilabos_samples: List[LabSample]
+    unilabos_samples: List[LabSample]
 
 
 class TestLatencyReturn(TypedDict):
@@ -89,7 +80,6 @@ class TestLatencyReturn(TypedDict):
     status: str
 
 
-@device(id="host_node", category=[], description="Host Node", icon="icon_device.webp")
 class HostNode(BaseROS2DeviceNode):
     """
     主机节点类，负责管理设备、资源和控制器
@@ -278,42 +268,44 @@ class HostNode(BaseROS2DeviceNode):
         self._action_clients: Dict[str, ActionClient] = {  # 为了方便了解实际的数据类型，host的默认写好
             "/devices/host_node/create_resource": ActionClient(
                 self,
-                ResourceCreateFromOuterEasy,
+                lab_registry.ResourceCreateFromOuterEasy,
                 "/devices/host_node/create_resource",
                 callback_group=self.callback_group,
             ),
             "/devices/host_node/create_resource_detailed": ActionClient(
                 self,
-                ResourceCreateFromOuter,
+                lab_registry.ResourceCreateFromOuter,
                 "/devices/host_node/create_resource_detailed",
                 callback_group=self.callback_group,
             ),
             "/devices/host_node/test_latency": ActionClient(
                 self,
-                EmptyIn,
+                lab_registry.EmptyIn,
                 "/devices/host_node/test_latency",
                 callback_group=self.callback_group,
             ),
             "/devices/host_node/test_resource": ActionClient(
                 self,
-                EmptyIn,
+                lab_registry.EmptyIn,
                 "/devices/host_node/test_resource",
                 callback_group=self.callback_group,
             ),
             "/devices/host_node/_execute_driver_command": ActionClient(
                 self,
-                StrSingleInput,
+                lab_registry.StrSingleInput,
                 "/devices/host_node/_execute_driver_command",
                 callback_group=self.callback_group,
             ),
             "/devices/host_node/_execute_driver_command_async": ActionClient(
                 self,
-                StrSingleInput,
+                lab_registry.StrSingleInput,
                 "/devices/host_node/_execute_driver_command_async",
                 callback_group=self.callback_group,
             ),
         }  # 用来存储多个ActionClient实例
-        self._action_value_mappings: Dict[str, Dict] = {}  # device_id -> action_value_mappings(本地+远程设备统一存储)
+        self._action_value_mappings: Dict[str, Dict] = (
+            {}
+        )  # device_id -> action_value_mappings(本地+远程设备统一存储)
         self._slave_registry_configs: Dict[str, Dict] = {}  # registry_name -> registry_config(含action_value_mappings)
         self._goals: Dict[str, Any] = {}  # 用来存储多个目标的状态
         self._online_devices: Set[str] = {f"{self.namespace}/{device_id}"}  # 用于跟踪在线设备
@@ -331,18 +323,10 @@ class HostNode(BaseROS2DeviceNode):
         self._discover_devices()
 
         # 初始化所有本机设备节点，多一次过滤，防止重复初始化
-        local_machine = BasicConfig.machine_name
         for device_config in devices_config.root_nodes:
             device_id = device_config.res_content.id
             if device_config.res_content.type != "device":
                 continue
-            dev_machine = device_config.res_content.machine_name
-            if dev_machine and local_machine and dev_machine != local_machine:
-                self.lab_logger().info(
-                    f"[Host Node] Device {device_id} belongs to machine '{dev_machine}', "
-                    f"local is '{local_machine}', skipping initialization."
-                )
-                continue
             if device_id not in self.devices_names:
                 self.initialize_device(device_id, device_config)
             else:
@@ -572,7 +556,7 @@ class HostNode(BaseROS2DeviceNode):
         liquid_type: list[str] = [],
         liquid_volume: list[int] = [],
         slot_on_deck: str = "",
-    ) -> CreateResourceReturn:
+    ):
         # 暂不支持多对同名父子同时存在
         res_creation_input = {
             "id": res_id.split("/")[-1],
@@ -625,8 +609,6 @@ class HostNode(BaseROS2DeviceNode):
             assert len(response) == 1, "Create Resource应当只返回一个结果"
             for i in response:
                 res = json.loads(i)
-                if "suc" in res:
-                    raise ValueError(res.get("error"))
                 return res
         except Exception as ex:
             pass
@@ -668,12 +650,7 @@ class HostNode(BaseROS2DeviceNode):
             action_id = f"/devices/{device_id}/{action_name}"
             if action_id not in self._action_clients:
                 action_type = action_value_mapping["type"]
-                try:
-                    self._action_clients[action_id] = ActionClient(self, action_type, action_id)
-                except Exception as e:
-                    self.lab_logger().error(
-                        f"创建ActionClient失败，Device: {device_id}, Action Name: {action_name}, Action Type: {action_type}, Error: {e}")
-                    continue
+                self._action_clients[action_id] = ActionClient(self, action_type, action_id)
                 self.lab_logger().trace(
                     f"[Host Node] Created ActionClient (Local): {action_id}"
                 )  # 子设备再创建用的是Discover发现的
@@ -1273,9 +1250,9 @@ class HostNode(BaseROS2DeviceNode):
 
                 # 用 registry_name 索引已存储的 registry_config,获取 action_value_mappings
                 if registry_name and registry_name in self._slave_registry_configs:
-                    action_mappings = (
-                        self._slave_registry_configs[registry_name].get("class", {}).get("action_value_mappings", {})
-                    )
+                    action_mappings = self._slave_registry_configs[registry_name].get(
+                        "class", {}
+                    ).get("action_value_mappings", {})
                     if action_mappings:
                         self._action_value_mappings[edge_device_id] = action_mappings
                         self.lab_logger().info(
@@ -1295,19 +1272,14 @@ class HostNode(BaseROS2DeviceNode):
 
                 # 解析 devices_config,建立 device_id -> action_value_mappings 映射
                 if devices_config:
-                    machine_name = info["machine_name"]
-                    # Stamp machine_name on each device dict before parsing
                     for device_tree in devices_config:
                         for device_dict in device_tree:
-                            device_dict["machine_name"] = machine_name
                             device_id = device_dict.get("id", "")
                             class_name = device_dict.get("class", "")
                             if device_id and class_name and class_name in self._slave_registry_configs:
-                                action_mappings = (
-                                    self._slave_registry_configs[class_name]
-                                    .get("class", {})
-                                    .get("action_value_mappings", {})
-                                )
+                                action_mappings = self._slave_registry_configs[class_name].get(
+                                    "class", {}
+                                ).get("action_value_mappings", {})
                                 if action_mappings:
                                     self._action_value_mappings[device_id] = action_mappings
                                     self.lab_logger().info(
@@ -1315,18 +1287,6 @@ class HostNode(BaseROS2DeviceNode):
                                         f"for remote device {device_id} (class: {class_name})"
                                     )
 
-                    # Merge slave devices_config into self.devices_config tree
-                    try:
-                        slave_tree_set = ResourceTreeSet.load(devices_config)  # slave一定是根节点的tree
-                        for tree in slave_tree_set.trees:
-                            self.devices_config.trees.append(tree)
-                        self.lab_logger().info(
-                            f"[Host Node] Merged {len(slave_tree_set.trees)} slave device trees "
-                            f"(machine: {machine_name}) into devices_config"
-                        )
-                    except Exception as e:
-                        self.lab_logger().error(f"[Host Node] Failed to merge slave devices_config: {e}")
-
             self.lab_logger().debug(f"[Host Node] Node info update: {info}")
             response.response = "OK"
         except Exception as e:
@@ -1735,177 +1695,3 @@ class HostNode(BaseROS2DeviceNode):
             self.lab_logger().error(f"[Host Node-Resource] Error notifying resource tree update: {str(e)}")
             self.lab_logger().error(traceback.format_exc())
             return False
-
-    # ------------------------------------------------------------------
-    # Device lifecycle (add / remove) — pure forwarder
-    # ------------------------------------------------------------------
-
-    def notify_device_manage(self, target_node_id: str, action: str, config: ResourceDictType) -> bool:
-        """Forward an add/remove device command to the target node via ROS2 SerialCommand.
-
-        The HostNode does NOT interpret the command; it simply resolves the
-        target namespace and forwards the request to ``s2c_device_manage``.
-
-        If *target_node_id* equals the HostNode's own device_id (i.e. the
-        command targets the host itself), we call our local ``create_device``
-        / ``destroy_device`` directly instead of going through ROS2.
-        """
-        try:
-            # If the target is the host itself, handle locally
-            device_id = config["id"]
-            if target_node_id == self.device_id:
-                if action == "add":
-                    return self.create_device(device_id, config).get("success", False)
-                elif action == "remove":
-                    return self.destroy_device(device_id).get("success", False)
-
-            if target_node_id not in self.devices_names:
-                self.lab_logger().error(
-                    f"[Host Node-DeviceMgr] Target {target_node_id} not found in devices_names"
-                )
-                return False
-
-            namespace = self.devices_names[target_node_id]
-            device_key = f"{namespace}/{target_node_id}"
-            if device_key not in self._online_devices:
-                self.lab_logger().error(f"[Host Node-DeviceMgr] Target {device_key} is offline")
-                return False
-
-            srv_address = f"/srv{namespace}/s2c_device_manage"
-            self.lab_logger().info(
-                f"[Host Node-DeviceMgr] Forwarding {action}_device to {target_node_id} ({srv_address})"
-            )
-
-            sclient = self.create_client(SerialCommand, srv_address)
-            if not sclient.wait_for_service(timeout_sec=5.0):
-                self.lab_logger().error(f"[Host Node-DeviceMgr] Service {srv_address} not available")
-                return False
-
-            request = SerialCommand.Request()
-            request.command = json.dumps({"action": action, "data": config}, ensure_ascii=False)
-
-            future = sclient.call_async(request)
-            timeout = 30.0
-            start_time = time.time()
-            while not future.done():
-                if time.time() - start_time > timeout:
-                    self.lab_logger().error(
-                        f"[Host Node-DeviceMgr] Timeout waiting for {action}_device on {target_node_id}"
-                    )
-                    return False
-                time.sleep(0.05)
-
-            response = future.result()
-            self.lab_logger().info(
-                f"[Host Node-DeviceMgr] {action}_device on {target_node_id} completed"
-            )
-            return True
-
-        except Exception as e:
-            self.lab_logger().error(f"[Host Node-DeviceMgr] Error: {e}")
-            self.lab_logger().error(traceback.format_exc())
-            return False
-
-    def create_device(self, device_id: str, config: ResourceDictType) -> dict:
-        """Dynamically create a root-level device on the host."""
-        if not device_id:
-            return {"success": False, "error": "device_id required"}
-
-        if device_id in self.devices_names:
-            return {"success": False, "error": f"Device {device_id} already exists"}
-
-        try:
-            config.setdefault("id", device_id)
-            config.setdefault("type", "device")
-            config.setdefault("machine_name", BasicConfig.machine_name or "本地")
-            res_dict = ResourceDictInstance.get_resource_instance_from_dict(config)
-
-            self.initialize_device(device_id, res_dict)
-
-            if device_id not in self.devices_names:
-                return {"success": False, "error": f"initialize_device failed for {device_id}"}
-
-            # Add to config tree (devices_config)
-            tree = ResourceTreeInstance(res_dict)
-            self.devices_config.trees.append(tree)
-
-            # Add to resource tracker so s2c_resource_tree can find it
-            try:
-                for plr_resource in ResourceTreeSet([tree]).to_plr_resources():
-                    self._resource_tracker.add_resource(plr_resource)
-            except Exception as ex:
-                self.lab_logger().warning(f"[Host Node-DeviceMgr] PLR resource registration skipped: {ex}")
-
-            self.lab_logger().info(f"[Host Node-DeviceMgr] Device {device_id} created successfully")
-            return {"success": True, "device_id": device_id}
-
-        except Exception as e:
-            self.lab_logger().error(f"[Host Node-DeviceMgr] Failed to create {device_id}: {e}")
-            self.lab_logger().error(traceback.format_exc())
-            return {"success": False, "error": str(e)}
-
-    def destroy_device(self, device_id: str) -> dict:
-        """Remove a root-level device from the host."""
-        if not device_id:
-            return {"success": False, "error": "device_id required"}
-
-        if device_id not in self.devices_names:
-            return {"success": False, "error": f"Device {device_id} not found"}
-
-        if device_id == self.device_id:
-            return {"success": False, "error": "Cannot destroy host_node itself"}
-
-        try:
-            namespace = self.devices_names[device_id]
-            device_key = f"{namespace}/{device_id}"
-
-            # Remove action clients
-            action_prefix = f"/devices/{device_id}/"
-            to_remove = [k for k in self._action_clients if k.startswith(action_prefix)]
-            for k in to_remove:
-                try:
-                    self._action_clients[k].destroy()
-                except Exception:
-                    pass
-                del self._action_clients[k]
-
-            # Remove from config tree (devices_config)
-            self.devices_config.trees = [
-                t for t in self.devices_config.trees
-                if t.root_node.res_content.id != device_id
-            ]
-
-            # Remove from resource tracker
-            try:
-                tracked = self._resource_tracker.uuid_to_resources.copy()
-                for uid, res in tracked.items():
-                    res_id = res.get("id") if isinstance(res, dict) else getattr(res, "name", None)
-                    if res_id == device_id:
-                        self._resource_tracker.remove_resource(res)
-            except Exception as ex:
-                self.lab_logger().warning(f"[Host Node-DeviceMgr] Resource tracker cleanup: {ex}")
-
-            # Clean internal state
-            self._online_devices.discard(device_key)
-            self.devices_names.pop(device_id, None)
-            self.device_machine_names.pop(device_id, None)
-            self._action_value_mappings.pop(device_id, None)
-
-            # Destroy the ROS2 node of the device
-            instance = self.devices_instances.pop(device_id, None)
-            if instance is not None:
-                try:
-                    # noinspection PyProtectedMember
-                    ros_node = getattr(instance, "_ros_node", None)
-                    if ros_node is not None:
-                        ros_node.destroy_node()
-                except Exception as e:
-                    self.lab_logger().warning(f"[Host Node-DeviceMgr] Error destroying ROS node for {device_id}: {e}")
-
-            self.lab_logger().info(f"[Host Node-DeviceMgr] Device {device_id} destroyed")
-            return {"success": True, "device_id": device_id}
-
-        except Exception as e:
-            self.lab_logger().error(f"[Host Node-DeviceMgr] Failed to destroy {device_id}: {e}")
-            self.lab_logger().error(traceback.format_exc())
-            return {"success": False, "error": str(e)}

unilabos/ros/nodes/presets/workstation.py

@@ -20,7 +20,7 @@ from unilabos.ros.msgs.message_converter import (
     convert_from_ros_msg_with_mapping,
 )
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, DeviceNodeResourceTracker, ROS2DeviceNode
-from unilabos.resources.resource_tracker import ResourceDictType, ResourceTreeSet, ResourceDictInstance
+from unilabos.resources.resource_tracker import ResourceTreeSet, ResourceDictInstance
 from unilabos.utils.type_check import get_result_info_str
 
 if TYPE_CHECKING:
@@ -177,103 +177,6 @@ class ROS2WorkstationNode(BaseROS2DeviceNode):
                     self.lab_logger().trace(f"为子设备 {device_id} 创建动作客户端: {action_name}")
         return d
 
-    def create_device(self, device_id: str, config: ResourceDictType) -> dict:
-        """Dynamically add a sub-device to this workstation."""
-        if not device_id:
-            return {"success": False, "error": "device_id required"}
-
-        if device_id in self.sub_devices:
-            return {"success": False, "error": f"Sub-device {device_id} already exists"}
-
-        try:
-            from unilabos.config.config import BasicConfig
-            config.setdefault("id", device_id)
-            config.setdefault("type", "device")
-            config.setdefault("machine_name", BasicConfig.machine_name or "本地")
-            res_dict = ResourceDictInstance.get_resource_instance_from_dict(config)
-
-            d = self.initialize_device(device_id, res_dict)
-            if d is None:
-                return {"success": False, "error": f"initialize_device returned None for {device_id}"}
-
-            # Add to children config list
-            self.children.append(res_dict)
-
-            # Add to resource tracker
-            try:
-                from unilabos.resources.resource_tracker import ResourceTreeInstance
-                tree = ResourceTreeInstance(res_dict)
-                for plr_resource in ResourceTreeSet([tree]).to_plr_resources():
-                    self.resource_tracker.add_resource(plr_resource)
-            except Exception as ex:
-                self.lab_logger().warning(f"[Workstation-DeviceMgr] PLR resource registration skipped: {ex}")
-
-            self.lab_logger().info(f"[Workstation-DeviceMgr] Sub-device {device_id} created")
-            return {"success": True, "device_id": device_id}
-
-        except Exception as e:
-            self.lab_logger().error(f"[Workstation-DeviceMgr] Failed to create {device_id}: {e}")
-            self.lab_logger().error(traceback.format_exc())
-            return {"success": False, "error": str(e)}
-
-    def destroy_device(self, device_id: str) -> dict:
-        """Dynamically remove a sub-device from this workstation."""
-        if not device_id:
-            return {"success": False, "error": "device_id required"}
-
-        if device_id not in self.sub_devices:
-            return {"success": False, "error": f"Sub-device {device_id} not found"}
-
-        try:
-            # Remove from children config list
-            self.children = [
-                c for c in self.children
-                if c.res_content.id != device_id
-            ]
-
-            # Remove from resource tracker
-            try:
-                tracked = self.resource_tracker.uuid_to_resources.copy()
-                for uid, res in tracked.items():
-                    res_id = res.get("id") if isinstance(res, dict) else getattr(res, "name", None)
-                    if res_id == device_id:
-                        self.resource_tracker.remove_resource(res)
-            except Exception as ex:
-                self.lab_logger().warning(f"[Workstation-DeviceMgr] Resource tracker cleanup: {ex}")
-
-            # Remove action clients for this sub-device
-            action_prefix = f"/devices/{device_id}/"
-            to_remove = [k for k in self._action_clients if k.startswith(action_prefix)]
-            for k in to_remove:
-                try:
-                    self._action_clients[k].destroy()
-                except Exception:
-                    pass
-                del self._action_clients[k]
-
-            # Destroy the ROS2 node
-            instance = self.sub_devices.pop(device_id, None)
-            if instance is not None:
-                ros_node = getattr(instance, "ros_node_instance", None)
-                if ros_node is not None:
-                    try:
-                        ros_node.destroy_node()
-                    except Exception as e:
-                        self.lab_logger().warning(
-                            f"[Workstation-DeviceMgr] Error destroying ROS node for {device_id}: {e}"
-                        )
-
-            # Remove from communication map if present
-            self.communication_node_id_to_instance.pop(device_id, None)
-
-            self.lab_logger().info(f"[Workstation-DeviceMgr] Sub-device {device_id} destroyed")
-            return {"success": True, "device_id": device_id}
-
-        except Exception as e:
-            self.lab_logger().error(f"[Workstation-DeviceMgr] Failed to destroy {device_id}: {e}")
-            self.lab_logger().error(traceback.format_exc())
-            return {"success": False, "error": str(e)}
-
     def create_ros_action_server(self, action_name, action_value_mapping):
         """创建ROS动作服务器"""
         if action_name not in self.protocol_names:

unilabos/test/experiments/prcxi_9320_slim.json

@@ -74,7 +74,7 @@
                         "occupied_by": null,
                         "position": {
                             "x": 0,
-                            "y": 0,
+                            "y": 288,
                             "z": 0
                         },
                         "size": {
@@ -83,13 +83,11 @@
                             "depth": 0
                         },
                         "content_type": [
-                            "container",
                             "plate",
                             "tip_rack",
                             "plates",
                             "tip_racks",
-                            "tube_rack",
-                            "adaptor"
+                            "tube_rack"
                         ]
                     },
                     {
@@ -98,7 +96,7 @@
                         "occupied_by": null,
                         "position": {
                             "x": 138,
-                            "y": 0,
+                            "y": 288,
                             "z": 0
                         },
                         "size": {
@@ -111,8 +109,7 @@
                             "tip_rack",
                             "plates",
                             "tip_racks",
-                            "tube_rack",
-                            "adaptor"
+                            "tube_rack"
                         ]
                     },
                     {
@@ -121,7 +118,7 @@
                         "occupied_by": null,
                         "position": {
                             "x": 276,
-                            "y": 0,
+                            "y": 288,
                             "z": 0
                         },
                         "size": {
@@ -134,8 +131,7 @@
                             "tip_rack",
                             "plates",
                             "tip_racks",
-                            "tube_rack",
-                            "adaptor"
+                            "tube_rack"
                         ]
                     },
                     {
@@ -144,6 +140,204 @@
                         "occupied_by": null,
                         "position": {
                             "x": 414,
+                            "y": 288,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack"
+                        ]
+                    },
+                    {
+                        "label": "T5",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 0,
+                            "y": 192,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack"
+                        ]
+                    },
+                    {
+                        "label": "T6",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 138,
+                            "y": 192,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack"
+                        ]
+                    },
+                    {
+                        "label": "T7",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 276,
+                            "y": 192,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack"
+                        ]
+                    },
+                    {
+                        "label": "T8",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 414,
+                            "y": 192,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack"
+                        ]
+                    },
+                    {
+                        "label": "T9",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 0,
+                            "y": 96,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack"
+                        ]
+                    },
+                    {
+                        "label": "T10",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 138,
+                            "y": 96,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack"
+                        ]
+                    },
+                    {
+                        "label": "T11",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 276,
+                            "y": 96,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack"
+                        ]
+                    },
+                    {
+                        "label": "T12",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 414,
+                            "y": 96,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack"
+                        ]
+                    },
+                    {
+                        "label": "T13",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 0,
                             "y": 0,
                             "z": 0
                         },
@@ -157,215 +351,7 @@
                             "tip_rack",
                             "plates",
                             "tip_racks",
-                            "tube_rack",
-                            "adaptor"
-                        ]
-                    },
-                    {
-                        "label": "T5",
-                        "visible": true,
-                        "occupied_by": null,
-                        "position": {
-                            "x": 0,
-                            "y": 96,
-                            "z": 0
-                        },
-                        "size": {
-                            "width": 128.0,
-                            "height": 86,
-                            "depth": 0
-                        },
-                        "content_type": [
-                            "plate",
-                            "tip_rack",
-                            "plates",
-                            "tip_racks",
-                            "tube_rack",
-                            "adaptor"
-                        ]
-                    },
-                    {
-                        "label": "T6",
-                        "visible": true,
-                        "occupied_by": null,
-                        "position": {
-                            "x": 138,
-                            "y": 96,
-                            "z": 0
-                        },
-                        "size": {
-                            "width": 128.0,
-                            "height": 86,
-                            "depth": 0
-                        },
-                        "content_type": [
-                            "plate",
-                            "tip_rack",
-                            "plates",
-                            "tip_racks",
-                            "tube_rack",
-                            "adaptor"
-                        ]
-                    },
-                    {
-                        "label": "T7",
-                        "visible": true,
-                        "occupied_by": null,
-                        "position": {
-                            "x": 276,
-                            "y": 96,
-                            "z": 0
-                        },
-                        "size": {
-                            "width": 128.0,
-                            "height": 86,
-                            "depth": 0
-                        },
-                        "content_type": [
-                            "plate",
-                            "tip_rack",
-                            "plates",
-                            "tip_racks",
-                            "tube_rack",
-                            "adaptor"
-                        ]
-                    },
-                    {
-                        "label": "T8",
-                        "visible": true,
-                        "occupied_by": null,
-                        "position": {
-                            "x": 414,
-                            "y": 96,
-                            "z": 0
-                        },
-                        "size": {
-                            "width": 128.0,
-                            "height": 86,
-                            "depth": 0
-                        },
-                        "content_type": [
-                            "plate",
-                            "tip_rack",
-                            "plates",
-                            "tip_racks",
-                            "tube_rack",
-                            "adaptor"
-                        ]
-                    },
-                    {
-                        "label": "T9",
-                        "visible": true,
-                        "occupied_by": null,
-                        "position": {
-                            "x": 0,
-                            "y": 192,
-                            "z": 0
-                        },
-                        "size": {
-                            "width": 128.0,
-                            "height": 86,
-                            "depth": 0
-                        },
-                        "content_type": [
-                            "plate",
-                            "tip_rack",
-                            "plates",
-                            "tip_racks",
-                            "tube_rack",
-                            "adaptor"
-                        ]
-                    },
-                    {
-                        "label": "T10",
-                        "visible": true,
-                        "occupied_by": null,
-                        "position": {
-                            "x": 138,
-                            "y": 192,
-                            "z": 0
-                        },
-                        "size": {
-                            "width": 128.0,
-                            "height": 86,
-                            "depth": 0
-                        },
-                        "content_type": [
-                            "plate",
-                            "tip_rack",
-                            "plates",
-                            "tip_racks",
-                            "tube_rack",
-                            "adaptor"
-                        ]
-                    },
-                    {
-                        "label": "T11",
-                        "visible": true,
-                        "occupied_by": null,
-                        "position": {
-                            "x": 276,
-                            "y": 192,
-                            "z": 0
-                        },
-                        "size": {
-                            "width": 128.0,
-                            "height": 86,
-                            "depth": 0
-                        },
-                        "content_type": [
-                            "plate",
-                            "tip_rack",
-                            "plates",
-                            "tip_racks",
-                            "tube_rack",
-                            "adaptor"
-                        ]
-                    },
-                    {
-                        "label": "T12",
-                        "visible": true,
-                        "occupied_by": null,
-                        "position": {
-                            "x": 414,
-                            "y": 192,
-                            "z": 0
-                        },
-                        "size": {
-                            "width": 128.0,
-                            "height": 86,
-                            "depth": 0
-                        },
-                        "content_type": [
-                            "plate",
-                            "tip_rack",
-                            "plates",
-                            "tip_racks",
-                            "tube_rack",
-                            "adaptor"
-                        ]
-                    },
-                    {
-                        "label": "T13",
-                        "visible": true,
-                        "occupied_by": null,
-                        "position": {
-                            "x": 0,
-                            "y": 288,
-                            "z": 0
-                        },
-                        "size": {
-                            "width": 128.0,
-                            "height": 86,
-                            "depth": 0
-                        },
-                        "content_type": [
-                            "plate",
-                            "tip_rack",
-                            "plates",
-                            "tip_racks",
-                            "tube_rack",
-                            "adaptor"
+                            "tube_rack"
                         ]
                     },
                     {
@@ -374,7 +360,7 @@
                         "occupied_by": null,
                         "position": {
                             "x": 138,
-                            "y": 288,
+                            "y": 0,
                             "z": 0
                         },
                         "size": {
@@ -387,8 +373,7 @@
                             "tip_rack",
                             "plates",
                             "tip_racks",
-                            "tube_rack",
-                            "adaptor"
+                            "tube_rack"
                         ]
                     },
                     {
@@ -397,7 +382,7 @@
                         "occupied_by": null,
                         "position": {
                             "x": 276,
-                            "y": 288,
+                            "y": 0,
                             "z": 0
                         },
                         "size": {
@@ -410,8 +395,7 @@
                             "tip_rack",
                             "plates",
                             "tip_racks",
-                            "tube_rack",
-                            "adaptor"
+                            "tube_rack"
                         ]
                     },
                     {
@@ -420,7 +404,7 @@
                         "occupied_by": null,
                         "position": {
                             "x": 414,
-                            "y": 288,
+                            "y": 0,
                             "z": 0
                         },
                         "size": {
@@ -433,8 +417,7 @@
                             "tip_rack",
                             "plates",
                             "tip_racks",
-                            "tube_rack",
-                            "adaptor"
+                            "tube_rack"
                         ]
                     }
                 ]

unilabos/utils/decorator.py

@@ -19,6 +19,74 @@ def singleton(cls):
     return get_instance
 
 
+def topic_config(
+    period: Optional[float] = None,
+    print_publish: Optional[bool] = None,
+    qos: Optional[int] = None,
+) -> Callable[[F], F]:
+    """
+    Topic发布配置装饰器
+
+    用于装饰 get_{attr_name} 方法或 @property，控制对应属性的ROS topic发布行为。
+
+    Args:
+        period: 发布周期（秒）。None 表示使用默认值 5.0
+        print_publish: 是否打印发布日志。None 表示使用节点默认配置
+        qos: QoS深度配置。None 表示使用默认值 10
+
+    Example:
+        class MyDriver:
+            # 方式1: 装饰 get_{attr_name} 方法
+            @topic_config(period=1.0, print_publish=False, qos=5)
+            def get_temperature(self):
+                return self._temperature
+
+            # 方式2: 与 @property 连用（topic_config 放在下面）
+            @property
+            @topic_config(period=0.1)
+            def position(self):
+                return self._position
+
+    Note:
+        与 @property 连用时，@topic_config 必须放在 @property 下面，
+        这样装饰器执行顺序为：先 topic_config 添加配置，再 property 包装。
+    """
+
+    def decorator(func: F) -> F:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        # 在函数上附加配置属性 (type: ignore 用于动态属性)
+        wrapper._topic_period = period  # type: ignore[attr-defined]
+        wrapper._topic_print_publish = print_publish  # type: ignore[attr-defined]
+        wrapper._topic_qos = qos  # type: ignore[attr-defined]
+        wrapper._has_topic_config = True  # type: ignore[attr-defined]
+
+        return wrapper  # type: ignore[return-value]
+
+    return decorator
+
+
+def get_topic_config(func) -> dict:
+    """
+    获取函数上的topic配置
+
+    Args:
+        func: 被装饰的函数
+
+    Returns:
+        包含 period, print_publish, qos 的配置字典
+    """
+    if hasattr(func, "_has_topic_config") and getattr(func, "_has_topic_config", False):
+        return {
+            "period": getattr(func, "_topic_period", None),
+            "print_publish": getattr(func, "_topic_print_publish", None),
+            "qos": getattr(func, "_topic_qos", None),
+        }
+    return {}
+
+
 def subscribe(
     topic: str,
     msg_type: Optional[type] = None,
@@ -36,6 +104,24 @@ def subscribe(
             - {namespace}: 完整命名空间 (如 "/devices/pump_1")
         msg_type: ROS 消息类型。如果为 None，需要在回调函数的类型注解中指定
         qos: QoS 深度配置，默认为 10
+
+    Example:
+        from std_msgs.msg import String, Float64
+
+        class MyDriver:
+            @subscribe(topic="/devices/{device_id}/set_speed", msg_type=Float64)
+            def on_speed_update(self, msg: Float64):
+                self._speed = msg.data
+                print(f"Speed updated to: {self._speed}")
+
+            @subscribe(topic="{namespace}/command")
+            def on_command(self, msg: String):
+                # msg_type 可从类型注解推断
+                self.execute_command(msg.data)
+
+    Note:
+        - 回调方法的第一个参数是 self，第二个参数是收到的 ROS 消息
+        - topic 中的占位符会在创建订阅时被实际值替换
     """
 
     def decorator(func: F) -> F:
@@ -43,6 +129,7 @@ def subscribe(
         def wrapper(*args, **kwargs):
             return func(*args, **kwargs)
 
+        # 在函数上附加订阅配置
         wrapper._subscribe_topic = topic  # type: ignore[attr-defined]
         wrapper._subscribe_msg_type = msg_type  # type: ignore[attr-defined]
         wrapper._subscribe_qos = qos  # type: ignore[attr-defined]
@@ -54,7 +141,15 @@ def subscribe(
 
 
 def get_subscribe_config(func) -> dict:
-    """获取函数上的订阅配置 (topic, msg_type, qos)"""
+    """
+    获取函数上的订阅配置
+
+    Args:
+        func: 被装饰的函数
+
+    Returns:
+        包含 topic, msg_type, qos 的配置字典
+    """
     if hasattr(func, "_has_subscribe") and getattr(func, "_has_subscribe", False):
         return {
             "topic": getattr(func, "_subscribe_topic", None),
@@ -68,6 +163,9 @@ def get_all_subscriptions(instance) -> list:
     """
     扫描实例的所有方法，获取带有 @subscribe 装饰器的方法及其配置
 
+    Args:
+        instance: 要扫描的实例
+
     Returns:
         包含 (method_name, method, config) 元组的列表
     """
@@ -86,14 +184,92 @@ def get_all_subscriptions(instance) -> list:
     return subscriptions
 
 
-# ---------------------------------------------------------------------------
-# 向后兼容重导出 -- 已迁移到 unilabos.registry.decorators
-# ---------------------------------------------------------------------------
-from unilabos.registry.decorators import (  # noqa: E402, F401
-    topic_config,
-    get_topic_config,
-    always_free,
-    is_always_free,
-    not_action,
-    is_not_action,
-)
+def always_free(func: F) -> F:
+    """
+    标记动作为永久闲置(不受busy队列限制)的装饰器
+
+    被此装饰器标记的 action 方法，在执行时不会受到设备级别的排队限制，
+    任何时候请求都可以立即执行。适用于查询类、状态读取类等轻量级操作。
+
+    Example:
+        class MyDriver:
+            @always_free
+            def query_status(self, param: str):
+                # 这个动作可以随时执行，不需要排队
+                return self._status
+
+            def transfer(self, volume: float):
+                # 这个动作会按正常排队逻辑执行
+                pass
+
+    Note:
+        - 可以与其他装饰器组合使用，@always_free 应放在最外层
+        - 仅影响 WebSocket 调度层的 busy/free 判断，不影响 ROS2 层
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    wrapper._is_always_free = True  # type: ignore[attr-defined]
+
+    return wrapper  # type: ignore[return-value]
+
+
+def is_always_free(func) -> bool:
+    """
+    检查函数是否被标记为永久闲置
+
+    Args:
+        func: 被检查的函数
+
+    Returns:
+        如果函数被 @always_free 装饰则返回 True，否则返回 False
+    """
+    return getattr(func, "_is_always_free", False)
+
+
+def not_action(func: F) -> F:
+    """
+    标记方法为非动作的装饰器
+
+    用于装饰 driver 类中的方法，使其在 complete_registry 时不被识别为动作。
+    适用于辅助方法、内部工具方法等不应暴露为设备动作的公共方法。
+
+    Example:
+        class MyDriver:
+            @not_action
+            def helper_method(self):
+                # 这个方法不会被注册为动作
+                pass
+
+            def actual_action(self, param: str):
+                # 这个方法会被注册为动作
+                self.helper_method()
+
+    Note:
+        - 可以与其他装饰器组合使用，@not_action 应放在最外层
+        - 仅影响 complete_registry 的动作识别，不影响方法的正常调用
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    # 在函数上附加标记
+    wrapper._is_not_action = True  # type: ignore[attr-defined]
+
+    return wrapper  # type: ignore[return-value]
+
+
+def is_not_action(func) -> bool:
+    """
+    检查函数是否被标记为非动作
+
+    Args:
+        func: 被检查的函数
+
+    Returns:
+        如果函数被 @not_action 装饰则返回 True，否则返回 False
+    """
+    return getattr(func, "_is_not_action", False)

unilabos/utils/environment_check.py

@@ -22,7 +22,6 @@ class EnvironmentChecker:
             # "pymodbus.framer.FramerType": "pymodbus==3.9.2",
             "websockets": "websockets",
             "msgcenterpy": "msgcenterpy",
-            "orjson": "orjson",
             "opentrons_shared_data": "opentrons_shared_data",
             "typing_extensions": "typing_extensions",
             "crcmod": "crcmod-plus",
@@ -33,7 +32,7 @@ class EnvironmentChecker:
 
         # 包版本要求（包名: 最低版本）
         self.version_requirements = {
-            "msgcenterpy": "0.1.8",  # msgcenterpy 最低版本要求
+            "msgcenterpy": "0.1.5",  # msgcenterpy 最低版本要求
         }
 
         self.missing_packages = []

unilabos/utils/import_manager.py

@@ -21,11 +21,15 @@ __all__ = [
     "get_class",
     "get_module",
     "init_from_list",
-    "get_enhanced_class_info",
+    "get_class_info_static",
+    "get_registry_class_info",
 ]
 
+from ast import Constant
+
 from unilabos.resources.resource_tracker import PARAM_SAMPLE_UUIDS
 from unilabos.utils import logger
+from unilabos.utils.decorator import is_not_action, is_always_free
 
 
 class ImportManager:
@@ -41,7 +45,6 @@ class ImportManager:
         self._modules: Dict[str, Any] = {}
         self._classes: Dict[str, Type] = {}
         self._functions: Dict[str, Callable] = {}
-        self._search_miss: set = set()
 
         if module_list:
             for module_path in module_list:
@@ -156,113 +159,193 @@ class ImportManager:
         Returns:
             找到的类对象，如果未找到则返回None
         """
+        # 如果cls_name是builtins中的关键字，则返回对应类
         if class_name in builtins.__dict__:
             return builtins.__dict__[class_name]
+        # 首先在已索引的类中查找
         if class_name in self._classes:
             return self._classes[class_name]
 
-        cache_key = class_name.lower() if search_lower else class_name
-        if cache_key in self._search_miss:
-            return None
-
         if search_lower:
             classes = {name.lower(): obj for name, obj in self._classes.items()}
             if class_name in classes:
                 return classes[class_name]
 
+        # 遍历所有已加载的模块进行搜索
         for module_path, module in self._modules.items():
             for name, obj in inspect.getmembers(module):
                 if inspect.isclass(obj) and (
                     (name.lower() == class_name.lower()) if search_lower else (name == class_name)
                 ):
+                    # 将找到的类添加到索引中
                     self._classes[name] = obj
                     self._classes[f"{module_path}:{name}"] = obj
                     return obj
 
-        self._search_miss.add(cache_key)
         return None
 
-    def get_enhanced_class_info(self, module_path: str, **_kwargs) -> Dict[str, Any]:
-        """通过 AST 分析获取类的增强信息。
-
-        复用 ``ast_registry_scanner`` 的 ``_collect_imports`` / ``_extract_class_body``，
-        与 AST 扫描注册表完全一致。
+    def get_enhanced_class_info(self, module_path: str, use_dynamic: bool = True) -> Dict[str, Any]:
+        """
+        获取增强的类信息，支持动态导入和静态分析
 
         Args:
-            module_path: 格式 ``"module.path:ClassName"``
+            module_path: 模块路径，格式为 "module.path" 或 "module.path:ClassName"
+            use_dynamic: 是否优先使用动态导入
 
         Returns:
-            ``{"module_path", "ast_analysis_success", "import_map",
-              "init_params", "status_methods", "action_methods"}``
+            包含详细类信息的字典
         """
-        from unilabos.registry.ast_registry_scanner import (
-            _collect_imports,
-            _extract_class_body,
-            _filepath_to_module,
-        )
-
-        result: Dict[str, Any] = {
+        result = {
             "module_path": module_path,
-            "ast_analysis_success": False,
-            "import_map": {},
-            "init_params": [],
+            "dynamic_import_success": False,
+            "static_analysis_success": False,
+            "init_params": {},
+            "status_methods": {},  # get_ 开头和 @property 方法
+            "action_methods": {},  # set_ 开头和其他非_开头方法
+        }
+
+        # 尝试动态导入
+        dynamic_info = None
+        static_info = None
+        if use_dynamic:
+            try:
+                dynamic_info = self._get_dynamic_class_info(module_path)
+                result["dynamic_import_success"] = True
+                logger.debug(f"[ImportManager] 动态导入类 {module_path} 成功")
+            except Exception as e:
+                logger.warning(
+                    f"[UniLab Registry] 在补充注册表时，动态导入类 "
+                    f"{module_path} 失败（将使用静态分析，"
+                    f"建议修复导入错误，以实现更好的注册表识别效果！）: {e}"
+                )
+                use_dynamic = False
+        if not use_dynamic:
+            # 尝试静态分析
+            try:
+                static_info = self._get_static_class_info(module_path)
+                result["static_analysis_success"] = True
+                logger.debug(f"[ImportManager] 静态分析类 {module_path} 成功")
+            except Exception as e:
+                logger.warning(f"[ImportManager] 静态分析类 {module_path} 失败: {e}")
+
+        # 合并信息（优先使用动态导入的信息）
+        if dynamic_info:
+            result.update(dynamic_info)
+        elif static_info:
+            result.update(static_info)
+
+        return result
+
+    def _get_dynamic_class_info(self, class_path: str) -> Dict[str, Any]:
+        """使用inspect模块动态获取类信息"""
+        cls = get_class(class_path)
+        class_name = cls.__name__
+
+        result = {
+            "class_name": class_name,
+            "init_params": self._analyze_method_signature(cls.__init__)["args"],
+            "status_methods": {},
+            "action_methods": {},
+        }
+        # 分析类的所有成员
+        for name, method in cls.__dict__.items():
+            if name.startswith("_"):
+                continue
+
+            # 检查是否是property
+            if isinstance(method, property):
+                # @property 装饰的方法
+                # noinspection PyTypeChecker
+                return_type = self._get_return_type_from_method(method.fget) if method.fget else "Any"
+                prop_info = {
+                    "name": name,
+                    "return_type": return_type,
+                }
+                result["status_methods"][name] = prop_info
+
+                # 检查是否有对应的setter
+                if method.fset:
+                    setter_info = self._analyze_method_signature(method.fset)
+                    result["action_methods"][name] = setter_info
+
+            elif inspect.ismethod(method) or inspect.isfunction(method):
+                if name.startswith("get_"):
+                    actual_name = name[4:]  # 去掉get_前缀
+                    if actual_name in result["status_methods"]:
+                        continue
+                    # get_ 开头的方法归类为status
+                    method_info = self._analyze_method_signature(method)
+                    result["status_methods"][actual_name] = method_info
+                elif not name.startswith("_"):
+                    # 检查是否被 @not_action 装饰器标记
+                    if is_not_action(method):
+                        continue
+                    # 其他非_开头的方法归类为action
+                    method_info = self._analyze_method_signature(method)
+                    # 检查是否被 @always_free 装饰器标记
+                    if is_always_free(method):
+                        method_info["always_free"] = True
+                    result["action_methods"][name] = method_info
+
+        return result
+
+    def _get_static_class_info(self, module_path: str) -> Dict[str, Any]:
+        """使用AST静态分析获取类信息"""
+        module_name, class_name = module_path.rsplit(":", 1)
+        # 将模块路径转换为文件路径
+        file_path = self._module_path_to_file_path(module_name)
+        if not file_path or not os.path.exists(file_path):
+            raise FileNotFoundError(f"找不到模块文件: {module_name} -> {file_path}")
+
+        with open(file_path, "r", encoding="utf-8") as f:
+            source_code = f.read()
+
+        tree = ast.parse(source_code)
+
+        # 查找目标类
+        target_class = None
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                if node.name == class_name:
+                    target_class = node
+                    break
+
+        if target_class is None:
+            raise AttributeError(f"在文件 {file_path} 中找不到类 {class_name}")
+
+        result = {
+            "class_name": class_name,
+            "init_params": {},
             "status_methods": {},
             "action_methods": {},
         }
 
-        module_name, class_name = module_path.rsplit(":", 1)
-        file_path = self._module_path_to_file_path(module_name)
-        if not file_path or not os.path.exists(file_path):
-            logger.warning(f"[ImportManager] 找不到模块文件: {module_name} -> {file_path}")
-            return result
-
-        try:
-            with open(file_path, "r", encoding="utf-8") as f:
-                tree = ast.parse(f.read(), filename=file_path)
-        except Exception as e:
-            logger.warning(f"[ImportManager] 解析文件 {file_path} 失败: {e}")
-            return result
-
-        # 推导 module dotted path → 构建 import_map
-        python_path = Path(file_path)
-        for sp in sorted(sys.path, key=len, reverse=True):
-            try:
-                Path(file_path).relative_to(sp)
-                python_path = Path(sp)
-                break
-            except ValueError:
-                continue
-        module_dotted = _filepath_to_module(Path(file_path), python_path)
-        import_map = _collect_imports(tree, module_dotted)
-        result["import_map"] = import_map
-
-        # 定位目标类 AST 节点
-        target_class = None
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ClassDef) and node.name == class_name:
-                target_class = node
-                break
-
-        if target_class is None:
-            logger.warning(f"[ImportManager] 在文件 {file_path} 中找不到类 {class_name}")
-            return result
-
-        body = _extract_class_body(target_class, import_map)
-
-        # 映射到统一字段名（与 registry.py complete_registry 消费端一致）
-        result["init_params"] = body.get("init_params", [])
-        result["status_methods"] = body.get("status_properties", {})
-        result["action_methods"] = {
-            k: {
-                "args": v.get("params", []),
-                "return_type": v.get("return_type", ""),
-                "is_async": v.get("is_async", False),
-                "always_free": v.get("always_free", False),
-                "docstring": v.get("docstring"),
-            }
-            for k, v in body.get("auto_methods", {}).items()
-        }
-        result["ast_analysis_success"] = True
+        # 分析类的方法
+        for node in target_class.body:
+            if isinstance(node, ast.FunctionDef):
+                method_info = self._analyze_method_node(node)
+                method_name = node.name
+                if method_name == "__init__":
+                    result["init_params"] = method_info["args"]
+                elif method_name.startswith("_"):
+                    continue
+                elif self._is_property_method(node):
+                    # @property 装饰的方法
+                    result["status_methods"][method_name] = method_info
+                elif method_name.startswith("get_"):
+                    # get_ 开头的方法归类为status
+                    actual_name = method_name[4:]  # 去掉get_前缀
+                    if actual_name not in result["status_methods"]:
+                        result["status_methods"][actual_name] = method_info
+                else:
+                    # 检查是否被 @not_action 装饰器标记
+                    if self._is_not_action_method(node):
+                        continue
+                    # 其他非_开头的方法归类为action
+                    # 检查是否被 @always_free 装饰器标记
+                    if self._is_always_free_method(node):
+                        method_info["always_free"] = True
+                    result["action_methods"][method_name] = method_info
         return result
 
     def _analyze_method_signature(self, method, skip_unilabos_params: bool = True) -> Dict[str, Any]:
@@ -318,26 +401,23 @@ class ImportManager:
             "name": method.__name__,
             "args": args,
             "return_type": self._get_type_string(signature.return_annotation),
+            "return_annotation": signature.return_annotation,  # 保留原始类型注解，用于TypedDict等特殊处理
             "is_async": inspect.iscoroutinefunction(method),
         }
 
-    def _get_return_type_from_method(self, method) -> Union[str, Tuple[str, Any]]:
+    def _get_return_type_from_method(self, method) -> str:
         """从方法中获取返回类型"""
         signature = inspect.signature(method)
         return self._get_type_string(signature.return_annotation)
 
     def _get_type_string(self, annotation) -> Union[str, Tuple[str, Any]]:
-        """将类型注解转换为类型字符串。
-
-        非内建类返回 ``module:ClassName`` 全路径（如
-        ``"unilabos.registry.placeholder_type:ResourceSlot"``），
-        避免短名冲突；内建类型直接返回短名（如 ``"str"``、``"int"``）。
-        """
+        """将类型注解转换为Class Library中可搜索的类名"""
         if annotation == inspect.Parameter.empty:
-            return "Any"
+            return "Any"  # 如果没有注解，返回Any
         if annotation is None:
-            return "None"
+            return "None"  # 明确的None类型
         if hasattr(annotation, "__origin__"):
+            # 处理typing模块的类型
             origin = annotation.__origin__
             if origin in (list, set, tuple):
                 if hasattr(annotation, "__args__") and annotation.__args__:
@@ -352,26 +432,126 @@ class ImportManager:
                 return "dict"
             elif origin is Optional:
                 return "Unknown"
-            return "Unknown"
+            return f"Unknown"
         annotation_str = str(annotation)
+        # 处理typing模块的复杂类型
         if "typing." in annotation_str:
+            # 简化typing类型显示
             return (
                 annotation_str.replace("typing.", "")
                 if getattr(annotation, "_name", None) is None
                 else annotation._name.lower()
             )
+        # 如果是类型对象
         if hasattr(annotation, "__name__"):
-            module = getattr(annotation, "__module__", None)
-            if module and module != "builtins":
-                return f"{module}:{annotation.__name__}"
-            return annotation.__name__
+            # 如果是内置类型
+            if annotation.__module__ == "builtins":
+                return annotation.__name__
+            else:
+                # 如果是自定义类，返回完整路径
+                return f"{annotation.__module__}:{annotation.__name__}"
+        # 如果是typing模块的类型
         elif hasattr(annotation, "_name"):
             return annotation._name
+        # 如果是字符串形式的类型注解
         elif isinstance(annotation, str):
             return annotation
         else:
             return annotation_str
 
+    def _is_property_method(self, node: ast.FunctionDef) -> bool:
+        """检查是否是@property装饰的方法"""
+        for decorator in node.decorator_list:
+            if isinstance(decorator, ast.Name) and decorator.id == "property":
+                return True
+        return False
+
+    def _is_setter_method(self, node: ast.FunctionDef) -> bool:
+        """检查是否是@xxx.setter装饰的方法"""
+        for decorator in node.decorator_list:
+            if isinstance(decorator, ast.Attribute) and decorator.attr == "setter":
+                return True
+        return False
+
+    def _is_not_action_method(self, node: ast.FunctionDef) -> bool:
+        """检查是否是@not_action装饰的方法"""
+        for decorator in node.decorator_list:
+            if isinstance(decorator, ast.Name) and decorator.id == "not_action":
+                return True
+        return False
+
+    def _is_always_free_method(self, node: ast.FunctionDef) -> bool:
+        """检查是否是@always_free装饰的方法"""
+        for decorator in node.decorator_list:
+            if isinstance(decorator, ast.Name) and decorator.id == "always_free":
+                return True
+        return False
+
+    def _get_property_name_from_setter(self, node: ast.FunctionDef) -> str:
+        """从setter装饰器中获取属性名"""
+        for decorator in node.decorator_list:
+            if isinstance(decorator, ast.Attribute) and decorator.attr == "setter":
+                if isinstance(decorator.value, ast.Name):
+                    return decorator.value.id
+        return node.name
+
+    def get_class_info_static(self, module_class_path: str) -> Dict[str, Any]:
+        """
+        静态分析获取类的方法信息，不需要实际导入模块
+
+        Args:
+            module_class_path: 格式为 "module.path:ClassName" 的字符串
+
+        Returns:
+            包含类方法信息的字典
+        """
+        try:
+            if ":" not in module_class_path:
+                raise ValueError("module_class_path必须是 'module.path:ClassName' 格式")
+
+            module_path, class_name = module_class_path.rsplit(":", 1)
+
+            # 将模块路径转换为文件路径
+            file_path = self._module_path_to_file_path(module_path)
+            if not file_path or not os.path.exists(file_path):
+                logger.warning(f"找不到模块文件: {module_path} -> {file_path}")
+                return {}
+
+            # 解析源码
+            with open(file_path, "r", encoding="utf-8") as f:
+                source_code = f.read()
+
+            tree = ast.parse(source_code)
+
+            # 查找目标类
+            class_node = None
+            for node in ast.walk(tree):
+                if isinstance(node, ast.ClassDef) and node.name == class_name:
+                    class_node = node
+                    break
+
+            if not class_node:
+                logger.warning(f"在模块 {module_path} 中找不到类 {class_name}")
+                return {}
+
+            # 分析类的方法
+            methods_info = {}
+            for node in class_node.body:
+                if isinstance(node, ast.FunctionDef):
+                    method_info = self._analyze_method_node(node)
+                    methods_info[node.name] = method_info
+
+            return {
+                "class_name": class_name,
+                "module_path": module_path,
+                "file_path": file_path,
+                "methods": methods_info,
+            }
+
+        except Exception as e:
+            logger.error(f"静态分析类 {module_class_path} 时出错: {str(e)}")
+            return {}
+
     def _module_path_to_file_path(self, module_path: str) -> Optional[str]:
         for path in sys.path:
             potential_path = Path(path) / module_path.replace(".", "/")
@@ -386,6 +566,222 @@ class ImportManager:
 
         return None
 
+    def _analyze_method_node(self, node: ast.FunctionDef) -> Dict[str, Any]:
+        """分析方法节点，提取参数和返回类型信息"""
+        method_info = {
+            "name": node.name,
+            "args": [],
+            "return_type": None,
+            "is_async": isinstance(node, ast.AsyncFunctionDef),
+        }
+        # 获取默认值列表
+        defaults = node.args.defaults
+        num_defaults = len(defaults)
+
+        # 计算必需参数数量
+        total_args = len(node.args.args)
+        num_required = total_args - num_defaults
+
+        # 提取参数信息
+        for i, arg in enumerate(node.args.args):
+            if arg.arg == "self":
+                continue
+            # 跳过 sample_uuids 参数（由系统自动注入）
+            if arg.arg == PARAM_SAMPLE_UUIDS:
+                continue
+            arg_info = {
+                "name": arg.arg,
+                "type": None,
+                "default": None,
+                "required": i < num_required,
+            }
+
+            # 提取类型注解
+            if arg.annotation:
+                arg_info["type"] = ast.unparse(arg.annotation) if hasattr(ast, "unparse") else str(arg.annotation)
+
+            # 提取默认值并推断类型
+            if i >= num_required:
+                default_index = i - num_required
+                if default_index < len(defaults):
+                    default_value: Constant = defaults[default_index]  # type: ignore
+                    assert isinstance(default_value, Constant), "暂不支持对非常量类型进行推断，可反馈开源仓库"
+                    arg_info["default"] = default_value.value
+                    # 如果没有类型注解，尝试从默认值推断类型
+                    if not arg_info["type"]:
+                        arg_info["type"] = self._get_type_string(type(arg_info["default"]))
+            method_info["args"].append(arg_info)
+
+        # 提取返回类型
+        if node.returns:
+            method_info["return_type"] = ast.unparse(node.returns) if hasattr(ast, "unparse") else str(node.returns)
+
+        return method_info
+
+    def _infer_type_from_default(self, node: ast.AST) -> Optional[str]:
+        """从默认值推断参数类型"""
+        if isinstance(node, ast.Constant):
+            value = node.value
+            if isinstance(value, bool):
+                return "bool"
+            elif isinstance(value, int):
+                return "int"
+            elif isinstance(value, float):
+                return "float"
+            elif isinstance(value, str):
+                return "str"
+            elif value is None:
+                return "Optional[Any]"
+        elif isinstance(node, ast.List):
+            return "List"
+        elif isinstance(node, ast.Dict):
+            return "Dict"
+        elif isinstance(node, ast.Tuple):
+            return "Tuple"
+        elif isinstance(node, ast.Set):
+            return "Set"
+        elif isinstance(node, ast.Name):
+            # 常见的默认值模式
+            if node.id in ["None"]:
+                return "Optional[Any]"
+            elif node.id in ["True", "False"]:
+                return "bool"
+
+        return None
+
+    def _infer_types_from_docstring(self, method_info: Dict[str, Any]) -> None:
+        """从docstring中推断参数类型"""
+        docstring = method_info.get("docstring", "")
+        if not docstring:
+            return
+
+        lines = docstring.split("\n")
+        in_args_section = False
+
+        for line in lines:
+            line = line.strip()
+
+            # 检测Args或Arguments段落
+            if line.lower().startswith(("args:", "arguments:")):
+                in_args_section = True
+                continue
+            elif line.startswith(("returns:", "return:", "yields:", "raises:")):
+                in_args_section = False
+                continue
+            elif not line or not in_args_section:
+                continue
+
+            # 解析参数行，格式通常是: param_name (type): description 或 param_name: description
+            if ":" in line:
+                parts = line.split(":", 1)
+                param_part = parts[0].strip()
+
+                # 提取参数名和类型
+                param_name = None
+                param_type = None
+
+                if "(" in param_part and ")" in param_part:
+                    # 格式: param_name (type)
+                    param_name = param_part.split("(")[0].strip()
+                    type_part = param_part.split("(")[1].split(")")[0].strip()
+                    param_type = type_part
+                else:
+                    # 格式: param_name
+                    param_name = param_part
+
+                # 更新对应参数的类型信息
+                if param_name:
+                    for arg_info in method_info["args"]:
+                        if arg_info["name"] == param_name and not arg_info["type"]:
+                            if param_type:
+                                arg_info["inferred_type"] = param_type
+                            elif not arg_info["inferred_type"]:
+                                # 从描述中推断类型
+                                description = parts[1].strip().lower()
+                                if any(word in description for word in ["path", "file", "directory", "filename"]):
+                                    arg_info["inferred_type"] = "str"
+                                elif any(
+                                    word in description for word in ["port", "number", "count", "size", "length"]
+                                ):
+                                    arg_info["inferred_type"] = "int"
+                                elif any(
+                                    word in description for word in ["rate", "ratio", "percentage", "temperature"]
+                                ):
+                                    arg_info["inferred_type"] = "float"
+                                elif any(word in description for word in ["flag", "enable", "disable", "option"]):
+                                    arg_info["inferred_type"] = "bool"
+
+    def get_registry_class_info(self, module_class_path: str) -> Dict[str, Any]:
+        """
+        获取适用于注册表的类信息，包含完整的类型推断
+
+        Args:
+            module_class_path: 格式为 "module.path:ClassName" 的字符串
+
+        Returns:
+            适用于注册表的类信息字典
+        """
+        class_info = self.get_class_info_static(module_class_path)
+        if not class_info:
+            return {}
+
+        registry_info = {
+            "class_name": class_info["class_name"],
+            "module_path": class_info["module_path"],
+            "file_path": class_info["file_path"],
+            "methods": {},
+            "properties": [],
+            "init_params": {},
+            "action_methods": {},
+        }
+
+        for method_name, method_info in class_info["methods"].items():
+            # 分类处理不同类型的方法
+            if method_info["is_property"]:
+                registry_info["properties"].append(
+                    {
+                        "name": method_name,
+                        "return_type": method_info.get("return_type"),
+                        "docstring": method_info.get("docstring"),
+                    }
+                )
+            elif method_name == "__init__":
+                # 处理初始化参数
+                init_params = {}
+                for arg in method_info["args"]:
+                    if arg["name"] != "self":
+                        param_info = {
+                            "name": arg["name"],
+                            "type": arg.get("type") or arg.get("inferred_type"),
+                            "required": arg.get("is_required", True),
+                            "default": arg.get("default"),
+                        }
+                        init_params[arg["name"]] = param_info
+                registry_info["init_params"] = init_params
+            elif not method_name.startswith("_"):
+                # 处理公共方法（可能的action方法）
+                action_info = {
+                    "name": method_name,
+                    "params": {},
+                    "return_type": method_info.get("return_type"),
+                    "docstring": method_info.get("docstring"),
+                    "num_required": method_info.get("num_required", 0) - 1,  # 减去self
+                    "num_defaults": method_info.get("num_defaults", 0),
+                }
+
+                for arg in method_info["args"]:
+                    if arg["name"] != "self":
+                        param_info = {
+                            "name": arg["name"],
+                            "type": arg.get("type") or arg.get("inferred_type"),
+                            "required": arg.get("is_required", True),
+                            "default": arg.get("default"),
+                        }
+                        action_info["params"][arg["name"]] = param_info
+
+                registry_info["action_methods"][method_name] = action_info
+
+        return registry_info
 
 
 # 全局实例，便于直接使用
@@ -413,6 +809,16 @@ def init_from_list(module_list: List[str]) -> None:
     default_manager = ImportManager(module_list)
 
 
-def get_enhanced_class_info(module_path: str, **kwargs) -> Dict[str, Any]:
+def get_class_info_static(module_class_path: str) -> Dict[str, Any]:
+    """静态分析获取类信息的便捷函数"""
+    return default_manager.get_class_info_static(module_class_path)
+
+
+def get_registry_class_info(module_class_path: str) -> Dict[str, Any]:
+    """获取适用于注册表的类信息的便捷函数"""
+    return default_manager.get_registry_class_info(module_class_path)
+
+
+def get_enhanced_class_info(module_path: str, use_dynamic: bool = True) -> Dict[str, Any]:
     """获取增强的类信息的便捷函数"""
-    return default_manager.get_enhanced_class_info(module_path, **kwargs)
+    return default_manager.get_enhanced_class_info(module_path, use_dynamic)

unilabos/utils/log.py

@@ -217,6 +217,7 @@ def configure_logger(loglevel=None, working_dir=None):
     return log_filepath
 
 
+
 # 配置日志系统
 configure_logger()
 

unilabos/utils/requirements.txt

@@ -1,8 +1,7 @@
 networkx
 typing_extensions
 websockets
-msgcenterpy>=0.1.8
-orjson>=3.11
+msgcenterpy>=0.1.5
 opentrons_shared_data
 pint
 fastapi

unilabos/utils/tools.py

@@ -1,39 +1,4 @@
-import json
-
-from unilabos.utils.type_check import TypeEncoder, json_default
-
-try:
-    import orjson
-
-    def fast_dumps(obj, **kwargs) -> bytes:
-        """JSON 序列化为 bytes，优先使用 orjson。"""
-        return orjson.dumps(obj, option=orjson.OPT_NON_STR_KEYS, default=json_default)
-
-    def fast_dumps_pretty(obj, **kwargs) -> bytes:
-        """JSON 序列化为 bytes（带缩进），优先使用 orjson。"""
-        return orjson.dumps(
-            obj,
-            option=orjson.OPT_NON_STR_KEYS | orjson.OPT_INDENT_2,
-            default=json_default,
-        )
-
-    def normalize_json(info: dict) -> dict:
-        """经 JSON 序列化/反序列化一轮来清理非标准类型。"""
-        return orjson.loads(orjson.dumps(info, default=json_default))
-
-except ImportError:
-
-    def fast_dumps(obj, **kwargs) -> bytes:  # type: ignore[misc]
-        return json.dumps(obj, ensure_ascii=False, cls=TypeEncoder).encode("utf-8")
-
-    def fast_dumps_pretty(obj, **kwargs) -> bytes:  # type: ignore[misc]
-        return json.dumps(obj, indent=2, ensure_ascii=False, cls=TypeEncoder).encode("utf-8")
-
-    def normalize_json(info: dict) -> dict:  # type: ignore[misc]
-        return json.loads(json.dumps(info, ensure_ascii=False, cls=TypeEncoder))
-
-
 # 辅助函数：将UUID数组转换为字符串
 def uuid_to_str(uuid_array) -> str:
     """将UUID字节数组转换为十六进制字符串"""
-    return "".join(format(byte, "02x") for byte in uuid_array)
+    return "".join(format(byte, "02x") for byte in uuid_array)

unilabos/utils/type_check.py

@@ -15,21 +15,14 @@ def get_type_class(type_hint):
     return final_type
 
 
-def json_default(obj):
-    """将 type 对象序列化为类名，其余 fallback 到 str()。"""
-    if isinstance(obj, type):
-        return str(obj)[8:-2]
-    return str(obj)
-
-
 class TypeEncoder(json.JSONEncoder):
     """自定义JSON编码器处理特殊类型"""
 
     def default(self, obj):
-        try:
-            return json_default(obj)
-        except Exception:
-            return super().default(obj)
+        # 优先处理类型对象
+        if isinstance(obj, type):
+            return str(obj)[8:-2]
+        return super().default(obj)
 
 
 class NoAliasDumper(yaml.SafeDumper):
@@ -50,10 +43,13 @@ class ResultInfoEncoder(json.JSONEncoder):
     """专门用于处理任务执行结果信息的JSON编码器"""
 
     def default(self, obj):
+        # 优先处理类型对象
         if isinstance(obj, type):
-            return json_default(obj)
+            return str(obj)[8:-2]
 
+        # 对于无法序列化的对象，统一转换为字符串
         try:
+            # 尝试调用 __dict__ 或者其他序列化方法
             if hasattr(obj, "__dict__"):
                 return obj.__dict__
             elif hasattr(obj, "_asdict"):  # namedtuple
@@ -63,8 +59,10 @@ class ResultInfoEncoder(json.JSONEncoder):
             elif hasattr(obj, "dict"):
                 return obj.dict()
             else:
+                # 如果都不行，转换为字符串
                 return str(obj)
         except Exception:
+            # 如果转换失败，直接返回字符串表示
             return str(obj)