v0.11.0

update aksk desc

print res query logs

Fix skills exec error with action type

Update Skills

Update Skills addr

Change uni-lab. to leap-lab.
Support unit in pylabrobot

Support async func.

change to leap-lab backend. Support feedback interval. Reduce cocurrent lags.

fix create_resource_with_slot

update unilabos_formulation & batch-submit-exp

scale multi exec thread up to 48

update handle creation api

fit cocurrent gap

add running status debounce

allow non @topic_config support

update skill

add placeholder keys

always free

提交实验技能

disable samples

correct sample demo ret value

新增试剂reagent

update registry

新增manual_confirm

add workstation creation skill

add virtual_sample_demo 样品追踪测试设备

add external devices param
fix registry upload missing type

fast registry load

minor fix on skill & registry

stripe ros2 schema desc
add create-device-skill

new registry system backwards to yaml

remove not exist resource

new registry sys
exp. support with add device

correct raise create resource error

ret info fix revert

ret info fix

fix prcxi check

add create_resource schema

re signal host ready event

add websocket connection timeout and improve reconnection logic

add open_timeout parameter to websocket connection
add TimeoutError and InvalidStatus exception handling
implement exponential backoff for reconnection attempts
simplify reconnection logic flow

.conda/base/recipe.yaml

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

.conda/environment/recipe.yaml

@@ -2,7 +2,7 @@
 
 package:
   name: unilabos-env
-  version: 0.11.3
+  version: 0.11.0
 
 build:
   noarch: generic

.conda/full/recipe.yaml

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

.cursor/skills/add-device/SKILL.md

@@ -5,98 +5,9 @@ description: Guide for adding new devices to Uni-Lab-OS (接入新设备). Uses
 
 # 添加新设备到 Uni-Lab-OS
 
-本 Skill 是自包含的设备接入指南，不依赖外部文档。迁移给别人时，只复制 `.cursor/skills/add-device/SKILL.md` 即可获得核心规则、模板、验证方式和常见错误清单。
+**第一步：** 使用 Read 工具读取 `docs/ai_guides/add_device.md`，获取完整的设备接入指南。
 
-开始实现前，仍应搜索 `unilabos/devices/` 获取同类别已有设备的接口、参数名、状态字符串和返回值风格作为参考。
+该指南包含设备类别（物模型）列表、通信协议模板、常见错误检查清单等。搜索 `unilabos/devices/` 获取已有设备的实现参考。
-
----
-
-## 接入工作流
-
-按下面顺序推进，并在工作中维护进度：
-
-```text
-设备接入进度：
-- [ ] 1. 确定设备类别（物模型）和对外单位
-- [ ] 2. 确定通信协议
-- [ ] 3. 收集指令协议（SDK、厂商文档、寄存器表、HTTP API、用户口述）
-- [ ] 4. 对齐同类设备接口（搜索 unilabos/devices/）
-- [ ] 5. 创建驱动 unilabos/devices/<category>/<file>.py
-- [ ] 6. 验证可导入、注册表扫描、启动测试
-- [ ] 7. 如需要，配置实验图文件
-```
-
-## 设备类别（物模型）
-
-优先使用已有类别。只有确实无法归类时才使用 `custom`。
-
-| 类别 ID | 说明 | 标准属性 | 标准动作 |
-|---|---|---|---|
-| `temperature` | 加热、冷却、温控 | `temp`, `temp_target`, `status` | `set_temperature`, `stop` |
-| `pump_and_valve` | 泵、阀门、注射器 | 见子类型表 | 见子类型表 |
-| `motor` | 电机、步进马达 | `position`, `status` | `enable`, `move_position`, `move_speed`, `stop` |
-| `heaterstirrer` | 加热搅拌一体机 | `temp`, `stir_speed`, `status` | `set_temperature`, `stir`, `stop` |
-| `balance` | 天平、称重 | `weight`, `unit`, `status` | `tare`, `read_weight` |
-| `sensor` | 传感器（液位、温度等） | `value`, `level`, `status` | `read_value`, `set_threshold` |
-| `liquid_handling` | 液体处理机器人 | `status`, `deck_state` | `transfer_liquid`, `aspirate`, `dispense` |
-| `robot_arm` | 机械臂 | `arm_pose`, `arm_status` | `moveit_task`, `pick_and_place` |
-| `workstation` | 工作站、组合设备 | `workflow_sequence`, `material_info` | `create_order`, `scheduler_start`, `scheduler_stop` |
-| `virtual` | 虚拟、模拟设备 | 按模拟的真实设备定义 | 按模拟的真实设备定义 |
-| `custom` | 不属于以上类别 | 用户自定义 | 用户自定义 |
-
-`pump_and_valve` 子类型：
-
-| 子类型 | 最小通用属性 | 最小通用动作 | 单位约定 |
-|---|---|---|---|
-| 注射泵（syringe pump） | `status`, `valve_position`, `position` | `initialize`, `set_valve_position`, `set_position`, `pull_plunger`, `push_plunger`, `stop_operation` | 体积=mL, 速度=mL/s |
-| 电磁阀（solenoid valve） | `status`, `valve_position` | `open`, `close`, `set_valve_position` | 无 |
-| 蠕动泵（peristaltic pump） | `status`, `speed` | `start`, `stop`, `set_speed` | 流速=mL/min |
-
-对外暴露的属性和动作参数必须使用用户友好的物理单位（mL、ul、degC、RPM 等），硬件原始值转换放在驱动内部。
-
-## 通信协议和指令来源
-
-先确认通信方式，再确认具体指令协议。物模型只定义设备“应该做什么”，不会告诉你硬件“具体发什么字节/请求”。
-
-| 协议 | 常用 config 参数 | 常用依赖 | 现有抽象 |
-|---|---|---|---|
-| Serial (RS232/RS485) | `port`, `baudrate`, `timeout` | `pyserial` | 直接使用 `serial.Serial` |
-| Modbus RTU | `port`, `baudrate`, `slave_id` | `pymodbus` | `device_comms/modbus_plc/` |
-| Modbus TCP | `host`, `port`, `slave_id` | `pymodbus` | `device_comms/modbus_plc/` |
-| TCP Socket | `host`, `port`, `timeout` | stdlib | 直接使用 `socket` |
-| HTTP API | `url`, `token`, `timeout` | `requests` | `device_comms/rpc.py` |
-| OPC UA | `url` | `opcua` | `device_comms/opcua_client/` |
-| 无通信（虚拟） | 无 | 无 | 在动作中模拟行为 |
-
-必须从以下来源之一获得指令细节：
-
-| 来源 | 处理方式 |
-|---|---|
-| 现成 SDK/驱动代码 | 读取代码，提取指令逻辑，包装进 Uni-Lab-OS 类 |
-| 协议文档/手册 | 解析命令、响应、校验、寄存器、错误码 |
-| 用户口述 | 按描述实现指令编解码，标出不确定点 |
-| 标准协议 | 使用标准实现，例如 Modbus 寄存器表、SCPI |
-| 虚拟设备 | 跳过硬件通信，在动作方法中维护模拟状态 |
-
-## 对齐已有实现（强制）
-
-实现前必须搜索 `unilabos/devices/` 中同类别设备：
-
-- 参数名必须与已有设备保持一致；动作方法参数名是接口契约，不要随意改成 `volume_ml`、`target_temp_c` 这类新名字。
-- `status` 字符串值要和同类设备一致，优先使用英文稳定值，例如 `Idle`、`Running`、`Error`。
-- 状态属性用 `@property` + `@topic_config()` 明确声明。
-- 返回值使用结构化 dict，至少包含 `success`，需要给前端展示的信息放在 `message`、`data`、`error` 等字段。
-
-## 架构选择
-
-| 场景 | 推荐方式 |
-|---|---|
-| 简单设备 | 纯 Python 类 + `@device` |
-| 工作站/组合设备 | `WorkstationBase` 或项目内已有工作站模式 |
-| 液体处理 | `LiquidHandlerAbstract` / PyLabRobot 相关模式 |
-| Modbus 设备 | 复用 `device_comms/modbus_plc/` 或项目内 Modbus 示例 |
-| OPC UA 设备 | 复用 `device_comms/opcua_client/` |
-| 外部独立包 | 使用 `create-device-package` skill |
 
 ---
 
@@ -160,45 +71,6 @@ from unilabos.registry.decorators import action
 - `_` 开头的方法 → 不扫描
 - `@not_action` 标记的方法 → 排除
 
-### 参数文档 → JSON Schema 元数据
-
-在 `__init__` 和 action 方法 docstring 的 `Args:` 小节里，使用以下格式生成入参 schema 的显示信息：
-
-```python
-"""
-Args:
-    param[显示名称]: 参数说明，会写入 JSON Schema 的 description。
-"""
-```
-
-- `param[显示名称]` 的显示名称会写入 goal property 的 `title`。
-- `:` 后面的说明会写入 goal property 的 `description`。
-- 如果只写 `param: 参数说明`，`title` 会兜底为字段名，`description` 使用参数说明。
-- 如果没有写参数文档，生成器也会兜底补齐 `title=<字段名>` 和 `description=""`，但新设备应优先写清楚显示名和说明。
-
-### 特殊参数类型：ResourceSlot / DeviceSlot
-
-需要前端选择资源或设备时，用特殊类型注解，registry 会自动生成 `placeholder_keys`：
-
-```python
-from typing import List
-from unilabos.registry.placeholder_type import DeviceSlot, ResourceSlot
-
-@action(description="转移液体")
-def transfer(self, source: ResourceSlot, target: ResourceSlot, volume_ul: float) -> dict:
-    """
-    Args:
-        source[源资源]: 源容器或孔位。
-        target[目标资源]: 目标容器或孔位。
-        volume_ul[体积(ul)]: 转移体积。
-    """
-    return {"success": True}
-
-@action(description="同步设备")
-def sync_devices(self, devices: List[DeviceSlot]) -> dict:
-    return {"success": True, "count": len(devices)}
-```
-
 ### @topic_config — 状态属性配置
 
 ```python
@@ -233,27 +105,13 @@ import logging
 from typing import Any, Dict, Optional
 
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-from unilabos.registry.decorators import action, device, not_action, topic_config
+from unilabos.registry.decorators import device, action, topic_config, not_action
 
-@device(
+@device(id="my_device", category=["my_category"], description="设备描述")
-    id="my_device",
-    category=["my_category"],
-    description="设备描述",
-    display_name="设备显示名",
-)
 class MyDevice:
-    """设备类说明。"""
-
     _ros_node: BaseROS2DeviceNode
 
     def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
-        """
-        初始化设备。
-
-        Args:
-            device_id[设备ID]: 设备实例 ID，默认使用 my_device。
-            config[设备配置]: 设备启动配置。
-        """
         self.device_id = device_id or "my_device"
         self.config = config or {}
         self.logger = logging.getLogger(f"MyDevice.{self.device_id}")
@@ -275,13 +133,7 @@ class MyDevice:
 
     @action(description="执行操作")
     def my_action(self, param: float = 0.0, name: str = "") -> Dict[str, Any]:
-        """
+        """带 @action 装饰器 → 注册为 'my_action' 动作"""
-        带 @action 装饰器 → 注册为 'my_action' 动作。
-
-        Args:
-            param[操作数值]: 操作使用的数值参数。
-            name[操作名称]: 操作名称或备注。
-        """
         return {"success": True}
 
     def get_info(self) -> Dict[str, Any]:
@@ -306,154 +158,3 @@ class MyDevice:
 - `post_init` 用 `@not_action` 标记，参数类型标注为 `BaseROS2DeviceNode`
 - 运行时状态存储在 `self.data` 字典中
 - 设备文件放在 `unilabos/devices/<category>/` 目录下
-
----
-
-## 通信实现片段
-
-Serial 文本指令：
-
-```python
-def _send_command(self, cmd: str) -> str:
-    self.ser.write(f"{cmd}\r\n".encode())
-    return self.ser.readline().decode().strip()
-```
-
-RS-485 响应解析要先定位帧头，不要用硬编码索引直接解析原始响应：
-
-```python
-def _normalize_response(self, raw: str, start_marker: str = "/") -> str:
-    pos = raw.find(start_marker)
-    return raw[pos:] if pos >= 0 else raw
-```
-
-自定义二进制帧：
-
-```python
-def _build_frame(self, func_code: int, data: bytes) -> bytes:
-    frame = bytearray([0xFE, func_code]) + bytearray(data)
-    checksum = sum(frame[1:]) % 256
-    frame.append(checksum)
-    return bytes(frame)
-```
-
-Modbus 寄存器映射：
-
-```python
-REGISTER_MAP = {
-    "temp_target": {"addr": 0x000B, "scale": 10},
-}
-
-def set_temperature(self, temp: float, **kwargs) -> bool:
-    reg = REGISTER_MAP["temp_target"]
-    value = int(float(temp) * reg["scale"]) & 0xFFFF
-    self.client.write_register(reg["addr"], value, slave=self.slave_id)
-    self.data["temp_target"] = temp
-    return True
-```
-
-HTTP API 映射：
-
-```python
-API_MAP = {
-    "set_temperature": {
-        "method": "POST",
-        "endpoint": "/api/temperature",
-        "body_key": "target",
-    },
-}
-```
-
-SDK 封装：
-
-```python
-from my_device_sdk import DeviceController
-
-class MyDevice:
-    def __init__(self, device_id=None, config=None, **kwargs):
-        self.config = config or {}
-        self.controller = DeviceController(port=self.config.get("port", "COM1"))
-```
-
----
-
-## 验证
-
-无需手写注册表 YAML。`@device` 装饰器 + AST 扫描会在启动或检查时生成注册表条目。
-
-```bash
-# 1. 模块可导入
-python -c "from unilabos.devices.<category>.<file> import <ClassName>"
-
-# 2. 启动测试
-unilab -g <graph>.json
-
-# 3. 仅检查注册表
-unilab --check_mode --skip_env_check
-```
-
-仅在旧代码无 `@device`、需要覆盖特殊字段、或做 `--complete_registry` 旧设备补全时，才考虑 YAML。新设备默认不要手写 YAML。
-
-## 图文件节点模板
-
-实验图 JSON 中的 `class` 对应 `@device(id=...)`，`config` 会传入 `__init__` 的 `config` 字典：
-
-```json
-{
-  "id": "my_device_1",
-  "name": "我的设备",
-  "children": [],
-  "parent": null,
-  "type": "device",
-  "class": "my_device",
-  "position": {"x": 0, "y": 0, "z": 0},
-  "config": {
-    "port": "/dev/ttyUSB0",
-    "baudrate": 9600
-  },
-  "data": {}
-}
-```
-
-工作站需要同时配置 `deck` 和 `children`：
-
-```json
-{
-  "nodes": [
-    {
-      "id": "my_station",
-      "type": "device",
-      "class": "my_workstation",
-      "children": ["my_deck"],
-      "config": {},
-      "deck": {
-        "data": {
-          "_resource_child_name": "my_deck",
-          "_resource_type": "unilabos.resources.my_module:MyDeck"
-        }
-      }
-    },
-    {
-      "id": "my_deck",
-      "type": "deck",
-      "class": "MyDeckClass",
-      "parent": "my_station",
-      "config": {"type": "MyDeckClass", "setup": true}
-    }
-  ]
-}
-```
-
----
-
-## 常见错误清单
-
-- 缺少 `@device`：设备不会被 AST 扫描发现。
-- 只有 `@property` 没有 `@topic_config()`：属性不会稳定广播到 `status_types`。
-- `post_init` 没有 `@not_action`：会被误暴露为动作。
-- `self.data = {}`：空字典会导致属性读取和 schema 初始数据不稳定，必须预填充每个状态键。
-- 动作参数重命名：不要把同类设备已有的 `volume` 改成 `volume_ml`，参数名是接口契约。
-- `status` 使用中文或临时文本：前端和工作流依赖稳定英文状态值。
-- async 方法中使用 `time.sleep()`：应使用 `await self._ros_node.sleep(seconds)`。
-- 硬编码串口响应索引：RS-485 响应前可能有噪声字节，应先定位帧头。
-- 把硬件寄存器单位暴露给用户：对外使用物理单位，驱动内部做 scale 转换。

.cursor/skills/filter-workflow-by-tags/SKILL.md

@@ -1,450 +0,0 @@
----
-name: filter-workflow-by-tags
-description: Query backend workflow list, aggregate all tags, and filter workflows by domain/scenario requirements using tags. Use when the user wants to search workflows, find workflows by tags, list available workflow tags, filter workflows by category/domain/scenario, or mentions 工作流筛选/标签查询/workflow tags/按领域查找工作流.
----
-# Uni-Lab 工作流标签筛选指南
-
-通过 Uni-Lab 云端 API 查询工作流列表，汇总所有可用标签（tags），并根据领域和场景要求筛选工作流。
-
-> **重要**：本指南中的 `Authorization: Lab <token>` 是 **Uni-Lab 平台专用的认证方式**，`Lab` 是 Uni-Lab 的 auth scheme 关键字，**不是** HTTP Basic 认证。请勿将其替换为 `Basic`。
-
-## 使用模式识别
-
-**用户可能一开始就给出场景目标**（如"我要做有机合成实验"、"找柱层析相关的 protocol"）。此时：
-
-1. **识别场景关键词** → 映射到可能的 tags（如 synthesis、organic、chromatography、purification）
-2. **直接执行完整流程**（获取 ak/sk/addr → 拉取所有工作流 → 汇总 tags → 按场景筛选）
-3. **展示筛选结果** → 引导用户从候选 workflow 中**选择明确的实验 protocol**
-4. **如果用户确认某个 workflow** → 记录 `workflow_uuid`，准备对接“与其他 Skill 的协作”
-
-**如果用户未给场景目标**，则按标准 checklist 询问筛选条件。
-
----
-
-## 前置条件
-
-使用本指南前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
-
-### 1. ak / sk → AUTH
-
-询问用户的启动参数，从 `--ak` `--sk` 或 config.py 中获取。
-
-生成 AUTH token：
-
-```bash
-python -c "import base64,sys; print('Authorization: Lab ' + base64.b64encode(f'{sys.argv[1]}:{sys.argv[2]}'.encode()).decode())" <ak> <sk>
-```
-
-### 2. --addr → BASE URL
-
-| `--addr` 值 | BASE                                  |
-| ------------- | ------------------------------------- |
-| `test`      | `https://leap-lab.test.bohrium.com` |
-| `uat`       | `https://leap-lab.uat.bohrium.com`  |
-| `local`     | `http://127.0.0.1:48197`            |
-| 不传（默认）  | `https://leap-lab.bohrium.com`      |
-
-确认后设置：
-
-```bash
-BASE="<根据 addr 确定的 URL>"
-AUTH="Authorization: Lab <上面命令输出的 token>"
-```
-
-### 3. lab_uuid（实验室 UUID）
-
-如果用户未提供 `lab_uuid`，通过以下 API 自动获取：
-
-```bash
-curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
-```
-
-返回 `data.uuid` 即为 `lab_uuid`。
-
-**三项全部就绪后才可开始。**
-
-## Session State
-
-在整个对话过程中，agent 需要记住以下状态：
-
-- `lab_uuid` — 实验室 UUID
-- `all_workflows` — 完整工作流列表（分页获取后缓存到内存或临时文件）
-- `all_tags` — 所有工作流的标签汇总
-
----
-
-## API 端点
-
-### 查询工作流列表（支持分页）
-
-```
-GET $BASE/api/v1/lab/workflow/owner/list?page=<page>&page_size=<page_size>&lab_uuid=$lab_uuid
-```
-
-**参数：**
-
-- `page` — 页码，从 1 开始
-- `page_size` — 每页数量，建议 1000
-- `lab_uuid` — 实验室 UUID
-
-**返回结构：**
-
-```json
-{
-  "code": 0,
-  "data": {
-    "has_more": true,
-    "data": [
-      {
-        "uuid": "9661bba2-1b9f-4687-a63d-910245df174b",
-        "name": "Untitled",
-        "description": "",
-        "user_id": "114211",
-        "published": false,
-        "tags": null
-      },
-      {
-        "uuid": "e0436638-190b-46bc-b1a1-2711d9602f6a",
-        "name": "Synthesis v2",
-        "user_id": "114211",
-        "published": true,
-        "tags": ["synthesis", "organic"]
-      }
-    ]
-  }
-}
-```
-
-**字段说明：**
-
-- `has_more` — 若为 `true`，需要继续请求 `page+1`
-- `tags` — 可能为 `null`、空数组或字符串数组；聚合时必须容忍 `null`
-
-### 启动工作流（直接运行）
-
-```
-POST $BASE/api/v1/lab/workflow/<workflow_uuid>/run
-```
-
-**用途：** 直接启动一个 workflow 的默认执行（使用模板中预设的参数），无需创建 notebook。适用于快速测试或无参数变化的重复执行。
-
-**请求体：** 空 JSON `{}` 或省略
-
-**返回：**
-
-```json
-{
-  "code": 0,
-  "data": "<run_uuid>"
-}
-```
-
-- `run_uuid` — 本次执行的唯一标识（不是 notebook UUID）
-
-**注意：**
-
-- 该接口会使用 workflow 模板中保存的默认参数直接执行
-- 如果 workflow 需要动态参数（如 CSV 路径、样品 UUID），应使用 `POST /lab/notebook` 创建 notebook 并传入 `node_params`
-- 返回的 `run_uuid` 可直接传入下方「查询任务状态」接口查询实时进度
-
-### 查询任务状态
-
-```
-GET $BASE/api/v1/lab/mcp/task/<task_uuid>
-```
-
-**用途：** 查询由 `POST /lab/workflow/<uuid>/run` 返回的 `run_uuid`（即 task_uuid）的实时执行状态，包括整体状态和每个节点（JOS：Job On Station）的执行详情。
-
-**路径参数：**
-
-- `task_uuid` — 等同于启动工作流接口返回的 `run_uuid`
-
-**返回：**
-
-```json
-{
-  "code": 0,
-  "data": {
-    "status": "running",
-    "jos_status": [
-      {
-        "uuid": "d0e24bfe-8d99-450e-b19d-f25849dfbaad",
-        "node_name": "PRCXI_BioER_96_wellplate_slot_1",
-        "action_name": "create_resource",
-        "status": "success",
-        "return_info": {
-          "suc": true,
-          "error": "",
-          "return_value": { ... }
-        }
-      },
-      {
-        "uuid": "...",
-        "node_name": "...",
-        "action_name": "transfer_liquid",
-        "status": "pending",
-        "return_info": null
-      }
-    ]
-  }
-}
-```
-
-**字段说明：**
-
-- `data.status` — 整体任务状态
-  - `running` — 正在执行（至少一个节点 pending 或 running）
-  - `success` — 全部节点成功
-  - `failed` — 有节点失败
-- `data.jos_status[]` — 节点级执行列表（按执行顺序）
-  - `uuid` — 节点执行实例 UUID
-  - `node_name` — 节点名称（资源/设备名或工位名）
-  - `action_name` — 动作类型（`create_resource`、`transfer_liquid`、`centrifuge`、等）
-  - `status` — 节点状态：`success`、`pending`、`running`、`failed`
-  - `return_info` — 执行返回，失败时 `suc=false` 且 `error` 有错误信息
-
-**注意：**
-
-- 此接口的 `task_uuid` **是** `POST /lab/workflow/<uuid>/run` 返回的 `run_uuid`，二者为同一个 ID 的不同称呼
-- **不要**把 notebook UUID（`POST /lab/notebook` 返回）传进来——那条路径用 `GET /lab/notebook/status` 查询
-- `jos_status` 数组按节点执行顺序给出；从 pending 数量可以估算剩余进度
-- 返回体可能较大（`return_info.return_value` 中可能包含完整 resource tree），可在脚本中只提取 `status` + `node_name` + `action_name` 做摘要
-
-**状态轮询示例：**
-
-```bash
-# 每 5 秒轮询一次直至完成
-TASK="b183d97e-d2b5-4b24-b14b-820df04d87c0"
-while :; do
-  st=$(curl -s -X GET "$BASE/api/v1/lab/mcp/task/$TASK" -H "$AUTH" \
-    | python3 -c "import json,sys; d=json.load(sys.stdin)['data']; \
-      print(d['status'], '|', sum(1 for j in d['jos_status'] if j['status']=='success'), '/', len(d['jos_status']))")
-  echo "$(date +%H:%M:%S) $st"
-  [[ "$st" == success* || "$st" == failed* ]] && break
-  sleep 5
-done
-```
-
----
-
-## 完整工作流 Checklist
-
-```
-Task Progress:
-- [ ] Step 0: 识别用户是否已给出场景目标（如"有机合成"、"柱层析"）
-       - 若已给出 → 记录场景关键词，自动进入后续步骤
-       - 若未给出 → 在 Step 6 询问用户
-- [ ] Step 1: 确认 ak/sk → 生成 AUTH token
-- [ ] Step 2: 确认 --addr → 设置 BASE URL
-- [ ] Step 3: GET /edge/lab/info → 获取 lab_uuid（如用户未提供）
-- [ ] Step 4: 分页获取所有工作流（从 page=1 开始直到 has_more=false）
-- [ ] Step 5: 汇总所有非空 tags → 生成 all_tags（去重、排序、附出现次数）
-- [ ] Step 6: 根据场景关键词（Step 0 或新询问）在 all_tags 中做语义映射 → 确定候选 tags
-       - 若语义映射不唯一，列出候选 tags 让用户确认
-- [ ] Step 7: 按候选 tags 筛选工作流（默认 any 模式，召回优先）
-- [ ] Step 8: 展示筛选结果（uuid、name、description、tags、published）
-- [ ] Step 9: 引导用户从结果中选择**明确的实验 protocol**
-       - 若结果只有 1 条 → 直接确认该 workflow_uuid
-       - 若结果 2–10 条 → 让用户按编号选择
-       - 若结果过多 → 提示收紧条件（加 tag、切换 all 模式、仅 published）
-       - 若结果为空 → 放宽条件（去掉最稀有 tag）或提示用户换关键词
-- [ ] Step 10: 记录用户选中的 workflow_uuid，并提示提交实验或查看详情
-```
-
----
-
-## 推荐路径：使用脚本
-
-同目录下提供 `scripts/filter_workflows.py`，一次完成分页抓取、标签聚合与筛选：
-
-```bash
-# 1. 仅汇总标签（不筛选）
-python scripts/filter_workflows.py \
-  --auth "<Lab base64token>" \
-  --base "$BASE" \
-  --lab-uuid "$lab_uuid" \
-  --summary-only
-
-# 2. 按标签筛选（ANY 模式：包含任一）
-python scripts/filter_workflows.py \
-  --auth "<Lab base64token>" \
-  --base "$BASE" \
-  --lab-uuid "$lab_uuid" \
-  --tags synthesis organic \
-  --mode any
-
-# 3. 按标签筛选（ALL 模式：必须同时包含）
-python scripts/filter_workflows.py \
-  --auth "<Lab base64token>" \
-  --base "$BASE" \
-  --lab-uuid "$lab_uuid" \
-  --tags synthesis organic \
-  --mode all \
-  --output filtered.json
-
-# 4. 仅筛选已发布
-python scripts/filter_workflows.py \
-  --auth "<Lab base64token>" \
-  --base "$BASE" \
-  --lab-uuid "$lab_uuid" \
-  --tags synthesis \
-  --published-only
-```
-
-**`--auth` 参数说明**：传入 `Authorization` 头中 `Lab` 之后的 base64 token（不带 `Lab ` 前缀），脚本内部会自动补上 scheme。
-
-**输出结构：**
-
-```json
-{
-  "total_workflows": 150,
-  "tag_counts": {"synthesis": 12, "organic": 8, "analysis": 5},
-  "all_tags": ["analysis", "organic", "synthesis"],
-  "filter": {"tags": ["synthesis", "organic"], "mode": "any"},
-  "filtered_workflows": [
-    {"uuid": "...", "name": "...", "description": "...", "tags": [...], "published": true}
-  ]
-}
-```
-
----
-
-## 手动路径：curl + jq
-
-如果脚本不可用或环境缺少 Python，可用 shell 实现。
-
-### 1. 分页抓取（写入 `all_workflows.json`）
-
-```bash
-page=1
-echo "[]" > all_workflows.json
-
-while :; do
-  resp=$(curl -s -X GET \
-    "$BASE/api/v1/lab/workflow/owner/list?page=$page&page_size=1000&lab_uuid=$lab_uuid" \
-    -H "$AUTH")
-
-  page_data=$(echo "$resp" | jq -c '.data.data // []')
-  jq -c --argjson p "$page_data" '. + $p' all_workflows.json > _tmp.json && mv _tmp.json all_workflows.json
-
-  has_more=$(echo "$resp" | jq -r '.data.has_more')
-  [ "$has_more" != "true" ] && break
-  page=$((page + 1))
-done
-
-echo "Total: $(jq 'length' all_workflows.json)"
-```
-
-### 2. 汇总所有标签（含出现次数）
-
-```bash
-jq '[.[].tags // [] | .[]] | group_by(.) | map({tag: .[0], count: length}) | sort_by(-.count)' \
-  all_workflows.json
-```
-
-### 3. 按标签筛选
-
-```bash
-# ANY：包含任一指定标签
-jq --argjson want '["synthesis","organic"]' \
-  '[.[] | select((.tags // []) | any(. as $t | $want | index($t)))]' \
-  all_workflows.json
-
-# ALL：同时包含所有指定标签
-jq --argjson want '["synthesis","organic"]' \
-  '[.[] | select(($want | all(. as $w | (.tags // []) | index($w))))]' \
-  all_workflows.json
-```
-
----
-
-## 筛选策略
-
-agent 拿到用户的「领域 + 场景」自然语言描述时，按如下顺序选择 tag：
-
-1. **优先用户显式指定的 tags**：若用户明确给出标签词，直接精确匹配。
-2. **从 all_tags 中做语义映射**：若用户描述是自然语言（如"有机合成、柱层析"），在 all_tags 中找语义相关项（如 `synthesis`、`organic`、`chromatography`）。必要时展示候选 tag 让用户确认。
-3. **模式选择**：
-   - 默认 `any`（更多召回），给出 tag 集合的并集匹配
-   - 用户强调"必须同时满足"时用 `all`
-4. **空结果兜底**：如果筛选为空，放宽条件（去掉最稀有 tag、切换 any 模式），并提醒用户。
-
----
-
-## 引导到明确的 Protocol
-
-筛选完成后，**最终目标是让用户确认一个具体的 workflow_uuid**，而不是停留在"一堆候选"上。按结果数量采取不同策略：
-
-| 结果数量  | 策略                                                                                                                               |
-| --------- | ---------------------------------------------------------------------------------------------------------------------------------- |
-| 0 条      | 放宽筛选（去掉最稀有 tag → 切换 any 模式 → 去掉 `--published-only`）。仍为空则提示换关键词，或列出 `all_tags` 让用户重新选。 |
-| 1 条      | 直接确认："找到唯一匹配：`<name>` (uuid `<uuid>`)，是否用它？"用户确认后记录 `workflow_uuid`。                               |
-| 2–10 条  | 编号列表展示，让用户选编号。每项给出 name、tags、description 摘要、published 状态。                                                |
-| 10–30 条 | 先展示 tag 分布帮助用户进一步收紧：列出匹配结果中最常见的子标签，提示"加一个 tag 可将结果缩小到 N 条"。                            |
-| >30 条    | 强制要求用户补充条件：仅 published、指定具体 tag 组合、或按名称关键词过滤。                                                        |
-
-**确认 workflow 后**：
-
-1. 将 `workflow_uuid` 写入 session state
-2. 提示用户下一步可用的 skill：
-   - 提交实验 → 引导到“与其他 Skill 的协作”
-   - 查看 workflow 详细节点 → `GET /api/v1/lab/workflow/template/detail/<workflow_uuid>`
-3. 若用户想换一个，回到筛选步骤。
-
----
-
-## 展示结果
-
-推荐格式（表格 + 汇总统计）：
-
-```
-共 150 个工作流，其中 32 个匹配筛选条件 [tags: synthesis OR organic]
-
-| UUID (短) | 名称                     | Tags                         | 已发布 |
-|-----------|--------------------------|------------------------------|--------|
-| e0436638  | Synthesis v2             | synthesis, organic           | ✓      |
-| 5b60dbb8  | Grignard Protocol        | synthesis, organometallic    | ✓      |
-| ...       | ...                      | ...                          | ...    |
-
-所有可用标签（按频次）：
-  synthesis (12), organic (8), analysis (5), purification (4), ...
-```
-
-如果用户下一步想执行某工作流 → 引导到“与其他 Skill 的协作”。
-
----
-
-## 常见问题
-
-### Q: tags 为 null 的工作流要不要展示？
-
-默认**不展示**在筛选结果中（因为无法按 tag 匹配）。但在 `--summary-only` 或无筛选条件时，这些工作流仍会计入总数，并在输出中单独列出"未打标签"计数。
-
-### Q: 如何按名称/描述做模糊匹配？
-
-脚本未内置，但可在 jq 中组合：
-
-```bash
-jq '[.[] | select((.name + " " + (.description // "")) | test("organic"; "i"))]' all_workflows.json
-```
-
-### Q: `page_size=1000` 是否会被服务端限制？
-
-接口通常允许最大 1000；如果返回量少于 1000 且 `has_more=false`，说明已到末页。极端情况下若服务端返回错误，可降到 200 或 500 再试。
-
-### Q: 工作流数量极大（>10k）怎么办？
-
-1. 先跑 `--summary-only` 了解 tag 分布
-2. 提示用户先限定 `--published-only` 或指定 tag
-3. 考虑将 `all_workflows.json` 缓存到本地，下次直接复用
-
----
-
-## 与其他 Skill 的协作
-
-- 正常情况下，找到 workflow 之后可以直接用它提交实验（启动工作流的 api 端点 POST $BASE/api/v1/lab/workflow/<workflow_uuid>/run，不用别的 skill）
-- **仅当需要进行多次实验时，使用 batch-submit-experiment** — 筛选到目标工作流后，`workflow_uuid` 直接用于实验提交
-
-## 脚本依赖
-
-`scripts/filter_workflows.py` 仅使用 Python 标准库（`urllib`、`json`、`argparse`），无需额外安装。

.cursor/skills/filter-workflow-by-tags/scripts/filter_workflows.py

@@ -1,191 +0,0 @@
-#!/usr/bin/env python3
-"""分页拉取 Uni-Lab 工作流列表，汇总 tags 并按 tag 筛选。
-
-使用示例:
-    python filter_workflows.py \
-        --auth <base64token> \
-        --base https://leap-lab.test.bohrium.com \
-        --lab-uuid a9059772-... \
-        --tags synthesis organic --mode any
-
-仅依赖 Python 标准库。
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-import urllib.error
-import urllib.parse
-import urllib.request
-from collections import Counter
-
-
-def fetch_all_workflows(base: str, auth_token: str, lab_uuid: str, page_size: int = 1000) -> list[dict]:
-    """分页拉取所有 owner 工作流，直到 has_more=false。"""
-    workflows: list[dict] = []
-    page = 1
-    while True:
-        query = urllib.parse.urlencode(
-            {"page": page, "page_size": page_size, "lab_uuid": lab_uuid}
-        )
-        url = f"{base.rstrip('/')}/api/v1/lab/workflow/owner/list?{query}"
-        req = urllib.request.Request(
-            url,
-            headers={
-                "Authorization": f"Lab {auth_token}",
-                "Accept": "application/json",
-            },
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=30) as resp:
-                payload = json.loads(resp.read().decode("utf-8"))
-        except urllib.error.HTTPError as e:
-            sys.exit(f"[ERROR] HTTP {e.code} on page {page}: {e.read().decode('utf-8', 'ignore')}")
-        except urllib.error.URLError as e:
-            sys.exit(f"[ERROR] URL error on page {page}: {e.reason}")
-
-        if payload.get("code") != 0:
-            sys.exit(f"[ERROR] API returned non-zero code: {payload}")
-
-        data = payload.get("data") or {}
-        page_items = data.get("data") or []
-        workflows.extend(page_items)
-
-        if not data.get("has_more"):
-            break
-        page += 1
-        # 防御性兜底，避免接口异常导致无限循环
-        if page > 1000:
-            print(f"[WARN] page count exceeded 1000, stopping early", file=sys.stderr)
-            break
-
-    return workflows
-
-
-def aggregate_tags(workflows: list[dict]) -> tuple[list[str], dict[str, int], int]:
-    """返回 (sorted_tags, tag_counts, untagged_count)。"""
-    counter: Counter[str] = Counter()
-    untagged = 0
-    for wf in workflows:
-        tags = wf.get("tags")
-        if not tags:
-            untagged += 1
-            continue
-        for t in tags:
-            if isinstance(t, str) and t.strip():
-                counter[t.strip()] += 1
-    return sorted(counter.keys()), dict(counter), untagged
-
-
-def filter_workflows(
-    workflows: list[dict],
-    want_tags: list[str],
-    mode: str,
-    published_only: bool,
-) -> list[dict]:
-    """按 tag 筛选。mode 取值 any / all。"""
-    want_set = {t.strip() for t in want_tags if t.strip()}
-    out: list[dict] = []
-    for wf in workflows:
-        if published_only and not wf.get("published"):
-            continue
-        if not want_set:
-            out.append(wf)
-            continue
-        tags = wf.get("tags") or []
-        tag_set = {t for t in tags if isinstance(t, str)}
-        if mode == "all":
-            if want_set.issubset(tag_set):
-                out.append(wf)
-        else:  # any
-            if want_set & tag_set:
-                out.append(wf)
-    return out
-
-
-def project_workflow(wf: dict) -> dict:
-    """精简输出字段。"""
-    return {
-        "uuid": wf.get("uuid"),
-        "name": wf.get("name"),
-        "description": wf.get("description", ""),
-        "tags": wf.get("tags") or [],
-        "published": bool(wf.get("published")),
-        "user_id": wf.get("user_id"),
-    }
-
-
-def parse_args() -> argparse.Namespace:
-    p = argparse.ArgumentParser(description="Fetch & filter Uni-Lab workflows by tags.")
-    p.add_argument("--auth", required=True, help="Base64 token (the part after `Lab `).")
-    p.add_argument("--base", required=True, help="Base URL, e.g. https://leap-lab.test.bohrium.com")
-    p.add_argument("--lab-uuid", required=True, help="Lab UUID.")
-    p.add_argument("--tags", nargs="*", default=[], help="Tags to filter by (space separated).")
-    p.add_argument(
-        "--mode",
-        choices=["any", "all"],
-        default="any",
-        help="any: workflow contains at least one tag; all: workflow contains every tag.",
-    )
-    p.add_argument("--published-only", action="store_true", help="Only include published workflows.")
-    p.add_argument("--page-size", type=int, default=1000, help="Page size, default 1000.")
-    p.add_argument(
-        "--summary-only",
-        action="store_true",
-        help="Print tag summary without applying filter (still fetches everything).",
-    )
-    p.add_argument("--output", help="Write JSON result to this path. If omitted, print to stdout.")
-    return p.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-    workflows = fetch_all_workflows(
-        base=args.base,
-        auth_token=args.auth,
-        lab_uuid=args.lab_uuid,
-        page_size=args.page_size,
-    )
-    sorted_tags, tag_counts, untagged = aggregate_tags(workflows)
-
-    if args.summary_only:
-        result = {
-            "total_workflows": len(workflows),
-            "untagged_count": untagged,
-            "tag_counts": tag_counts,
-            "all_tags": sorted_tags,
-        }
-    else:
-        filtered = filter_workflows(
-            workflows,
-            want_tags=args.tags,
-            mode=args.mode,
-            published_only=args.published_only,
-        )
-        result = {
-            "total_workflows": len(workflows),
-            "untagged_count": untagged,
-            "tag_counts": tag_counts,
-            "all_tags": sorted_tags,
-            "filter": {
-                "tags": args.tags,
-                "mode": args.mode,
-                "published_only": args.published_only,
-            },
-            "matched_count": len(filtered),
-            "filtered_workflows": [project_workflow(wf) for wf in filtered],
-        }
-
-    payload = json.dumps(result, ensure_ascii=False, indent=2)
-    if args.output:
-        with open(args.output, "w", encoding="utf-8") as f:
-            f.write(payload)
-        print(f"Wrote {len(workflows)} workflows summary → {args.output}", file=sys.stderr)
-    else:
-        print(payload)
-
-
-if __name__ == "__main__":
-    main()

.cursor/skills/virtual-workbench/SKILL.md

@@ -10,8 +10,7 @@ description: Operate Virtual Workbench via REST API — prepare materials, move
 - **device_id**: `virtual_workbench`
 - **Python 源码**: `unilabos/devices/virtual/workbench.py`
 - **设备类**: `VirtualWorkbench`
-- **当前纳入动作**: 5 个（`auto-prepare_materials`, `auto-move_to_heating_station`, `auto-start_heating`, `auto-move_to_output`, `transfer`）
+- **动作数**: 6（`auto-prepare_materials`, `auto-move_to_heating_station`, `auto-start_heating`, `auto-move_to_output`, `transfer`, `manual_confirm`）
-- **暂跳过动作**: `manual_confirm`、扣电测试 `test`（需要启用时先从最新注册表重新提取 schema）
 - **设备描述**: 模拟工作台，包含 1 个机械臂（每次操作 2s，独占锁）和 3 个加热台（每次加热 60s，可并行）
 
 ### 典型工作流程
@@ -152,8 +151,7 @@ curl -s -X POST "$BASE/api/v1/lab/mcp/run/action" \
 | `auto-start_heating` | `UniLabJsonCommand` |
 | `auto-move_to_output` | `UniLabJsonCommand` |
 | `transfer` | `UniLabJsonCommandAsync` |
-
+| `manual_confirm` | `UniLabJsonCommand` |
-> `manual_confirm` 和扣电测试 `test` 当前不纳入本 skill 的推荐操作范围；不要基于历史 JSON 直接调用，需先重新生成并校验 schema。
 
 ### 10. 查询任务状态
 
@@ -227,9 +225,11 @@ curl -s -X PUT "$BASE/api/v1/edge/material/node" \
 | `transfer`        | `resource`       | ResourceSlot | 待转移物料数组       |
 | `transfer`        | `target_device`  | DeviceSlot   | 目标设备路径         |
 | `transfer`        | `mount_resource` | ResourceSlot | 目标孔位数组         |
+| `manual_confirm`  | `resource`       | ResourceSlot | 确认用物料数组       |
+| `manual_confirm`  | `target_device`  | DeviceSlot   | 确认用目标设备       |
+| `manual_confirm`  | `mount_resource` | ResourceSlot | 确认用目标孔位数组   |
 
 > `prepare_materials`、`move_to_heating_station`、`start_heating`、`move_to_output` 这 4 个动作**无 Slot 字段**，参数为纯数值/整数。
-> `manual_confirm` 先跳过，不维护其 Slot 字段表。
 
 ---
 
@@ -270,13 +270,3 @@ prepare_materials (count=5)
 ```
 
 创建节点时，`prepare_materials` 的 5 个 output handle（`channel_1` ~ `channel_5`）分别连接到 5 个 `move_to_heating_station` 节点的 `material_input` handle。每个 `move_to_heating_station` 的 `heating_station_output` 和 `material_number_output` 连接到对应 `start_heating` 的 `station_id_input` 和 `material_number_input`。
-
-`start_heating` 完成后还需要继续连接到 `move_to_output`，否则加热完成的物料不会移出加热台：
-
-| source action | source handle | target action | target handle | 传递参数 |
-| ------------- | ------------- | ------------- | ------------- | -------- |
-| `auto-prepare_materials` | `channel_N` | `auto-move_to_heating_station` | `material_input` | `material_number` |
-| `auto-move_to_heating_station` | `heating_station_output` | `auto-start_heating` | `station_id_input` | `station_id` |
-| `auto-move_to_heating_station` | `material_number_output` | `auto-start_heating` | `material_number_input` | `material_number` |
-| `auto-start_heating` | `heating_done_station` | `auto-move_to_output` | `output_station_input` | `station_id` |
-| `auto-start_heating` | `heating_done_material` | `auto-move_to_output` | `output_material_input` | `material_number` |

.cursor/skills/virtual-workbench/action-index.md

@@ -1,8 +1,6 @@
 # Action Index — virtual_workbench
 
-当前纳入 5 个动作，按功能分类。每个动作的完整 JSON Schema 在 `actions/<name>.json`。
+6 个动作，按功能分类。每个动作的完整 JSON Schema 在 `actions/<name>.json`。
-
-暂跳过：`manual_confirm`、扣电测试 `test`。这两个动作需要启用时，先从最新 `req_device_registry_upload.json` 重新提取 schema 并校验参数。
 
 ---
 
@@ -62,18 +60,17 @@
 
 ---
 
-## 暂跳过动作
+## 人工确认
 
 ### `manual_confirm`
 
-创建人工确认节点，等待用户手动确认后继续（含物料转移上下文）。当前先不纳入推荐操作范围。
+创建人工确认节点，等待用户手动确认后继续（含物料转移上下文）
 
 - **action_type**: `UniLabJsonCommand`
 - **Schema**: [`actions/manual_confirm.json`](actions/manual_confirm.json)
-- **状态**: 暂跳过。源码参数已包含扣电测试相关字段，历史 JSON 可能过期；需要启用时重新提取 schema。
+- **核心参数**: `resource`, `target_device`, `mount_resource`, `timeout_seconds`, `assignee_user_ids`
-
+- **占位符字段**:
-### `test`
+  - `resource` — **ResourceSlot**，物料数组
-
+  - `target_device` — **DeviceSlot**，目标设备路径
-启动扣电测试。当前先不纳入本 skill。
+  - `mount_resource` — **ResourceSlot**，目标孔位数组
-
+  - `assignee_user_ids` — `unilabos_manual_confirm` 类型
-- **状态**: 暂跳过。需要启用时从注册表生成 `actions/test.json` 后再补充索引。

.github/workflows/ci-check.yml

@@ -25,7 +25,7 @@ jobs:
           fetch-depth: 0
 
       - name: Setup Miniforge
-        uses: conda-incubator/setup-miniconda@v4
+        uses: conda-incubator/setup-miniconda@v3
         with:
           miniforge-version: latest
           use-mamba: true
@@ -38,7 +38,7 @@ jobs:
       - name: Install ROS dependencies, uv and unilabos-msgs
         run: |
           echo Installing ROS dependencies...
-          mamba install -n check-env --override-channels -c robostack-staging -c conda-forge -c uni-lab conda-forge::uv conda-forge::opencv robostack-staging::ros-humble-ros-core robostack-staging::ros-humble-action-msgs robostack-staging::ros-humble-std-msgs robostack-staging::ros-humble-geometry-msgs robostack-staging::ros-humble-control-msgs robostack-staging::ros-humble-nav2-msgs uni-lab::ros-humble-unilabos-msgs robostack-staging::ros-humble-cv-bridge robostack-staging::ros-humble-vision-opencv robostack-staging::ros-humble-tf-transformations robostack-staging::ros-humble-moveit-msgs robostack-staging::ros-humble-tf2-ros robostack-staging::ros-humble-tf2-ros-py conda-forge::transforms3d -y
+          mamba install -n check-env conda-forge::uv conda-forge::opencv robostack-staging::ros-humble-ros-core robostack-staging::ros-humble-action-msgs robostack-staging::ros-humble-std-msgs robostack-staging::ros-humble-geometry-msgs robostack-staging::ros-humble-control-msgs robostack-staging::ros-humble-nav2-msgs uni-lab::ros-humble-unilabos-msgs robostack-staging::ros-humble-cv-bridge robostack-staging::ros-humble-vision-opencv robostack-staging::ros-humble-tf-transformations robostack-staging::ros-humble-moveit-msgs robostack-staging::ros-humble-tf2-ros robostack-staging::ros-humble-tf2-ros-py conda-forge::transforms3d -c robostack-staging -c conda-forge -c uni-lab -y
 
       - name: Install pip dependencies and unilabos
         run: |

.github/workflows/conda-pack-build.yml

@@ -1,10 +1,6 @@
 name: Build Conda-Pack Environment
 
 on:
-  # 在 UniLabOS Conda Build 成功上传后自动构建非全量 conda-pack
-  workflow_run:
-    workflows: ["UniLabOS Conda Build"]
-    types: [completed]
   workflow_dispatch:
     inputs:
       branch:
@@ -25,16 +21,6 @@ on:
 
 jobs:
   build-conda-pack:
-    if: |
-      github.event_name == 'workflow_dispatch' ||
-      (
-        github.event_name == 'workflow_run' &&
-        github.event.workflow_run.conclusion == 'success' &&
-        github.event.workflow_run.event == 'workflow_run'
-      )
-    env:
-      BUILD_FULL: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.build_full == 'true' }}
-      PACKAGE_REF: ${{ github.event.inputs.branch || github.event.workflow_run.head_sha || github.ref_name }}
     strategy:
       fail-fast: false
       matrix:
@@ -43,7 +29,7 @@ jobs:
             platform: linux-64
             env_file: unilabos-linux-64.yaml
             script_ext: sh
-          - os: macos-15-intel # Intel x86_64
+          - os: macos-15 # Intel (via Rosetta)
             platform: osx-64
             env_file: unilabos-osx-64.yaml
             script_ext: sh
@@ -68,9 +54,7 @@ jobs:
         id: should_build
         shell: bash
         run: |
-          if [[ "${{ github.event_name }}" != "workflow_dispatch" ]]; then
+          if [[ -z "${{ github.event.inputs.platforms }}" ]]; then
-            echo "should_build=true" >> $GITHUB_OUTPUT
-          elif [[ -z "${{ github.event.inputs.platforms }}" ]]; then
             echo "should_build=true" >> $GITHUB_OUTPUT
           elif [[ "${{ github.event.inputs.platforms }}" == *"${{ matrix.platform }}"* ]]; then
             echo "should_build=true" >> $GITHUB_OUTPUT
@@ -81,17 +65,17 @@ jobs:
       - uses: actions/checkout@v6
         if: steps.should_build.outputs.should_build == 'true'
         with:
-          ref: ${{ github.event.inputs.branch || github.event.workflow_run.head_sha || github.ref }}
+          ref: ${{ github.event.inputs.branch }}
           fetch-depth: 0
 
       - name: Setup Miniforge (with mamba)
         if: steps.should_build.outputs.should_build == 'true'
-        uses: conda-incubator/setup-miniconda@v4
+        uses: conda-incubator/setup-miniconda@v3
         with:
           miniforge-version: latest
           use-mamba: true
           python-version: '3.11.14'
-          channels: conda-forge,robostack-staging,uni-lab
+          channels: conda-forge,robostack-staging,uni-lab,defaults
           channel-priority: flexible
           activate-environment: unilab
           auto-update-conda: false
@@ -102,13 +86,13 @@ jobs:
         run: |
           echo Installing unilabos and dependencies to unilab environment...
           echo Using mamba for faster and more reliable dependency resolution...
-          echo Build full: ${{ env.BUILD_FULL }}
+          echo Build full: ${{ github.event.inputs.build_full }}
-          if "${{ env.BUILD_FULL }}"=="true" (
+          if "${{ github.event.inputs.build_full }}"=="true" (
             echo Installing unilabos-full ^(complete package^)...
-            mamba install -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge uni-lab::unilabos-full conda-pack zstandard -y
+            mamba install -n unilab uni-lab::unilabos-full conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
           ) else (
             echo Installing unilabos ^(minimal package^)...
-            mamba install -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge uni-lab::unilabos conda-pack zstandard -y
+            mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
           )
 
       - name: Install conda-pack, unilabos and dependencies (Unix)
@@ -117,13 +101,13 @@ jobs:
         run: |
           echo "Installing unilabos and dependencies to unilab environment..."
           echo "Using mamba for faster and more reliable dependency resolution..."
-          echo "Build full: ${{ env.BUILD_FULL }}"
+          echo "Build full: ${{ github.event.inputs.build_full }}"
-          if [[ "${{ env.BUILD_FULL }}" == "true" ]]; then
+          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
             echo "Installing unilabos-full (complete package)..."
-            mamba install -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge uni-lab::unilabos-full conda-pack zstandard -y
+            mamba install -n unilab uni-lab::unilabos-full conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
           else
             echo "Installing unilabos (minimal package)..."
-            mamba install -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge uni-lab::unilabos conda-pack zstandard -y
+            mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
           fi
 
       - name: Get latest ros-humble-unilabos-msgs version (Windows)
@@ -150,27 +134,27 @@ jobs:
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
         run: |
           echo Checking for available ros-humble-unilabos-msgs versions...
-          mamba search --override-channels -c uni-lab -c robostack-staging -c conda-forge ros-humble-unilabos-msgs || echo Search completed
+          mamba search ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge || echo Search completed
           echo.
           echo Updating ros-humble-unilabos-msgs to latest version...
-          mamba update -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge ros-humble-unilabos-msgs -y || echo Already at latest version
+          mamba update -n unilab ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge -y || echo Already at latest version
 
       - name: Check for newer ros-humble-unilabos-msgs (Unix)
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
         shell: bash
         run: |
           echo "Checking for available ros-humble-unilabos-msgs versions..."
-          mamba search --override-channels -c uni-lab -c robostack-staging -c conda-forge ros-humble-unilabos-msgs || echo "Search completed"
+          mamba search ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge || echo "Search completed"
           echo ""
           echo "Updating ros-humble-unilabos-msgs to latest version..."
-          mamba update -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge ros-humble-unilabos-msgs -y || echo "Already at latest version"
+          mamba update -n unilab ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge -y || echo "Already at latest version"
 
       - name: Install latest unilabos from source (Windows)
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
         run: |
           echo Uninstalling existing unilabos...
           mamba run -n unilab pip uninstall unilabos -y || echo unilabos not installed via pip
-          echo Installing unilabos from source (ref: ${{ env.PACKAGE_REF }})...
+          echo Installing unilabos from source (branch: ${{ github.event.inputs.branch }})...
           mamba run -n unilab pip install .
           echo Verifying installation...
           mamba run -n unilab pip show unilabos
@@ -181,7 +165,7 @@ jobs:
         run: |
           echo "Uninstalling existing unilabos..."
           mamba run -n unilab pip uninstall unilabos -y || echo "unilabos not installed via pip"
-          echo "Installing unilabos from source (ref: ${{ env.PACKAGE_REF }})..."
+          echo "Installing unilabos from source (branch: ${{ github.event.inputs.branch }})..."
           mamba run -n unilab pip install .
           echo "Verifying installation..."
           mamba run -n unilab pip show unilabos
@@ -242,9 +226,7 @@ jobs:
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
         run: |
           echo Packing unilab environment with conda-pack...
-          for /f "delims=" %%i in ('mamba run -n unilab python -c "import os; print(os.environ['CONDA_PREFIX'])"') do set "UNILAB_PREFIX=%%i"
+          mamba activate unilab && conda pack -n unilab -o unilab-env-${{ matrix.platform }}.tar.gz --ignore-missing-files
-          echo Packing environment at: %UNILAB_PREFIX%
-          mamba run -n unilab conda-pack -p "%UNILAB_PREFIX%" -o unilab-env-${{ matrix.platform }}.tar.gz --ignore-missing-files
           echo Pack file created:
           dir unilab-env-${{ matrix.platform }}.tar.gz
 
@@ -253,9 +235,8 @@ jobs:
         shell: bash
         run: |
           echo "Packing unilab environment with conda-pack..."
-          UNILAB_PREFIX="$(mamba run -n unilab python -c 'import os; print(os.environ["CONDA_PREFIX"])')"
+          mamba install conda-pack -c conda-forge -y
-          echo "Packing environment at: $UNILAB_PREFIX"
+          conda pack -n unilab -o unilab-env-${{ matrix.platform }}.tar.gz --ignore-missing-files
-          mamba run -n unilab conda-pack -p "$UNILAB_PREFIX" -o unilab-env-${{ matrix.platform }}.tar.gz --ignore-missing-files
           echo "Pack file created:"
           ls -lh unilab-env-${{ matrix.platform }}.tar.gz
 
@@ -286,7 +267,7 @@ jobs:
 
           rem Create README using Python script
           echo Creating: README.txt
-          python scripts\create_readme.py ${{ matrix.platform }} ${{ env.PACKAGE_REF }} dist-package\README.txt
+          python scripts\create_readme.py ${{ matrix.platform }} ${{ github.event.inputs.branch }} dist-package\README.txt
 
           echo.
           echo Distribution package contents:
@@ -322,7 +303,7 @@ jobs:
 
           # Create README using Python script
           echo "Creating: README.txt"
-          python scripts/create_readme.py ${{ matrix.platform }} ${{ env.PACKAGE_REF }} dist-package/README.txt
+          python scripts/create_readme.py ${{ matrix.platform }} ${{ github.event.inputs.branch }} dist-package/README.txt
 
           echo ""
           echo "Distribution package contents:"
@@ -333,7 +314,7 @@ jobs:
         if: steps.should_build.outputs.should_build == 'true'
         uses: actions/upload-artifact@v6
         with:
-          name: unilab-pack-${{ matrix.platform }}-${{ env.PACKAGE_REF }}
+          name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}
           path: dist-package/
           retention-days: 90
           if-no-files-found: error
@@ -345,9 +326,9 @@ jobs:
           echo Build Summary
           echo ==========================================
           echo Platform: ${{ matrix.platform }}
-          echo Branch: ${{ env.PACKAGE_REF }}
+          echo Branch: ${{ github.event.inputs.branch }}
           echo Python version: 3.11.14
-          if "${{ env.BUILD_FULL }}"=="true" (
+          if "${{ github.event.inputs.build_full }}"=="true" (
             echo Package: unilabos-full ^(complete^)
           ) else (
             echo Package: unilabos ^(minimal^)
@@ -356,7 +337,7 @@ jobs:
           echo Distribution package contents:
           dir dist-package
           echo.
-          echo Artifact name: unilab-pack-${{ matrix.platform }}-${{ env.PACKAGE_REF }}
+          echo Artifact name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}
           echo.
           echo After download, extract the ZIP and run:
           echo   install_unilab.bat
@@ -370,9 +351,9 @@ jobs:
           echo "Build Summary"
           echo "=========================================="
           echo "Platform: ${{ matrix.platform }}"
-          echo "Branch: ${{ env.PACKAGE_REF }}"
+          echo "Branch: ${{ github.event.inputs.branch }}"
           echo "Python version: 3.11.14"
-          if [[ "${{ env.BUILD_FULL }}" == "true" ]]; then
+          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
             echo "Package: unilabos-full (complete)"
           else
             echo "Package: unilabos (minimal)"
@@ -381,7 +362,7 @@ jobs:
           echo "Distribution package contents:"
           ls -lh dist-package/
           echo ""
-          echo "Artifact name: unilab-pack-${{ matrix.platform }}-${{ env.PACKAGE_REF }}"
+          echo "Artifact name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}"
           echo ""
           echo "After download:"
           echo "  install_unilab.sh"

.github/workflows/deploy-docs.yml

@@ -51,12 +51,12 @@ jobs:
           fetch-depth: 0
 
       - name: Setup Miniforge (with mamba)
-        uses: conda-incubator/setup-miniconda@v4
+        uses: conda-incubator/setup-miniconda@v3
         with:
           miniforge-version: latest
           use-mamba: true
           python-version: '3.11.14'
-          channels: conda-forge,robostack-staging,uni-lab
+          channels: conda-forge,robostack-staging,uni-lab,defaults
           channel-priority: flexible
           activate-environment: unilab
           auto-update-conda: false
@@ -66,7 +66,7 @@ jobs:
         run: |
           echo "Installing unilabos and dependencies to unilab environment..."
           echo "Using mamba for faster and more reliable dependency resolution..."
-          mamba install -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge uni-lab::unilabos -y
+          mamba install -n unilab uni-lab::unilabos -c uni-lab -c robostack-staging -c conda-forge -y
 
       - name: Install latest unilabos from source
         run: |
@@ -84,7 +84,7 @@ jobs:
 
       - name: Setup Pages
         id: pages
-        uses: actions/configure-pages@v6
+        uses: actions/configure-pages@v5
         if: |
           github.event.workflow_run.head_branch == 'main' ||
           (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
@@ -105,7 +105,7 @@ jobs:
           test -f docs/_build/html/index.html && echo "✓ index.html exists" || echo "✗ index.html missing"
 
       - name: Upload build artifacts
-        uses: actions/upload-pages-artifact@v5
+        uses: actions/upload-pages-artifact@v4
         if: |
           github.event.workflow_run.head_branch == 'main' ||
           (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
@@ -125,4 +125,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v5
+        uses: actions/deploy-pages@v4

.github/workflows/multi-platform-build.yml

@@ -10,9 +10,6 @@ on:
   # 支持 tag 推送（不依赖 CI Check）
   push:
     tags: ['v*']
-  # GitHub Release 发布时自动构建并上传
-  release:
-    types: [published]
   # 手动触发
   workflow_dispatch:
     inputs:
@@ -63,7 +60,7 @@ jobs:
           - os: ubuntu-latest
             platform: linux-64
             env_file: unilabos-linux-64.yaml
-          - os: macos-15-intel # Intel x86_64
+          - os: macos-15 # Intel (via Rosetta)
             platform: osx-64
             env_file: unilabos-osx-64.yaml
           - os: macos-latest # ARM64
@@ -83,7 +80,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           # 如果是 workflow_run 触发，使用触发 CI Check 的 commit
-          ref: ${{ github.event.workflow_run.head_sha || github.event.release.tag_name || github.ref }}
+          ref: ${{ github.event.workflow_run.head_sha || github.ref }}
           fetch-depth: 0
 
       - name: Check if platform should be built
@@ -99,14 +96,12 @@ jobs:
             echo "should_build=false" >> $GITHUB_OUTPUT
           fi
 
-      - name: Setup Miniforge
+      - name: Setup Miniconda
         if: steps.should_build.outputs.should_build == 'true'
-        uses: conda-incubator/setup-miniconda@v4
+        uses: conda-incubator/setup-miniconda@v3
         with:
-          miniforge-version: latest
+          miniconda-version: 'latest'
-          use-mamba: true
+          channels: conda-forge,robostack-staging,defaults
-          python-version: '3.11.14'
-          channels: conda-forge,robostack-staging
           channel-priority: strict
           activate-environment: build-env
           auto-update-conda: false
@@ -115,22 +110,24 @@ jobs:
       - name: Install rattler-build and anaconda-client
         if: steps.should_build.outputs.should_build == 'true'
         run: |
-          mamba install -n build-env --override-channels -c conda-forge rattler-build anaconda-client -y
+          conda install -c conda-forge rattler-build anaconda-client
 
       - name: Show environment info
         if: steps.should_build.outputs.should_build == 'true'
         run: |
           conda info
-          conda list -n build-env | grep -E "(rattler-build|anaconda-client)"
+          conda list | grep -E "(rattler-build|anaconda-client)"
-          conda run -n build-env rattler-build --version
-          conda run -n build-env anaconda --version
           echo "Platform: ${{ matrix.platform }}"
           echo "OS: ${{ matrix.os }}"
 
       - name: Build conda package
         if: steps.should_build.outputs.should_build == 'true'
         run: |
-          conda run -n build-env rattler-build build -r ./recipes/msgs/recipe.yaml --target-platform ${{ matrix.platform }} -c robostack -c robostack-staging -c conda-forge
+          if [[ "${{ matrix.platform }}" == "osx-arm64" ]]; then
+            rattler-build build -r ./recipes/msgs/recipe.yaml -c robostack -c robostack-staging -c conda-forge
+          else
+            rattler-build build -r ./recipes/msgs/recipe.yaml -c robostack -c robostack-staging -c conda-forge
+          fi
 
       - name: List built packages
         if: steps.should_build.outputs.should_build == 'true'
@@ -160,15 +157,9 @@ jobs:
           retention-days: 30
 
       - name: Upload to Anaconda.org (unilab organization)
-        if: |
+        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
-          steps.should_build.outputs.should_build == 'true' &&
-          (
-            github.event_name == 'release' ||
-            startsWith(github.ref, 'refs/tags/') ||
-            github.event.inputs.upload_to_anaconda == 'true'
-          )
         run: |
           for package in $(find ./output -name "*.conda"); do
             echo "Uploading $package to unilab organization..."
-            conda run -n build-env anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
+            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
           done

.github/workflows/unilabos-conda-build.yml

@@ -1,10 +1,14 @@
 name: UniLabOS Conda Build
 
 on:
-  # 在 Multi-Platform Conda Build 成功上传 msgs 后自动触发
+  # 在 CI Check 成功后自动触发
   workflow_run:
-    workflows: ["Multi-Platform Conda Build"]
+    workflows: ["CI Check"]
     types: [completed]
+    branches: [main, dev]
+  # 标签推送时直接触发（发布版本）
+  push:
+    tags: ['v*']
   # 手动触发
   workflow_dispatch:
     inputs:
@@ -29,37 +33,37 @@ on:
         type: boolean
 
 jobs:
-  # 等待上游 msgs 构建完成的 job (仅用于 workflow_run 触发)
+  # 等待 CI Check 完成的 job (仅用于 workflow_run 触发)
-  wait-for-upstream:
+  wait-for-ci:
     runs-on: ubuntu-latest
     if: github.event_name == 'workflow_run'
     outputs:
       should_continue: ${{ steps.check.outputs.should_continue }}
     steps:
-      - name: Check upstream workflow status
+      - name: Check CI status
         id: check
         run: |
-          if [[ "${{ github.event.workflow_run.conclusion }}" == "success" && ( "${{ github.event.workflow_run.event }}" == "release" || "${{ github.event.workflow_run.event }}" == "push" ) ]]; then
+          if [[ "${{ github.event.workflow_run.conclusion }}" == "success" ]]; then
             echo "should_continue=true" >> $GITHUB_OUTPUT
-            echo "Multi-Platform Conda Build passed for release/tag, proceeding with UniLabOS build"
+            echo "CI Check passed, proceeding with build"
           else
             echo "should_continue=false" >> $GITHUB_OUTPUT
-            echo "Upstream workflow is not a successful release/tag build (status: ${{ github.event.workflow_run.conclusion }}, event: ${{ github.event.workflow_run.event }}), skipping build"
+            echo "CI Check did not succeed (status: ${{ github.event.workflow_run.conclusion }}), skipping build"
           fi
 
   build:
-    needs: [wait-for-upstream]
+    needs: [wait-for-ci]
-    # 运行条件：workflow_run 触发且上游成功，或者手动触发
+    # 运行条件：workflow_run 触发且 CI 成功，或者其他触发方式
     if: |
       always() &&
-      (needs.wait-for-upstream.result == 'skipped' || needs.wait-for-upstream.outputs.should_continue == 'true')
+      (needs.wait-for-ci.result == 'skipped' || needs.wait-for-ci.outputs.should_continue == 'true')
     strategy:
       fail-fast: false
       matrix:
         include:
           - os: ubuntu-latest
             platform: linux-64
-          - os: macos-15-intel # Intel x86_64
+          - os: macos-15 # Intel (via Rosetta)
             platform: osx-64
           - os: macos-latest # ARM64
             platform: osx-arm64
@@ -75,7 +79,7 @@ jobs:
     steps:
       - uses: actions/checkout@v6
         with:
-          # 如果是 workflow_run 触发，使用上游 conda 包构建的 commit
+          # 如果是 workflow_run 触发，使用触发 CI Check 的 commit
           ref: ${{ github.event.workflow_run.head_sha || github.ref }}
           fetch-depth: 0
 
@@ -92,14 +96,12 @@ jobs:
             echo "should_build=false" >> $GITHUB_OUTPUT
           fi
 
-      - name: Setup Miniforge
+      - name: Setup Miniconda
         if: steps.should_build.outputs.should_build == 'true'
-        uses: conda-incubator/setup-miniconda@v4
+        uses: conda-incubator/setup-miniconda@v3
         with:
-          miniforge-version: latest
+          miniconda-version: 'latest'
-          use-mamba: true
+          channels: conda-forge,robostack-staging,uni-lab,defaults
-          python-version: '3.11.14'
-          channels: conda-forge,robostack-staging,uni-lab
           channel-priority: strict
           activate-environment: build-env
           auto-update-conda: false
@@ -108,22 +110,20 @@ jobs:
       - name: Install rattler-build and anaconda-client
         if: steps.should_build.outputs.should_build == 'true'
         run: |
-          mamba install -n build-env --override-channels -c conda-forge rattler-build anaconda-client -y
+          conda install -c conda-forge rattler-build anaconda-client
 
       - name: Show environment info
         if: steps.should_build.outputs.should_build == 'true'
         run: |
           conda info
-          conda list -n build-env | grep -E "(rattler-build|anaconda-client)"
+          conda list | grep -E "(rattler-build|anaconda-client)"
-          conda run -n build-env rattler-build --version
-          conda run -n build-env anaconda --version
           echo "Platform: ${{ matrix.platform }}"
           echo "OS: ${{ matrix.os }}"
-          echo "Build full package: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.build_full == 'true' }}"
+          echo "Build full package: ${{ github.event.inputs.build_full || 'false' }}"
           echo "Building packages:"
           echo "  - unilabos-env (environment dependencies)"
           echo "  - unilabos (with pip package)"
-          if [[ "${{ github.event_name == 'workflow_dispatch' && github.event.inputs.build_full == 'true' }}" == "true" ]]; then
+          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
             echo "  - unilabos-full (complete package)"
           fi
 
@@ -131,19 +131,14 @@ jobs:
         if: steps.should_build.outputs.should_build == 'true'
         run: |
           echo "Building unilabos-env (conda environment dependencies)..."
-          conda run -n build-env rattler-build build -r .conda/environment/recipe.yaml --target-platform ${{ matrix.platform }} -c uni-lab -c robostack-staging -c conda-forge
+          rattler-build build -r .conda/environment/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge
 
       - name: Upload unilabos-env to Anaconda.org (if enabled)
-        if: |
+        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
-          steps.should_build.outputs.should_build == 'true' &&
-          (
-            github.event_name == 'workflow_run' ||
-            github.event.inputs.upload_to_anaconda == 'true'
-          )
         run: |
           echo "Uploading unilabos-env to uni-lab organization..."
           for package in $(find ./output -name "unilabos-env*.conda"); do
-            conda run -n build-env anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
+            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
           done
 
       - name: Build unilabos (with pip package)
@@ -151,40 +146,33 @@ jobs:
         run: |
           echo "Building unilabos package..."
           # 如果已上传到 Anaconda，从 uni-lab channel 获取 unilabos-env；否则从本地 output 获取
-          conda run -n build-env rattler-build build -r .conda/base/recipe.yaml --target-platform ${{ matrix.platform }} -c uni-lab -c robostack-staging -c conda-forge --channel ./output
+          rattler-build build -r .conda/base/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge --channel ./output
 
       - name: Upload unilabos to Anaconda.org (if enabled)
-        if: |
+        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
-          steps.should_build.outputs.should_build == 'true' &&
-          (
-            github.event_name == 'workflow_run' ||
-            github.event.inputs.upload_to_anaconda == 'true'
-          )
         run: |
           echo "Uploading unilabos to uni-lab organization..."
           for package in $(find ./output -name "unilabos-0*.conda" -o -name "unilabos-[0-9]*.conda"); do
-            conda run -n build-env anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
+            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
           done
 
       - name: Build unilabos-full - Only when explicitly requested
         if: |
           steps.should_build.outputs.should_build == 'true' && 
-          github.event_name == 'workflow_dispatch' &&
           github.event.inputs.build_full == 'true'
         run: |
           echo "Building unilabos-full package on ${{ matrix.platform }}..."
-          conda run -n build-env rattler-build build -r .conda/full/recipe.yaml --target-platform ${{ matrix.platform }} -c uni-lab -c robostack-staging -c conda-forge --channel ./output
+          rattler-build build -r .conda/full/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge --channel ./output
 
       - name: Upload unilabos-full to Anaconda.org (if enabled)
         if: |
           steps.should_build.outputs.should_build == 'true' && 
-          github.event_name == 'workflow_dispatch' &&
           github.event.inputs.build_full == 'true' &&
           github.event.inputs.upload_to_anaconda == 'true'
         run: |
           echo "Uploading unilabos-full to uni-lab organization..."
           for package in $(find ./output -name "unilabos-full*.conda"); do
-            conda run -n build-env anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
+            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
           done
 
       - name: List built packages

docs/developer_guide/add_PLC.md

@@ -1,611 +0,0 @@
-# PLC 通信标准与设备驱动编写指南（基于 AI4M 工站）
-
-> 本文档以 `unilabos/devices/workstation/AI4M`（水凝胶检测工站）为参考实现，
-> 介绍如何将 PLC 控制的实验设备接入 Uni-Lab-OS：包含通信协议选型、节点表标准、
-> 通信基类、设备驱动、Registry 配置以及调试方法。
->
-> 阅读对象：负责现场调试与设备接入的同学。
-
----
-
-## 0. 总览：一台 PLC 设备从硬件到云端的链路
-
-```
-       PLC（西门子 / 倍福 / 三菱 / 汇川 / 国产 PLC ...）
-                   ▲
-                   │  各家 PLC 私有协议（S7 / Modbus / EtherCAT ...）
-                   │
-        ┌──────────┴──────────┐
-        │  OPC UA Server      │  ← 统一在 PLC 侧或独立网关上配置
-        │  （内置或 KEPServer）│
-        └──────────┬──────────┘
-                   │  OPC UA over TCP（标准协议）
-                   │
-        ┌──────────┴──────────┐
-        │  Uni-Lab 设备驱动    │  ← 本教程主体
-        │  AI4MDevice         │
-        │  ├─ base_opcua_client.py  通信基类
-        │  ├─ opcua_nodes_*.csv     节点表（标准）
-        │  └─ AI4M.py               动作函数
-        └──────────┬──────────┘
-                   │  ROS2 Action / 云端 HTTP
-                   ▼
-              实验记录本 / 云端调度
-```
-
-**统一约定**：所有 PLC 设备**只暴露 OPC UA 接口**给 Uni-Lab，PC 端不直接处理 S7 / Modbus 等底层协议。
-这是 Uni-Lab 在工站类设备上的 PLC 通信标准。
-
----
-
-## 1. 为什么选 OPC UA 作为标准？
-
-| 维度 | 自研 TCP/串口协议 | Modbus | **OPC UA** |
-|---|---|---|---|
-| 厂家无关 | ✗ | 部分 | **✓** |
-| 自带类型系统 | ✗ | ✗（裸寄存器） | **✓（Boolean/Int16/Float...）** |
-| 命名空间 / 节点树 | ✗ | ✗（地址=魔数） | **✓（带名字、可分组）** |
-| 订阅推送 | ✗ | ✗ | **✓（DataChange Notification）** |
-| 鉴权 / 加密 | 自己造 | ✗ | **✓** |
-| 与 PLC 工程师沟通成本 | 高 | 中 | **低（按变量名沟通）** |
-
-实际接入时，PLC 工程师只需要在 PLC 侧把约定的"上位通讯变量"暴露到 OPC UA Server，
-我们在 PC 侧就能用 `节点名 + 数据类型` 直接读写，不用管底层是 S7 还是 Modbus。
-
----
-
-## 2. 节点表标准：`opcua_nodes_xxx.csv`
-
-PLC 侧暴露的所有变量统一**用一张 CSV 表**描述，这是 PC 端和 PLC 端**唯一的接口契约**。
-位置示例：`unilabos/devices/workstation/AI4M/opcua_nodes_AI4M.csv`。
-
-### 2.1 列定义
-
-| 列名 | 是否必填 | 说明 |
-|---|---|---|
-| `Name` | ✅ | 节点名（PLC 工程师在 PLC 项目中真实使用的变量名，通常是中文/原始名） |
-| `EnglishName` | 推荐 | 英文别名，**PC 端代码全部用这个名字**调用 |
-| `NodeType` | ✅ | `VARIABLE`（变量）或 `METHOD`（方法），AI4M 全部用变量 |
-| `DataType` | ✅ | `BOOLEAN` / `INT16` / `INT32` / `FLOAT` / `DOUBLE` / `STRING` ... |
-| `NodeLanguage` | 推荐 | `Chinese` / `English`，配合 `EnglishName` 做映射 |
-| `NodeId` | ✅ | OPC UA 标准 NodeId，格式 `ns=<namespace>;s=<string>` 或 `ns=<n>;i=<int>` |
-
-### 2.2 真实样例（节选自 `opcua_nodes_AI4M.csv`）
-
-| Name | EnglishName | NodeType | DataType | NodeLanguage | NodeId |
-|---|---|---|---|---|---|
-| 机器人空闲 | `robot_ready` | VARIABLE | BOOLEAN | Chinese | `ns=4;s=上位通讯变量\|机器人空闲` |
-| 机器人取烧杯编号 | `robot_pick_beaker_id` | VARIABLE | INT16 | Chinese | `ns=4;s=上位通讯变量\|机器人取烧杯编号` |
-| 检测1请求参数 | `station_1_request_params` | VARIABLE | BOOLEAN | Chinese | `ns=4;s=上位通讯变量\|检测1请求参数` |
-| 检测1工艺完成 | `station_1_process_complete` | VARIABLE | BOOLEAN | Chinese | `ns=4;s=上位通讯变量\|检测1工艺完成` |
-| 磁力搅拌参数设置_C[0].搅拌速度 | `mag_stirrer_c0_stir_speed` | VARIABLE | INT16 | Chinese | `ns=4;s=上位通讯变量\|磁力搅拌参数设置_C[0].搅拌速度` |
-| 报警复位 | `alarm_reset` | VARIABLE | BOOLEAN | Chinese | `ns=4;s=上位通讯变量\|报警复位` |
-
-### 2.3 设计规范（必读）
-
-1. **命名按"角色-编号-属性"分层**，便于代码批量寻址：
-   - `mag_stirrer_c{0..4}_stir_speed`（搅拌仪 0~4 的搅拌速度）
-   - `station_{1..3}_process_complete`（检测站 1~3 的完成信号）
-   - `robot_rack_pick_beaker_{1..5}_complete`（取烧杯 1~5 的完成信号）
-
-   这样在驱动里可以直接 `f"mag_stirrer_c{idx}_stir_speed"` 拼出节点名。
-
-2. **数据类型与 PLC 侧严格一致**：
-   - `BOOL` → `BOOLEAN`，`INT/WORD` → `INT16/UINT16`，`DINT` → `INT32`，`REAL` → `FLOAT`。
-   - 类型不一致会触发 `BadTypeMismatch`，写入失败。
-
-3. **NodeId 必须从 PLC 工程或 OPC UA Server 中导出**，不要自己拼。
-   常见格式：
-   - 西门子 1500：`ns=4;s=上位通讯变量|<变量名>`
-   - 倍福 TwinCAT：`ns=4;s=PLC1.MAIN.<变量名>`
-   - KEPServerEX：`ns=2;s=Channel1.Device1.<Tag>`
-
-4. **每个工站一个独立 CSV**，不要共用。
-   AI4M 中真机用 `opcua_nodes_AI4M.csv`，仿真用 `opcua_nodes_AI4M_sim.csv`。
-
----
-
-## 3. 通信基类架构
-
-文件：`unilabos/devices/workstation/AI4M/base_opcua_client.py`
-
-整个通信层分两层：
-
-```
-BaseOpcUaClient                       # 最小可用：连接 + 节点注册 + 读写 + 方法调用
-        ▲
-        │ 继承
-        │
-OpcUaClientWithSubscription           # 生产可用：+ 订阅推送 + 缓存 + 自动重连
-        ▲
-        │ 继承
-        │
-AI4MDevice                            # 业务驱动：在它之上写设备动作函数
-```
-
-### 3.1 `BaseOpcUaClient` 核心能力
-
-```python
-class BaseOpcUaClient(UniversalDriver):
-    client: Optional[Client] = None
-    _node_registry: Dict[str, OpcUaNodeBase] = {}     # name -> Variable/Method
-    _name_mapping: Dict[str, str] = {}                # 英文名 -> 中文名
-    _reverse_mapping: Dict[str, str] = {}             # 中文名 -> 英文名
-    _found_node_objects: Dict[str, Any] = {}          # 缓存 ua.Node 用于订阅
-
-    @classmethod
-    def load_csv(cls, file_path) -> Tuple[List[OpcUaNode], dict, dict]: ...
-    def register_node_list(self, node_list) -> "BaseOpcUaClient": ...
-    def use_node(self, name) -> OpcUaNodeBase: ...
-    def read_node(self, node_name: str) -> str: ...   # 返回 JSON
-    def write_node(self, json_input: str) -> str: ...
-    def call_method(self, node_name, *args) -> Tuple[Any, bool]: ...
-```
-
-它做的事情可以归纳为四步：
-
-1. **`load_csv`**：读取节点表，建立 `Name ↔ EnglishName` 双向映射。
-2. **`register_node_list`**：把节点登记进 `_variables_to_find` 待查找列表。
-3. **`_connect` → `_find_nodes`**：连上 OPC UA 后，按 `NodeId` 把每个节点解析成 `Variable` / `Method` 对象，放进 `_node_registry`。
-4. **`use_node(name)`**：业务代码取节点的唯一入口，**支持中英文混用**，找不到会自动重试一次。
-
-### 3.2 `OpcUaClientWithSubscription` 增强能力
-
-在 `BaseOpcUaClient` 基础上提供三个生产环境必备的能力：
-
-#### a) 订阅缓存（高频读零开销）
-
-```python
-def _setup_subscriptions(self):
-    self._subscription = self.client.create_subscription(
-        self._subscription_interval,    # 默认 500ms
-        SubscriptionHandler(self),
-    )
-    for node_name, node in self._node_registry.items():
-        if node.type == NodeType.VARIABLE and node.node_id:
-            handle = self._subscription.subscribe_data_change(ua_node)
-            self._subscription_handles[node_name] = handle
-```
-
-当 PLC 侧变量变化时，`datachange_notification` 回调会把新值写进 `self._node_values[name]`，
-后续 `get_node_value` 优先读缓存——**业务代码可以放心地写 `while not self.get_node_value(...): time.sleep(1)` 而不用担心 OPC UA 频繁请求**。
-
-#### b) 智能缓存的 `get_node_value`
-
-```python
-def get_node_value(self, name, use_cache=True, force_read=False):
-    # 1. 中英文名归一化
-    chinese_name = self._name_mapping.get(name, name)
-
-    # 2. force_read=True 强制透传到 OPC UA Server
-    if force_read: ...
-
-    # 3. 命中订阅推送 → 直接返回缓存
-    # 4. 命中按需读 + 未过期（cache_timeout=5s）→ 返回缓存
-    # 5. 否则发起 read 并更新缓存
-```
-
-#### c) 连接监控 + 自动重连
-
-后台线程每 30s 调一次 `client.get_namespace_array()` 探活，断线则自动 `disconnect → connect → 重新订阅`，最多重试 5 次。
-
-### 3.3 数据类型 / 节点类型
-
-`unilabos/device_comms/opcua_client/node/uniopcua.py`：
-
-```python
-class DataType(Enum):
-    BOOLEAN = VariantType.Boolean
-    INT16   = VariantType.Int16
-    INT32   = VariantType.Int32
-    FLOAT   = VariantType.Float
-    STRING  = VariantType.String
-    # ...
-
-class NodeType(Enum):
-    VARIABLE = NodeClass.Variable
-    METHOD   = NodeClass.Method
-    OBJECT   = NodeClass.Object
-```
-
-`Variable.write()` 内部会按 `DataType` 做强制类型转换，
-所以 CSV 里的 `DataType` 列就是"PC 端转换写入值的类型说明书"。
-
----
-
-## 4. 编写设备驱动：以 `AI4MDevice` 为例
-
-文件：`unilabos/devices/workstation/AI4M/AI4M.py`
-
-### 4.1 继承通信基类，最小骨架
-
-```python
-from typing import Optional
-from unilabos.devices.workstation.AI4M.base_opcua_client import OpcUaClientWithSubscription
-
-class AI4MDevice(OpcUaClientWithSubscription):
-    def __init__(
-        self,
-        url: str,                              # opc.tcp://192.168.1.10:4840
-        deck: Optional[AI4M_deck] = None,      # 物料台面（资源树）
-        csv_path: str = None,                  # 节点表 CSV
-        username: str = None,
-        password: str = None,
-        use_subscription: bool = True,
-        cache_timeout: float = 5.0,
-        subscription_interval: int = 500,
-        *args, **kwargs,
-    ):
-        super().__init__(
-            url=url, username=username, password=password,
-            use_subscription=use_subscription,
-            cache_timeout=cache_timeout,
-            subscription_interval=subscription_interval,
-            *args, **kwargs,
-        )
-
-        # 物料台面初始化（见教程 4. 物料系统）
-        self.deck = deck or AI4M_deck(setup=True)
-        self._robot_lock = threading.Lock()
-
-        # 关键：加载节点表
-        if csv_path:
-            self.load_nodes_from_csv(csv_path)
-```
-
-`load_nodes_from_csv` 会一次性完成：解析 CSV → 注册节点 → 解析 NodeId → 建立订阅，
-**之后整个驱动都通过 `self.get_node_value(name)` / `self.set_node_value(name, value)` 操作 PLC**。
-
-### 4.2 PLC 通信的核心模式：握手协议（Handshake）
-
-PLC 编程的本质是"扫描周期 + 状态机"，PC 端**绝对不能用 fire-and-forget 的方式发指令**。
-和 PLC 配合的标准模式是 **"PC 写指令 → PC 等待 PLC 回执 → PC 复位指令"**。
-
-AI4M 中所有 `trigger_*` 函数都遵循以下三种握手范式之一：
-
-#### 范式 A：脉冲触发 + 完成信号（最常用）
-
-```python
-def trigger_init(self) -> dict:
-    # ① 复位上一轮残留
-    self.set_node_value("alarm_reset", True); time.sleep(1.0)
-    self.set_node_value("alarm_reset", False)
-    self.set_node_value("manual_auto_switch", False)
-
-    # ② 等待 PLC 退出自动模式
-    while self.get_node_value("auto_mode"):
-        time.sleep(1.0)
-
-    # ③ 发起初始化脉冲（True → False）
-    self.set_node_value("initialize", True); time.sleep(1.0)
-    self.set_node_value("initialize", False)
-
-    # ④ 等待 PLC 给出完成信号
-    while not self.get_node_value("init finished"):
-        time.sleep(1.0)
-
-    return {"message": "设备初始化完成"}
-```
-
-要点：
-- **"PC 写一个 BOOL 拉高再拉低"** 模拟脉冲，PLC 用上升沿触发动作。
-- **`get_node_value` 要在 while 循环里轮询**，配合订阅缓存基本无压力。
-- **每个动作必须有"开始"和"完成"两个独立的 BOOL 节点**，不能复用。
-
-#### 范式 B：参数下发 + 请求/已执行/完成 三步握手（带数据的工艺）
-
-```python
-def trigger_station_process(self, station_id: int, mag_stir_speed: int, ...):
-    request_node        = f"station_{station_id}_request_params"
-    params_received_node = f"station_{station_id}_params_received"
-    start_node          = f"station_{station_id}_start"
-    complete_node       = f"station_{station_id}_process_complete"
-
-    # ① PC 复位三个状态位（避免上一轮影响）
-    self._reset_station_process_flags(station_id)
-
-    # ② 等 PLC 主动请求参数（PLC 准备好了才接收）
-    while not self.get_node_value(request_node):
-        time.sleep(1.0)
-
-    # ③ PC 下发参数（注意：PLC 内部数组是 0-based，PC 暴露给用户是 1-based）
-    station_idx = station_id - 1
-    self.set_node_value(f"mag_stirrer_c{station_idx}_stir_speed", mag_stir_speed)
-    self.set_node_value(f"mag_stirrer_c{station_idx}_heat_temp",  mag_stir_heat_temp)
-    self.set_node_value(f"mag_stirrer_c{station_idx}_time_set",   mag_stir_time_set)
-    self.set_node_value(f"syringe_pump_{station_idx}_abs_position_set", syringe_pump_abs_pos)
-
-    # ④ PC 通知 PLC "参数已就绪"，等 PLC 回复"已执行"
-    self.set_node_value(start_node, True)
-    while not self.get_node_value(params_received_node):
-        time.sleep(1.0)
-
-    # ⑤ 等 PLC 完成整个工艺
-    while not self.get_node_value(complete_node):
-        time.sleep(5.0)
-
-    self.set_node_value(start_node, False)   # 复位，方便下一轮
-    return {"station_id": station_id, "message": "..."}
-```
-
-四个状态位的语义：
-
-| 信号 | 方向 | 含义 |
-|---|---|---|
-| `station_X_request_params` | **PLC → PC** | "我准备好了，把参数给我" |
-| `station_X_start` | **PC → PLC** | "参数我已经写好了，开干" |
-| `station_X_params_received` | **PLC → PC** | "参数我已经吃下了" |
-| `station_X_process_complete` | **PLC → PC** | "工艺已经做完" |
-
-**这是 PLC 通信教科书级别的标准范式**，所有带数据下发的动作都建议照抄。
-
-#### 范式 C：编号下发 + 编号对应的完成信号（多目标互锁）
-
-```python
-def trigger_robot_pick_beaker(self, pick_beaker_id: int, place_station_id: int = None, ...):
-    # ① 等机器人空闲（互锁）
-    while not self.get_node_value("robot_ready"):
-        time.sleep(1.0)
-
-    # ② 阶段一：下发"取哪一杯"编号 + 等"取这一杯完成"
-    pick_complete_node  = f"robot_rack_pick_beaker_{pick_beaker_id}_complete"
-    self.set_node_value("robot_pick_beaker_id", pick_beaker_id)
-    while not self.get_node_value(pick_complete_node):
-        time.sleep(1.0)
-
-    # ③ 阶段二：下发"放到哪个工站"编号 + 等"放完成"
-    place_complete_node = f"robot_place_station_{place_station_id}_complete"
-    self._reset_station_process_flags(place_station_id)
-    self.set_node_value("robot_place_station_id", place_station_id)
-    while not self.get_node_value(place_complete_node):
-        time.sleep(1.0)
-```
-
-要点：
-- **同一个动作的多个目标用"编号变量 + 编号对应的完成信号"实现**，不要每个目标都开一个开始位。
-- **配合 Python 端 `threading.Lock()` 做软互锁**，避免多个线程争抢机器人。
-- **每个阶段有独立的完成信号**，串行等待，不能合并。
-
-### 4.3 一些容易踩坑的细节
-
-1. **节点名映射**
-   `set_node_value("alarm_reset", True)` 实际写入的是 CSV 中文名 `报警复位`，
-   `get_node_value` 同理。**业务代码全部用 EnglishName**，不要直接用中文。
-
-2. **PLC 数组索引和 PC 不一致**
-   AI4M 里 PC 暴露 `station_id ∈ {1, 2, 3}`，但 PLC 内部数组是 `C[0..2]`，
-   驱动里要做 `station_idx = station_id - 1`，**这种映射只在驱动层做一次**，
-   不要让上层（registry / 实验记录本）感知。
-
-3. **订阅模式下 BOOL 节点的边沿同步**
-   订阅有 ~500ms 延迟。如果你刚 `set_node_value(x, True)` 就立刻 `get_node_value(x)`，
-   读到的可能还是 `False`（订阅还没推回来）。
-   解决方案：**写完后用 `force_read=True` 透传一次** 或加一段 `time.sleep`。
-
-4. **永远不要忘记复位**
-   `start` 拉 True 后必须有地方拉回 False，否则下一轮 PLC 上升沿不触发。
-   AI4M 在 `_reset_station_process_flags` 中统一做：
-
-   ```python
-   def _reset_station_process_flags(self, station_id: int) -> None:
-       self.set_node_value(f"station_{station_id}_process_complete", False)
-       self.set_node_value(f"station_{station_id}_start", False)
-       self.set_node_value(f"station_{station_id}_params_received", False)
-   ```
-
-5. **耗时长的等待 sleep 加大**
-   工艺等待用 `time.sleep(5.0)`，机器人等待用 `time.sleep(1.0)`，初始化等待 `time.sleep(1.0)`，
-   不要全部用 0.1s 轮询，会把日志刷爆。
-
----
-
-## 5. 把驱动接到 Uni-Lab：Registry + Graph
-
-### 5.1 Registry YAML（动作 schema）
-
-文件：`unilabos/registry/devices/AI4M_station.yaml`
-
-```yaml
-AI4M_station:
-  category: [AI4M_station]
-  class:
-    module: unilabos.devices.workstation.AI4M.AI4M:AI4MDevice    # ← 入口类
-    type: python
-    action_value_mappings:
-      auto-trigger_init:
-        schema:
-          description: 设备初始化...
-          properties:
-            goal:    { properties: {}, required: [], type: object }
-            result:
-              properties: { message: { type: string } }
-              required: [message]
-              type: object
-          type: object
-        type: UniLabJsonCommand
-
-      auto-trigger_station_process:
-        always_free: true
-        schema:
-          description: 执行检测工艺流程
-          properties:
-            goal:
-              properties:
-                station_id:                   { type: integer, description: 检测编号 1-3 }
-                mag_stir_stir_speed:          { type: integer }
-                mag_stir_heat_temp:           { type: integer }
-                mag_stir_time_set:            { type: integer }
-                syringe_pump_abs_position_set:{ type: integer }
-              required: [station_id, mag_stir_stir_speed, mag_stir_heat_temp,
-                         mag_stir_time_set, syringe_pump_abs_position_set]
-              type: object
-            result: { ... }
-        type: UniLabJsonCommand
-
-  init_param_schema:
-    config:
-      type: object
-      required: [url]
-      properties:
-        url:                   { type: string,  description: OPC UA 服务器地址 }
-        csv_path:              { type: string,  description: 节点配置 CSV 路径 }
-        deck:                  { type: string,  description: 资源树配置 }
-        username:              { type: string }
-        password:              { type: string }
-        use_subscription:      { type: boolean, default: true }
-        cache_timeout:         { type: number,  default: 5.0 }
-        subscription_interval: { type: integer, default: 500 }
-```
-
-规则总结：
-- `class.module` 指向驱动类（`module:ClassName`）。
-- `action_value_mappings` 中的 key 形如 `auto-<方法名>`，对应驱动里的同名 Python 方法。
-- `schema.goal` 自动转成 ROS2 Action 的 goal 消息，`schema.result` 转 result。
-- `init_param_schema.config` 对应 `__init__` 的入参，**所有需要现场改的参数都要列出来**（最重要的就是 `url` 和 `csv_path`）。
-- `always_free: true` 表示该动作不占用工站独占锁（多检测站可并发执行）。
-
-### 5.2 Graph JSON（实例化）
-
-文件：`unilabos/devices/workstation/AI4M/AI4M.json`
-
-```json
-{
-  "nodes": [
-    {
-      "id": "AI4M_station",
-      "name": "AI4M_station",
-      "type": "device",
-      "class": "AI4M_station",
-      "children": ["AI4M_deck"],
-      "parent": null,
-      "config": {
-        "url": "opc.tcp://192.168.1.10:4840",
-        "csv_path": "opcua_nodes_AI4M.csv",
-        "deck": {
-          "data": {
-            "_resource_child_name": "AI4M_deck",
-            "_resource_type": "unilabos.devices.workstation.AI4M.decks:AI4M_deck"
-          }
-        }
-      }
-    },
-    {
-      "id": "AI4M_deck",
-      "type": "deck",
-      "class": "AI4M_deck",
-      "parent": "AI4M_station",
-      "config": { "type": "AI4M_deck" }
-    }
-  ]
-}
-```
-
-要点：
-- `class` 必须和 Registry YAML 的顶层 key 完全一致（`AI4M_station`）。
-- `config` 字段**逐字传给驱动 `__init__`**，所以 Graph JSON = "现场参数表"。
-- 多套相同设备时拷贝一份，把 `id` / `url` 改掉即可（参考 `AI4M002_station`）。
-
-### 5.3 启动命令（来自 `start.md`）
-
-```cmd
-# 真机
-python unilabos/app/main.py -g unilabos/devices/workstation/AI4M/AI4M.json `
-  --ak <ak> --sk <sk> --upload_registry --addr <api_url> --disable_browser
-
-# 仿真（KEPServerEX 跑在本机 49320 端口）
-python unilabos/app/main.py -g unilabos/devices/workstation/AI4M/AI4Msim.json `
-  --ak <ak> --sk <sk> --upload_registry --disable_browser
-```
-
-`--upload_registry` 会把 `AI4M_station.yaml` 的 schema 上传到云端，
-之后实验记录本就能看到所有 `auto-*` 动作。
-
----
-
-## 6. 调试方法
-
-### 6.1 用 KEPServerEX 仿真 PLC
-
-不带 PLC 的开发机上，可以用 KEPServerEX（或 `python-opcua` 自建 server）模拟。
-AI4M 提供了一份仿真节点表 `opcua_nodes_AI4M_sim.csv`，**只改 NodeId 不改语义**，
-所以驱动代码无需任何改动即可在本机调试。
-
-### 6.2 单独跑驱动（不开 ROS）
-
-在驱动文件末尾的 `if __name__ == '__main__':` 段：
-
-```python
-if __name__ == '__main__':
-    A4 = AI4MDevice(
-        url="opc.tcp://192.168.1.10:4840",
-        csv_path="opcua_nodes_AI4M.csv",
-    )
-    A4.trigger_init()
-    print("初始化完成")
-    A4.trigger_robot_pick_beaker(1, 1)
-```
-
-**新动作上线前一定要在这里裸跑一遍**，确认握手时序正确，再往上接 ROS。
-
-### 6.3 看日志判断卡在哪
-
-`base_opcua_client.py` 的日志已经覆盖了所有关键节点：
-
-```
-✓ 客户端已连接!
-✓ 找到变量节点: 'robot_ready', NodeId: ns=4;s=...
-✓ 已订阅节点: robot_ready
-✓ 节点查找完成：所有 142 个节点均已找到
-```
-
-如果看到 `⚠ 以下 N 个节点未找到`，**99% 是 CSV 里的 NodeId 写错了**，回去对一下 PLC 工程导出的 NodeId。
-
-### 6.4 检查节点是否能直接读写
-
-```python
-# 透传读，绕过订阅缓存
-A4.get_node_value("robot_ready", force_read=True)
-
-# 直接读 JSON 形式（适合从 HTTP/调试面板调）
-A4.read_node("robot_ready")
-
-# 写
-A4.set_node_value("alarm_reset", True)
-A4.write_node('{"node_name": "alarm_reset", "value": false}')
-```
-
----
-
-## 7. 接入新 PLC 设备的 Checklist
-
-接到一台新工站时，按下面顺序做就能保证不漏：
-
-- [ ] 1. 让 PLC 工程师把上位通讯变量整理到 OPC UA Server，导出 NodeId 清单。
-- [ ] 2. 在 `unilabos/devices/workstation/<设备名>/` 下新建目录，复制 `AI4M/base_opcua_client.py` 不动。
-- [ ] 3. 整理 `opcua_nodes_<设备名>.csv`，6 列填齐，并补上 `EnglishName`。
-- [ ] 4. 在该目录写设备驱动 `<设备名>.py`，继承 `OpcUaClientWithSubscription`：
-  - [ ] `__init__` 调用 `super().__init__` + `self.load_nodes_from_csv(csv_path)`。
-  - [ ] 每个动作函数用范式 A/B/C 写握手协议。
-  - [ ] 每个动作函数都返回 `dict`，至少含 `message` 字段。
-- [ ] 5. 在 `unilabos/registry/devices/` 下新建 `<设备名>_station.yaml`，配置 `init_param_schema` 和 `action_value_mappings`。
-- [ ] 6. 在该目录新建 `<设备名>.json`（Graph），填好 `url` 和 `csv_path`。
-- [ ] 7. 用 `if __name__ == '__main__':` 单独跑驱动确认握手 OK。
-- [ ] 8. 用 `python unilabos/app/main.py -g <Graph> --upload_registry ...` 上线，到实验记录本下发动作回归。
-
----
-
-## 8. 参考实现速查
-
-| 关注点 | 在 AI4M 中看哪里 |
-|---|---|
-| OPC UA 通信基类 | `base_opcua_client.py` |
-| 节点定义类型系统 | `unilabos/device_comms/opcua_client/node/uniopcua.py` |
-| 节点表 CSV 标准 | `opcua_nodes_AI4M.csv` |
-| 设备驱动入口类 | `AI4M.py: AI4MDevice` |
-| 握手范式 A（脉冲+完成） | `AI4M.py: trigger_init` |
-| 握手范式 B（请求/参数/完成） | `AI4M.py: trigger_station_process` |
-| 握手范式 C（编号+完成） | `AI4M.py: trigger_robot_pick_beaker` |
-| 自动模式批量参数下发 | `AI4M.py: download_auto_params` |
-| Registry schema | `unilabos/registry/devices/AI4M_station.yaml` |
-| Graph 实例化 | `AI4M.json` / `AI4Msim.json` |
-| 启动命令 | `start.md` |

recipes/conda_build_config.yaml

@@ -1,5 +1,5 @@
 channel_sources:
-  - robostack,robostack-staging,conda-forge
+  - robostack,robostack-staging,conda-forge,defaults
   
 gazebo:
   - '11'

recipes/msgs/recipe.yaml

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

recipes/unilabos/recipe.yaml

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

scripts/workflow.py

@@ -2,6 +2,7 @@ import json
 import logging
 import traceback
 import uuid
+import xml.etree.ElementTree as ET
 from typing import Any, Dict, List
 
 import networkx as nx
@@ -24,15 +25,7 @@ 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):
@@ -49,7 +42,6 @@ class SimpleGraph:
             "multigraph": False,
             "graph": {},
             "nodes": nodes_list,
-            "edges": self.edges,
             "links": self.edges,
         }
 
@@ -66,8 +58,495 @@ 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.11.3',
+    version='0.11.0',
     packages=find_packages(),
     include_package_data=True,
     install_requires=['setuptools'],

unilabos/__init__.py

@@ -1 +1 @@
-__version__ = "0.11.3"
+__version__ = "0.11.0"

unilabos/app/main.py

@@ -12,15 +12,6 @@ from typing import Dict, Any, List
 import networkx as nx
 import yaml
 
-# Windows 中文系统 stdout 默认 GBK，无法编码 banner / emoji 日志中的 Unicode 字符
-# 强制 stdout/stderr 用 UTF-8，避免 print 触发 UnicodeEncodeError 导致进程崩溃
-if sys.platform == "win32":
-    for _stream in (sys.stdout, sys.stderr):
-        try:
-            _stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
-        except (AttributeError, OSError):
-            pass
-
 # 首先添加项目根目录到路径
 current_dir = os.path.dirname(os.path.abspath(__file__))
 unilabos_dir = os.path.dirname(os.path.dirname(current_dir))

unilabos/app/model.py

@@ -59,7 +59,6 @@ class JobAddReq(BaseModel):
     task_id: str = Field(examples=["task_id"], description="task uuid (auto-generated if empty)", default="")
     job_id: str = Field(examples=["job_id"], description="goal uuid (auto-generated if empty)", default="")
     node_id: str = Field(examples=["node_id"], description="node uuid", default="")
-    notebook_id: str = Field(examples=["notebook_id"], description="notebook uuid", default="")
     server_info: dict = Field(
         examples=[{"send_timestamp": 1717000000.0}],
         description="server info (auto-generated if empty)",

unilabos/app/utils.py

@@ -10,170 +10,29 @@ import shutil
 import sys
 
 
-_PATCH_MARKER = "# UniLabOS DLL Patch"
-_PATCH_END_MARKER = "# End UniLabOS DLL Patch"
-
-# 75 = EX_TEMPFAIL: 临时失败、重试即可，避免与业务退出码冲突
-_RESTART_EXIT_CODE = 75
-
-
-def _build_dll_patch(lib_bin: str, preload_pyd: str = "") -> str:
-    """生成一段加在目标文件顶部的 DLL 加载补丁源码。
-
-    - 始终把 ``lib_bin`` 加入 DLL 搜索路径，并把 handle 挂在模块属性上，
-      防止 GC 清掉搜索路径（``os.add_dll_directory`` 的句柄被回收时
-      目录会被移除）。
-    - 可选地用 ``ctypes.CDLL`` 预加载一个 .pyd，把它的依赖 DLL 提前装入
-      进程内存，作为 ``rclpy._rclpy_pybind11`` 这类首次加载点的兜底。
-    """
-    # 用 repr() 序列化路径：Python 解析 repr 的结果会还原成原始字符串，
-    # 不需要也不能再叠加 raw-string 前缀（叠了反而会让 \\ 变成两个反斜杠）。
-    lines = [
-        _PATCH_MARKER,
-        "import os as _ulab_os",
-        f"_ulab_p = {lib_bin!r}",
-        'if hasattr(_ulab_os, "add_dll_directory") and _ulab_os.path.isdir(_ulab_p):',
-        "    try: _UNILAB_DLL_HANDLE = _ulab_os.add_dll_directory(_ulab_p)",
-        "    except Exception: _UNILAB_DLL_HANDLE = None",
-    ]
-    if preload_pyd:
-        lines.extend(
-            [
-                "import ctypes as _ulab_ctypes",
-                f"try: _ulab_ctypes.CDLL({preload_pyd!r})",
-                "except Exception: pass",
-            ]
-        )
-    lines.append(_PATCH_END_MARKER)
-    return "\n".join(lines) + "\n"
-
-
-def _apply_dll_patch(file_path: str, lib_bin: str, preload_pyd: str = "") -> bool:
-    """把 DLL 补丁前置到 ``file_path``。文件不存在或已打过补丁则返回 False。"""
-    if not os.path.isfile(file_path):
-        return False
-    with open(file_path, "r", encoding="utf-8") as f:
-        content = f.read()
-    if _PATCH_MARKER in content:
-        return False
-    shutil.copy2(file_path, file_path + ".bak")
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write(_build_dll_patch(lib_bin, preload_pyd) + content)
-    return True
-
-
-def _print_restart_banner(patched_files):
-    """打印重启提示并以 EX_TEMPFAIL 退出。
-
-    - 不使用 ANSI 颜色码：Windows 旧版 cmd / PowerShell 5 默认不开 VT 处理，
-      会把 ``\\033[1;33m`` 当做字面字符显示，反而让用户看不到正文。
-    - 同时写入 stderr 与 stdout：某些上层 launcher / supervisor 只重定向
-      其中一路，写两遍能保证用户至少看到一份。
-    - 写入前防御性把流切到 UTF-8 with replace：``main.py`` 里已经做过一次，
-      但本模块也可能被绕过 ``main.py`` 的代码路径直接 import；reconfigure
-      失败也只是退回 errors=replace，不影响整体流程。
-    """
-    if sys.platform == "win32":
-        for _stream in (sys.stdout, sys.stderr):
-            try:
-                _stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
-            except (AttributeError, OSError):
-                pass
-
-    bar = "#" * 78
-    files_lines = [f"[UniLabOS]   - {p}" for p in patched_files]
-    body = "\n".join(
-        [
-            "",
-            bar,
-            bar,
-            "##",
-            "##  [UniLabOS] Windows + conda 下检测到 DLL 加载失败，已自动打补丁。",
-            "##  [UniLabOS] DLL load failure detected on Windows + conda;",
-            "##  [UniLabOS] the following files have been auto-patched:",
-            "##",
-            *[f"##  {line}" for line in files_lines],
-            "##",
-            "##  [UniLabOS] 当前进程的 rclpy 状态已损坏，补丁需要在新进程才生效。",
-            "##  [UniLabOS] The current process is unusable; the patch only takes",
-            "##  [UniLabOS] effect on a fresh process.",
-            "##",
-            "##  >>> 请重新运行刚才的命令 / Please re-run the same command. <<<",
-            "##",
-            bar,
-            bar,
-            "",
-        ]
-    )
-
-    for stream in (sys.stderr, sys.stdout):
-        try:
-            stream.write(body)
-            stream.flush()
-        except Exception:
-            try:
-                print(body, file=stream)
-            except Exception:
-                pass
-
-    sys.exit(_RESTART_EXIT_CODE)
-
-
 def patch_rclpy_dll_windows():
-    """在 Windows + conda 环境下修复 rclpy / rosidl typesupport 的 DLL 加载。
+    """在 Windows + conda 环境下为 rclpy 打 DLL 加载补丁"""
-
-    背景：conda 安装的 ros 系列包，其原生扩展依赖 ``$CONDA_PREFIX/Library/bin``
-    下的 DLL；只有 conda 环境被正确激活、且 PATH 中含 ``Library/bin`` 时，
-    ``os.add_dll_directory`` 才能找到它们。当从快捷方式 / IDE / 子进程 /
-    没激活的 shell 启动 ``unilab`` 时，会出现 ``DLL load failed``。
-
-    本函数会:
-        1) 修补 ``rclpy/impl/implementation_singleton.py`` —— rclpy 自身的 C 扩展入口；
-        2) 修补 ``rpyutils/add_dll_directories.py`` —— 所有 ``*_s__rosidl_typesupport_c.pyd``
-           （``geometry_msgs`` / ``std_msgs`` / ``sensor_msgs`` 等）的统一加载入口。
-
-    打完补丁后**必须重启进程**才能生效（当前进程的 rclpy 已经发生过
-    ``ImportError``，子模块仍处于损坏状态）。因此函数会主动退出，并在
-    stdout/stderr 同时打印明显的重启提示，避免用户被后续报错淹没。
-    """
     if sys.platform != "win32" or not os.environ.get("CONDA_PREFIX"):
         return
-
     try:
-        import rclpy  # noqa: F401
+        import rclpy
 
         return
     except ImportError as e:
         if not str(e).startswith("DLL load failed"):
             return
-
     cp = os.environ["CONDA_PREFIX"]
-    lib_bin = os.path.join(cp, "Library", "bin")
+    impl = os.path.join(cp, "Lib", "site-packages", "rclpy", "impl", "implementation_singleton.py")
-    site_packages = os.path.join(cp, "Lib", "site-packages")
+    pyd = glob.glob(os.path.join(cp, "Lib", "site-packages", "rclpy", "_rclpy_pybind11*.pyd"))
-    if not os.path.isdir(lib_bin):
+    if not os.path.exists(impl) or not pyd:
         return
-
+    with open(impl, "r", encoding="utf-8") as f:
-    patched = []
+        content = f.read()
-
+    lib_bin = os.path.join(cp, "Library", "bin").replace("\\", "/")
-    # 1) rclpy 自身的入口
+    patch = f'# UniLabOS DLL Patch\nimport os,ctypes\nos.add_dll_directory("{lib_bin}") if hasattr(os,"add_dll_directory") else None\ntry: ctypes.CDLL("{pyd[0].replace(chr(92),"/")}")\nexcept: pass\n# End Patch\n'
-    rclpy_impl = os.path.join(site_packages, "rclpy", "impl", "implementation_singleton.py")
+    shutil.copy2(impl, impl + ".bak")
-    rclpy_pyd_matches = glob.glob(os.path.join(site_packages, "rclpy", "_rclpy_pybind11*.pyd"))
+    with open(impl, "w", encoding="utf-8") as f:
-    rclpy_pyd = rclpy_pyd_matches[0] if rclpy_pyd_matches else ""
+        f.write(patch + content)
-    if rclpy_pyd and _apply_dll_patch(rclpy_impl, lib_bin, preload_pyd=rclpy_pyd):
-        patched.append(rclpy_impl)
-
-    # 2) rpyutils —— 所有 rosidl typesupport pyd 的加载点；放在 rclpy 之后
-    #    例：geometry_msgs/geometry_msgs_s__rosidl_typesupport_c.pyd
-    rpyutils_dll = os.path.join(site_packages, "rpyutils", "add_dll_directories.py")
-    if _apply_dll_patch(rpyutils_dll, lib_bin):
-        patched.append(rpyutils_dll)
-
-    if not patched:
-        # 已经打过补丁但 rclpy 仍然加载失败：原因不是缺 DLL 搜索路径，
-        # 不要再次打补丁污染文件，让上层看到真实的 ImportError。
-        return
-
-    _print_restart_banner(patched)
 
 
 patch_rclpy_dll_windows()

unilabos/app/web/controller.py

@@ -320,7 +320,6 @@ def job_add(req: JobAddReq) -> JobData:
             action_name=action_name,
             task_id=task_id,
             job_id=job_id,
-            notebook_id=req.notebook_id,
             device_action_key=device_action_key,
         )
 

unilabos/app/ws_client.py

@@ -59,7 +59,6 @@ class QueueItem:
     action_name: str
     task_id: str
     job_id: str
-    notebook_id: str
     device_action_key: str
     next_run_time: float = 0  # 下次执行时间戳
     retry_count: int = 0  # 重试次数
@@ -72,7 +71,6 @@ class JobInfo:
     job_id: str
     task_id: str
     device_id: str
-    notebook_id: str
     action_name: str
     device_action_key: str
     status: JobStatus
@@ -541,10 +539,7 @@ class MessageProcessor:
                 self.reconnect_count += 1
                 backoff = WSConfig.reconnect_interval
                 logger.info(
-                    "[MessageProcessor] 即将在 %s 秒后重连 (已尝试 %s/%s)",
+                    f"[MessageProcessor] 即将在 {backoff} 秒后重连 (已尝试 {self.reconnect_count}/{WSConfig.max_reconnect_attempts})"
-                    backoff,
-                    self.reconnect_count,
-                    WSConfig.max_reconnect_attempts,
                 )
                 await asyncio.sleep(backoff)
             else:
@@ -708,7 +703,6 @@ class MessageProcessor:
         action_name = data.get("action_name", "")
         task_id = data.get("task_id", "")
         job_id = data.get("job_id", "")
-        notebook_id = data.get("notebook_id", "")
 
         if not all([device_id, action_name, task_id, job_id]):
             logger.error("[MessageProcessor] Missing required fields in query_action_state")
@@ -724,7 +718,6 @@ class MessageProcessor:
             job_id=job_id,
             task_id=task_id,
             device_id=device_id,
-            notebook_id=notebook_id,
             action_name=action_name,
             device_action_key=device_action_key,
             status=JobStatus.QUEUE,
@@ -739,27 +732,13 @@ class MessageProcessor:
         if can_start_immediately:
             # 可以立即开始
             await self._send_action_state_response(
-                device_id,
+                device_id, action_name, task_id, job_id, "query_action_status", True, 0
-                action_name,
-                task_id,
-                job_id,
-                "query_action_status",
-                True,
-                0,
-                notebook_id=notebook_id,
             )
             logger.trace(f"[MessageProcessor] Job {job_log} can start immediately")
         else:
             # 需要排队
             await self._send_action_state_response(
-                device_id,
+                device_id, action_name, task_id, job_id, "query_action_status", False, 10
-                action_name,
-                task_id,
-                job_id,
-                "query_action_status",
-                False,
-                10,
-                notebook_id=notebook_id,
             )
             logger.trace(f"[MessageProcessor] Job {job_log} queued")
 
@@ -789,7 +768,6 @@ class MessageProcessor:
                         job_id=req.job_id,
                         task_id=req.task_id,
                         device_id=req.device_id,
-                        notebook_id=req.notebook_id,
                         action_name=action_name,
                         device_action_key=device_action_key,
                         status=JobStatus.QUEUE,
@@ -797,16 +775,11 @@ class MessageProcessor:
                         always_free=True,
                     )
                     self.device_manager.add_queue_request(job_info)
-                    existing_job = job_info
                     logger.info(f"[MessageProcessor] Job {job_log} always_free, auto-registered from direct job_start")
                 else:
                     logger.error(f"[MessageProcessor] Job {job_log} not registered (missing query_action_state)")
                     return
 
-            if existing_job and req.notebook_id and not existing_job.notebook_id:
-                existing_job.notebook_id = req.notebook_id
-            notebook_id = req.notebook_id or (existing_job.notebook_id if existing_job else "")
-
             success = self.device_manager.start_job(req.job_id)
             if not success:
                 logger.error(f"[MessageProcessor] Failed to start job {job_log}")
@@ -822,7 +795,6 @@ class MessageProcessor:
                 action_name=req.action,
                 task_id=req.task_id,
                 job_id=req.job_id,
-                notebook_id=notebook_id,
                 device_action_key=device_action_key,
             )
 
@@ -862,7 +834,6 @@ class MessageProcessor:
                             "job_id": req.job_id,
                             "task_id": req.task_id,
                             "device_id": req.device_id,
-                            "notebook_id": queue_item.notebook_id,
                             "action_name": req.action,
                             "status": "failed",
                             "feedback_data": {},
@@ -884,7 +855,6 @@ class MessageProcessor:
                             "query_action_status",
                             True,
                             0,
-                            notebook_id=next_job.notebook_id,
                         )
                         next_job_log = format_job_log(
                             next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name
@@ -1034,16 +1004,11 @@ class MessageProcessor:
 
                     success = host_node.notify_resource_tree_update(dev_id, act, item_list)
 
-                    if success is True:
+                    if success:
                         logger.info(
                             f"[MessageProcessor] Resource tree {act} completed for device {dev_id}, "
                             f"items: {len(item_list)}"
                         )
-                    elif success is None:
-                        logger.info(
-                            f"[MessageProcessor] Resource tree {act} skipped for device {dev_id}: "
-                            "在线增加设备暂不支持"
-                        )
                     else:
                         logger.warning(f"[MessageProcessor] Resource tree {act} failed for device {dev_id}")
 
@@ -1067,11 +1032,6 @@ class MessageProcessor:
 
         for item in device_list:
             target_node_id = item.get("target_node_id", "host_node")
-            if action == "add":
-                logger.info(
-                    f"[DeviceManage] 在线增加设备暂不支持，跳过 add_device: {item.get('id', '')}"
-                )
-                continue
 
             def _notify(target_id: str, act: str, cfg: ResourceDictType):
                 try:
@@ -1141,15 +1101,7 @@ class MessageProcessor:
         logger.info(f"[MessageProcessor] Restart cleanup scheduled")
 
     async def _send_action_state_response(
-        self,
+        self, device_id: str, action_name: str, task_id: str, job_id: str, typ: str, free: bool, need_more: int
-        device_id: str,
-        action_name: str,
-        task_id: str,
-        job_id: str,
-        typ: str,
-        free: bool,
-        need_more: int,
-        notebook_id: str = "",
     ):
         """发送动作状态响应"""
         message = {
@@ -1160,7 +1112,6 @@ class MessageProcessor:
                 "action_name": action_name,
                 "task_id": task_id,
                 "job_id": job_id,
-                "notebook_id": notebook_id,
                 "free": free,
                 "need_more": need_more + 1,
             },
@@ -1243,7 +1194,6 @@ class QueueProcessor:
                             action_name=timeout_job.action_name,
                             task_id=timeout_job.task_id,
                             job_id=timeout_job.job_id,
-                            notebook_id=timeout_job.notebook_id,
                             device_action_key=timeout_job.device_action_key,
                         )
                         # 发布超时失败状态，这会触发正常的job完成流程
@@ -1302,7 +1252,6 @@ class QueueProcessor:
                     "action_name": job_info.action_name,
                     "task_id": job_info.task_id,
                     "job_id": job_info.job_id,
-                    "notebook_id": job_info.notebook_id,
                     "free": False,
                     "need_more": 10 + 1,
                 },
@@ -1342,7 +1291,6 @@ class QueueProcessor:
                     "action_name": job_info.action_name,
                     "task_id": job_info.task_id,
                     "job_id": job_info.job_id,
-                    "notebook_id": job_info.notebook_id,
                     "free": False,
                     "need_more": 10 + 1,
                 },
@@ -1388,15 +1336,12 @@ class QueueProcessor:
                     "action_name": next_job.action_name,
                     "task_id": next_job.task_id,
                     "job_id": next_job.job_id,
-                    "notebook_id": next_job.notebook_id,
                     "free": True,
                     "need_more": 0,
                 },
             }
             self.message_processor.send_message(message)
-            # next_job_log = format_job_log(
+            # next_job_log = format_job_log(next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name)
-            #     next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name
-            # )
             # logger.debug(f"[QueueProcessor] Notified next job {next_job_log} can start")
 
             # 立即触发下一轮状态检查
@@ -1565,7 +1510,6 @@ class WebSocketClient(BaseCommunicationClient):
                 "job_id": item.job_id,
                 "task_id": item.task_id,
                 "device_id": item.device_id,
-                "notebook_id": item.notebook_id,
                 "action_name": item.action_name,
                 "status": status,
                 "feedback_data": feedback_data,

unilabos/devices/virtual/virtual_multiway_valve.py

@@ -2,8 +2,6 @@ import time
 import logging
 from typing import Union, Dict, Optional
 
-from unilabos.registry.decorators import topic_config
-
 
 class VirtualMultiwayValve:
     """
@@ -43,11 +41,13 @@ class VirtualMultiwayValve:
     def target_position(self) -> int:
         return self._target_position
 
-    @property
+    def get_current_position(self) -> int:
-    @topic_config()
+        """获取当前阀门位置 📍"""
-    def current_port(self) -> str:
+        return self._current_position
-        """当前连接的端口名称 🔌"""
+
-        return self.port
+    def get_current_port(self) -> str:
+        """获取当前连接的端口名称 🔌"""
+        return self._current_position
 
     def set_position(self, command: Union[int, str]):
         """
@@ -169,14 +169,12 @@ class VirtualMultiwayValve:
         self._status = "Idle"
         self._valve_state = "Closed"
         
-        close_msg = f"🔒 阀门已关闭，保持在位置 {self._current_position} ({self.port})"
+        close_msg = f"🔒 阀门已关闭，保持在位置 {self._current_position} ({self.get_current_port()})"
         self.logger.info(close_msg)
         return close_msg
 
-    @property
+    def get_valve_position(self) -> int:
-    @topic_config()
+        """获取阀门位置 - 兼容性方法 📍"""
-    def valve_position(self) -> int:
-        """阀门位置 📍"""
         return self._current_position
 
     def set_valve_position(self, command: Union[int, str]):
@@ -231,16 +229,19 @@ class VirtualMultiwayValve:
             self.logger.info(f"🔄 从端口 {self._current_position} 切换到泵位置...")
             return self.set_to_pump_position()
 
-    @property
+    def get_flow_path(self) -> str:
-    @topic_config()
+        """获取当前流路路径描述 🌊"""
-    def flow_path(self) -> str:
+        current_port = self.get_current_port()
-        """当前流路路径描述 🌊"""
         if self._current_position == 0:
-            return f"🚰 转移泵已连接 (位置 {self._current_position})"
+            flow_path = f"🚰 转移泵已连接 (位置 {self._current_position})"
-        return f"🔌 端口 {self._current_position} 已连接 ({self.current_port})"
+        else:
+            flow_path = f"🔌 端口 {self._current_position} 已连接 ({current_port})"
+        
+        # 删除debug日志：self.logger.debug(f"🌊 当前流路: {flow_path}")
+        return flow_path
 
     def __str__(self):
-        current_port = self.current_port
+        current_port = self.get_current_port()
         status_emoji = "✅" if self._status == "Idle" else "🔄" if self._status == "Busy" else "❌"
         
         return f"🔄 VirtualMultiwayValve({status_emoji} 位置: {self._current_position}/{self.max_positions}, 端口: {current_port}, 状态: {self._status})"
@@ -252,7 +253,7 @@ if __name__ == "__main__":
     
     print("🔄 === 虚拟九通阀门测试 === ✨")
     print(f"🏠 初始状态: {valve}")
-    print(f"🌊 当前流路: {valve.flow_path}")
+    print(f"🌊 当前流路: {valve.get_flow_path()}")
     
     # 切换到试剂瓶1（1号位）
     print(f"\n🔌 切换到1号位: {valve.set_position(1)}")

unilabos/devices/virtual/virtual_stirrer.py

@@ -3,7 +3,6 @@ import logging
 import time as time_module
 from typing import Dict, Any
 
-from unilabos.registry.decorators import topic_config
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 
 class VirtualStirrer:
@@ -315,11 +314,9 @@ class VirtualStirrer:
     def min_speed(self) -> float:
         return self._min_speed
     
-    @property
+    def get_device_info(self) -> Dict[str, Any]:
-    @topic_config()
+        """获取设备状态信息 📊"""
-    def device_info(self) -> Dict[str, Any]:
+        info = {
-        """设备状态快照信息 📊"""
-        return {
             "device_id": self.device_id,
             "status": self.status,
             "operation_mode": self.operation_mode,
@@ -328,9 +325,12 @@ class VirtualStirrer:
             "is_stirring": self.is_stirring,
             "remaining_time": self.remaining_time,
             "max_speed": self._max_speed,
-            "min_speed": self._min_speed,
+            "min_speed": self._min_speed
         }
         
+        # self.logger.debug(f"📊 设备信息: 模式={self.operation_mode}, 速度={self.current_speed} RPM, 搅拌={self.is_stirring}")
+        return info
+    
     def __str__(self):
         status_emoji = "✅" if self.operation_mode == "Idle" else "🌪️" if self.operation_mode == "Stirring" else "🛑" if self.operation_mode == "Settling" else "❌"
         return f"🌪️ VirtualStirrer({status_emoji} {self.device_id}: {self.operation_mode}, {self.current_speed} RPM)"

unilabos/devices/virtual/virtual_transferpump.py

@@ -4,7 +4,6 @@ from enum import Enum
 from typing import Union, Optional
 import logging
 
-from unilabos.registry.decorators import topic_config
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 
 
@@ -386,10 +385,8 @@ class VirtualTransferPump:
         """获取当前体积"""
         return self._current_volume
 
-    @property
+    def get_remaining_capacity(self) -> float:
-    @topic_config()
+        """获取剩余容量"""
-    def remaining_capacity(self) -> float:
-        """剩余容量 (ml)"""
         return self.max_volume - self._current_volume
 
     def is_empty(self) -> bool:

unilabos/devices/virtual/workbench.py

@@ -14,30 +14,20 @@ Virtual Workbench Device - 模拟工作台设备
 
 import logging
 import time
+from typing import Dict, Any, Optional, List
 from dataclasses import dataclass
 from enum import Enum
 from threading import Lock, RLock
-from typing import Any, Dict, List, Optional, cast
 
 from typing_extensions import TypedDict
 
 from unilabos.registry.decorators import (
-    ActionInputHandle,
+    device, action, ActionInputHandle, ActionOutputHandle, DataSource, topic_config, not_action, NodeType
-    ActionOutputHandle,
-    DataSource,
-    NodeType,
-    action,
-    device,
-    not_action,
-    topic_config,
 )
 from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, ROS2DeviceNode
-from unilabos.resources.resource_tracker import (
+from unilabos.resources.resource_tracker import SampleUUIDsType, LabSample, ResourceTreeSet
-    SampleUUIDsType,
+
-    LabSample,
-    ResourceTreeSet,
-)
 
 # ============ TypedDict 返回类型定义 ============
 
@@ -122,7 +112,6 @@ class HeatingStation:
 
 @device(
     id="virtual_workbench",
-    display_name="虚拟工作台",
     category=["virtual_device"],
     description="Virtual Workbench with 1 robotic arm and 3 heating stations for concurrent material processing",
 )
@@ -148,19 +137,7 @@ class VirtualWorkbench:
     HEATING_TIME: float = 60.0  # 加热时间(秒)
     NUM_HEATING_STATIONS: int = 3  # 加热台数量
 
-    def __init__(
+    def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
-        self,
-        device_id: Optional[str] = None,
-        config: Optional[Dict[str, Any]] = None,
-        **kwargs,
-    ):
-        """
-        初始化虚拟工作台。
-
-        Args:
-            device_id[设备ID]: 工作台设备实例 ID，默认使用 virtual_workbench。
-            config[设备配置]: 可包含 arm_operation_time、heating_time、num_heating_stations。
-        """
         # 处理可能的不同调用方式
         if device_id is None and "id" in kwargs:
             device_id = kwargs.pop("id")
@@ -174,13 +151,9 @@ class VirtualWorkbench:
         self.data: Dict[str, Any] = {}
 
         # 从config中获取可配置参数
-        self.ARM_OPERATION_TIME = float(
+        self.ARM_OPERATION_TIME = float(self.config.get("arm_operation_time", self.ARM_OPERATION_TIME))
-            self.config.get("arm_operation_time", self.ARM_OPERATION_TIME)
-        )
         self.HEATING_TIME = float(self.config.get("heating_time", self.HEATING_TIME))
-        self.NUM_HEATING_STATIONS = int(
+        self.NUM_HEATING_STATIONS = int(self.config.get("num_heating_stations", self.NUM_HEATING_STATIONS))
-            self.config.get("num_heating_stations", self.NUM_HEATING_STATIONS)
-        )
 
         # 机械臂状态和锁
         self._arm_lock = Lock()
@@ -189,8 +162,7 @@ class VirtualWorkbench:
 
         # 加热台状态
         self._heating_stations: Dict[int, HeatingStation] = {
-            i: HeatingStation(station_id=i)
+            i: HeatingStation(station_id=i) for i in range(1, self.NUM_HEATING_STATIONS + 1)
-            for i in range(1, self.NUM_HEATING_STATIONS + 1)
         }
         self._stations_lock = RLock()
 
@@ -320,113 +292,45 @@ class VirtualWorkbench:
         self.logger.info(f"机械臂已释放 (完成: {task})")
 
     @action(
-        always_free=True,
+        always_free=True, node_type=NodeType.MANUAL_CONFIRM, placeholder_keys={
-        node_type=NodeType.MANUAL_CONFIRM,
+            "assignee_user_ids": "unilabos_manual_confirm"
-        placeholder_keys={"assignee_user_ids": "unilabos_manual_confirm"},
+        }, goal_default={
-        goal_default={"timeout_seconds": 3600, "assignee_user_ids": []},
+            "timeout_seconds": 3600,
-        feedback_interval=300,
+            "assignee_user_ids": []
+        }, feedback_interval=300,
         handles=[
-            ActionInputHandle(
+            ActionInputHandle(key="target_device", data_type="device_id",
-                key="target_device",
+                              label="目标设备", data_key="target_device", data_source=DataSource.HANDLE),
-                data_type="device_id",
+            ActionInputHandle(key="resource", data_type="resource",
-                label="目标设备",
+                              label="待转移资源", data_key="resource", data_source=DataSource.HANDLE),
-                data_key="target_device",
+            ActionInputHandle(key="mount_resource", data_type="resource",
-                data_source=DataSource.HANDLE,
+                              label="目标孔位", data_key="mount_resource", data_source=DataSource.HANDLE),
-            ),
+
-            ActionInputHandle(
+            ActionInputHandle(key="collector_mass", data_type="collector_mass",
-                key="resource",
+                              label="极流体质量", data_key="collector_mass", data_source=DataSource.HANDLE),
-                data_type="resource",
+            ActionInputHandle(key="active_material", data_type="active_material",
-                label="待转移资源",
+                              label="活性物质含量", data_key="active_material", data_source=DataSource.HANDLE),
-                data_key="resource",
+            ActionInputHandle(key="capacity", data_type="capacity",
-                data_source=DataSource.HANDLE,
+                              label="克容量", data_key="capacity", data_source=DataSource.HANDLE),
-            ),
+            ActionInputHandle(key="battery_system", data_type="battery_system",
-            ActionInputHandle(
+                              label="电池体系", data_key="battery_system", data_source=DataSource.HANDLE),
-                key="mount_resource",
-                data_type="resource",
-                label="目标孔位",
-                data_key="mount_resource",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="collector_mass",
-                data_type="collector_mass",
-                label="极流体质量",
-                data_key="collector_mass",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="active_material",
-                data_type="active_material",
-                label="活性物质含量",
-                data_key="active_material",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="capacity",
-                data_type="capacity",
-                label="克容量",
-                data_key="capacity",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="battery_system",
-                data_type="battery_system",
-                label="电池体系",
-                data_key="battery_system",
-                data_source=DataSource.HANDLE,
-            ),
             # transfer使用
-            ActionOutputHandle(
+            ActionOutputHandle(key="target_device", data_type="device_id",
-                key="target_device",
+                               label="目标设备", data_key="target_device", data_source=DataSource.EXECUTOR),
-                data_type="device_id",
+            ActionOutputHandle(key="resource", data_type="resource",
-                label="目标设备",
+                              label="待转移资源", data_key="resource.@flatten", data_source=DataSource.EXECUTOR),
-                data_key="target_device",
+            ActionOutputHandle(key="mount_resource", data_type="resource",
-                data_source=DataSource.EXECUTOR,
+                              label="目标孔位", data_key="mount_resource.@flatten", data_source=DataSource.EXECUTOR),
-            ),
-            ActionOutputHandle(
-                key="resource",
-                data_type="resource",
-                label="待转移资源",
-                data_key="resource.@flatten",
-                data_source=DataSource.EXECUTOR,
-            ),
-            ActionOutputHandle(
-                key="mount_resource",
-                data_type="resource",
-                label="目标孔位",
-                data_key="mount_resource.@flatten",
-                data_source=DataSource.EXECUTOR,
-            ),
             # test使用
-            ActionOutputHandle(
+            ActionOutputHandle(key="collector_mass", data_type="collector_mass",
-                key="collector_mass",
+                              label="极流体质量", data_key="collector_mass", data_source=DataSource.EXECUTOR),
-                data_type="collector_mass",
+            ActionOutputHandle(key="active_material", data_type="active_material",
-                label="极流体质量",
+                              label="活性物质含量", data_key="active_material", data_source=DataSource.EXECUTOR),
-                data_key="collector_mass",
+            ActionOutputHandle(key="capacity", data_type="capacity",
-                data_source=DataSource.EXECUTOR,
+                              label="克容量", data_key="capacity", data_source=DataSource.EXECUTOR),
-            ),
+            ActionOutputHandle(key="battery_system", data_type="battery_system",
-            ActionOutputHandle(
+                              label="电池体系", data_key="battery_system", data_source=DataSource.EXECUTOR),
-                key="active_material",
+        ]
-                data_type="active_material",
-                label="活性物质含量",
-                data_key="active_material",
-                data_source=DataSource.EXECUTOR,
-            ),
-            ActionOutputHandle(
-                key="capacity",
-                data_type="capacity",
-                label="克容量",
-                data_key="capacity",
-                data_source=DataSource.EXECUTOR,
-            ),
-            ActionOutputHandle(
-                key="battery_system",
-                data_type="battery_system",
-                label="电池体系",
-                data_key="battery_system",
-                data_source=DataSource.EXECUTOR,
-            ),
-        ],
     )
     def manual_confirm(
         self,
@@ -439,156 +343,67 @@ class VirtualWorkbench:
         battery_system: List[str],
         timeout_seconds: int,
         assignee_user_ids: list[str],
-        **kwargs,
+        **kwargs
     ) -> dict:
         """
-        人工确认资源转移和扣电测试参数。
+        timeout_seconds: 超时时间（秒），默认3600秒
-
+        collector_mass: 极流体质量
-        Args:
+        active_material: 活性物质含量
-            resource[待转移资源]: 需要人工确认的资源列表。
+        capacity: 克容量（mAh/g）
-            target_device[目标设备]: 资源要转移到的目标设备 ID。
+        battery_system: 电池体系
-            mount_resource[目标孔位]: 资源要挂载到的目标孔位列表。
+        修改的结果无效，是只读的
-            collector_mass[极流体质量]: 每个样品对应的极流体质量。
-            active_material[活性物质含量]: 每个样品对应的活性物质含量。
-            capacity[克容量]: 每个样品对应的克容量，单位 mAh/g。
-            battery_system[电池体系]: 每个样品对应的电池体系名称。
-            timeout_seconds[超时时间]: 人工确认超时时间，单位秒。
-            assignee_user_ids[确认人]: 指定处理人工确认任务的用户 ID 列表。
-
-        Note:
-            修改的结果无效，是只读的。
         """
-        resource_tree = ResourceTreeSet.from_plr_resources(cast(Any, resource)).dump()
+        resource = ResourceTreeSet.from_plr_resources(resource).dump()
-        mount_resource_tree = ResourceTreeSet.from_plr_resources(cast(Any, mount_resource)).dump()
+        mount_resource = ResourceTreeSet.from_plr_resources(mount_resource).dump()
         kwargs.update(locals())
         kwargs.pop("kwargs")
         kwargs.pop("self")
-        kwargs["resource"] = resource_tree
-        kwargs["mount_resource"] = mount_resource_tree
-        kwargs.pop("resource_tree")
-        kwargs.pop("mount_resource_tree")
         return kwargs
 
     @action(
         description="转移物料",
         handles=[
-            ActionInputHandle(
+            ActionInputHandle(key="target_device", data_type="device_id",
-                key="target_device",
+                              label="目标设备", data_key="target_device", data_source=DataSource.HANDLE),
-                data_type="device_id",
+            ActionInputHandle(key="resource", data_type="resource",
-                label="目标设备",
+                               label="待转移资源", data_key="resource", data_source=DataSource.HANDLE),
-                data_key="target_device",
+            ActionInputHandle(key="mount_resource", data_type="resource",
-                data_source=DataSource.HANDLE,
+                               label="目标孔位", data_key="mount_resource", data_source=DataSource.HANDLE),
-            ),
+        ]
-            ActionInputHandle(
-                key="resource",
-                data_type="resource",
-                label="待转移资源",
-                data_key="resource",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="mount_resource",
-                data_type="resource",
-                label="目标孔位",
-                data_key="mount_resource",
-                data_source=DataSource.HANDLE,
-            ),
-        ],
     )
-    async def transfer(
+    async def transfer(self, resource: List[ResourceSlot], target_device: DeviceSlot, mount_resource: List[ResourceSlot]):
-        self,
+        future = ROS2DeviceNode.run_async_func(self._ros_node.transfer_resource_to_another, True,
-        resource: List[ResourceSlot],
-        target_device: DeviceSlot,
-        mount_resource: List[ResourceSlot],
-    ):
-        """
-        转移资源到目标设备。
-
-        Args:
-            resource[待转移资源]: 待转移的资源列表。
-            target_device[目标设备]: 接收资源的目标设备 ID。
-            mount_resource[目标孔位]: 目标设备上的挂载孔位列表。
-        """
-        future = ROS2DeviceNode.run_async_func(
-            self._ros_node.transfer_resource_to_another,
-            True,
             **{
                 "plr_resources": resource,
                 "target_device_id": target_device,
                 "target_resources": mount_resource,
                 "sites": [None] * len(mount_resource),
-            },
+            })
-        )
         result = await future
         return result
 
+
     @action(
         description="扣电测试启动",
         handles=[
-            ActionInputHandle(
+            ActionInputHandle(key="resource", data_type="resource",
-                key="resource",
+                              label="待转移资源", data_key="resource", data_source=DataSource.HANDLE),
-                data_type="resource",
+            ActionInputHandle(key="mount_resource", data_type="resource",
-                label="待转移资源",
+                              label="目标孔位", data_key="mount_resource", data_source=DataSource.HANDLE),
-                data_key="resource",
+
-                data_source=DataSource.HANDLE,
+            ActionInputHandle(key="collector_mass", data_type="collector_mass",
-            ),
+                              label="极流体质量", data_key="collector_mass", data_source=DataSource.HANDLE),
-            ActionInputHandle(
+            ActionInputHandle(key="active_material", data_type="active_material",
-                key="mount_resource",
+                              label="活性物质含量", data_key="active_material", data_source=DataSource.HANDLE),
-                data_type="resource",
+            ActionInputHandle(key="capacity", data_type="capacity",
-                label="目标孔位",
+                              label="克容量", data_key="capacity", data_source=DataSource.HANDLE),
-                data_key="mount_resource",
+            ActionInputHandle(key="battery_system", data_type="battery_system",
-                data_source=DataSource.HANDLE,
+                              label="电池体系", data_key="battery_system", data_source=DataSource.HANDLE),
-            ),
+        ]
-            ActionInputHandle(
-                key="collector_mass",
-                data_type="collector_mass",
-                label="极流体质量",
-                data_key="collector_mass",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="active_material",
-                data_type="active_material",
-                label="活性物质含量",
-                data_key="active_material",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="capacity",
-                data_type="capacity",
-                label="克容量",
-                data_key="capacity",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="battery_system",
-                data_type="battery_system",
-                label="电池体系",
-                data_key="battery_system",
-                data_source=DataSource.HANDLE,
-            ),
-        ],
     )
     async def test(
-        self,
+        self, resource: List[ResourceSlot], mount_resource: List[ResourceSlot],  collector_mass: List[float], active_material: List[float], capacity: List[float], battery_system: list[str]
-        resource: List[ResourceSlot],
-        mount_resource: List[ResourceSlot],
-        collector_mass: List[float],
-        active_material: List[float],
-        capacity: List[float],
-        battery_system: list[str],
     ):
-        """
-        启动扣电测试。
-
-        Args:
-            resource[待测试资源]: 需要进行扣电测试的资源列表。
-            mount_resource[测试孔位]: 扣电测试使用的目标孔位列表。
-            collector_mass[极流体质量]: 每个样品对应的极流体质量。
-            active_material[活性物质含量]: 每个样品对应的活性物质含量。
-            capacity[克容量]: 每个样品对应的克容量，单位 mAh/g。
-            battery_system[电池体系]: 每个样品对应的电池体系名称。
-        """
         print(resource)
         print(mount_resource)
         print(collector_mass)
@@ -600,11 +415,16 @@ class VirtualWorkbench:
         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),  # noqa: E501
+            ActionOutputHandle(key="channel_1", data_type="workbench_material",
-            ActionOutputHandle(key="channel_2", data_type="workbench_material", label="实验2", data_key="material_2", data_source=DataSource.EXECUTOR),  # noqa: E501
+                         label="实验1", data_key="material_1", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="channel_3", data_type="workbench_material", label="实验3", data_key="material_3", data_source=DataSource.EXECUTOR),  # noqa: E501
+            ActionOutputHandle(key="channel_2", data_type="workbench_material",
-            ActionOutputHandle(key="channel_4", data_type="workbench_material", label="实验4", data_key="material_4", data_source=DataSource.EXECUTOR),  # noqa: E501
+                         label="实验2", data_key="material_2", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="channel_5", data_type="workbench_material", label="实验5", data_key="material_5", data_source=DataSource.EXECUTOR),  # noqa: E501
+            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(
@@ -617,9 +437,6 @@ class VirtualWorkbench:
 
         作为工作流的起始节点, 生成指定数量的物料编号供后续节点使用。
         输出5个handle (material_1 ~ material_5), 分别对应实验1~5。
-
-        Args:
-            count[物料数量]: 要生成的物料数量，默认生成 5 个。
         """
         materials = [i for i in range(1, count + 1)]
 
@@ -640,11 +457,7 @@ class VirtualWorkbench:
                 LabSample(
                     sample_uuid=sample_uuid,
                     oss_path="",
-                    extra=(
+                    extra={"material_uuid": content} if isinstance(content, str) else (content.serialize() if content else {}),
-                        {"material_uuid": content}
-                        if isinstance(content, str)
-                        else (content.serialize() if content else {})
-                    ),
                 )
                 for sample_uuid, content in sample_uuids.items()
             ],
@@ -654,27 +467,12 @@ class VirtualWorkbench:
         auto_prefix=True,
         description="将物料从An位置移动到空闲加热台, 返回分配的加热台ID",
         handles=[
-            ActionInputHandle(
+            ActionInputHandle(key="material_input", data_type="workbench_material",
-                key="material_input",
+                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
-                data_type="workbench_material",
+            ActionOutputHandle(key="heating_station_output", data_type="workbench_station",
-                label="物料编号",
+                         label="加热台ID", data_key="station_id", data_source=DataSource.EXECUTOR),
-                data_key="material_number",
+            ActionOutputHandle(key="material_number_output", data_type="workbench_material",
-                data_source=DataSource.HANDLE,
+                         label="物料编号", data_key="material_number", data_source=DataSource.EXECUTOR),
-            ),
-            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(
@@ -686,9 +484,6 @@ class VirtualWorkbench:
         将物料从An位置移动到加热台
 
         多线程并发调用时, 会竞争机械臂使用权, 并自动查找空闲加热台
-
-        Args:
-            material_number[物料编号]: 要移动的物料编号，对应 A1、A2 等起始位置。
         """
         material_id = f"A{material_number}"
         task_desc = f"移动{material_id}到加热台"
@@ -751,8 +546,7 @@ class VirtualWorkbench:
                         oss_path="",
                         extra=(
                             {"material_uuid": content}
-                            if isinstance(content, str)
+                            if isinstance(content, str) else (content.serialize() if content else {})
-                            else (content.serialize() if content else {})
                         ),
                     )
                     for sample_uuid, content in sample_uuids.items()
@@ -775,8 +569,7 @@ class VirtualWorkbench:
                         oss_path="",
                         extra=(
                             {"material_uuid": content}
-                            if isinstance(content, str)
+                            if isinstance(content, str) else (content.serialize() if content else {})
-                            else (content.serialize() if content else {})
                         ),
                     )
                     for sample_uuid, content in sample_uuids.items()
@@ -788,34 +581,14 @@ class VirtualWorkbench:
         always_free=True,
         description="启动指定加热台的加热程序",
         handles=[
-            ActionInputHandle(
+            ActionInputHandle(key="station_id_input", data_type="workbench_station",
-                key="station_id_input",
+                        label="加热台ID", data_key="station_id", data_source=DataSource.HANDLE),
-                data_type="workbench_station",
+            ActionInputHandle(key="material_number_input", data_type="workbench_material",
-                label="加热台ID",
+                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
-                data_key="station_id",
+            ActionOutputHandle(key="heating_done_station", data_type="workbench_station",
-                data_source=DataSource.HANDLE,
+                         label="加热完成-加热台ID", data_key="station_id", data_source=DataSource.EXECUTOR),
-            ),
+            ActionOutputHandle(key="heating_done_material", data_type="workbench_material",
-            ActionInputHandle(
+                         label="加热完成-物料编号", data_key="material_number", data_source=DataSource.EXECUTOR),
-                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,
-            ),
         ],
     )
     def start_heating(
@@ -826,10 +599,6 @@ class VirtualWorkbench:
     ) -> StartHeatingResult:
         """
         启动指定加热台的加热程序
-
-        Args:
-            station_id[加热台ID]: 要启动加热的加热台编号。
-            material_number[物料编号]: 当前加热台上的物料编号。
         """
         self.logger.info(f"[加热台{station_id}] 开始加热")
 
@@ -846,8 +615,7 @@ class VirtualWorkbench:
                         oss_path="",
                         extra=(
                             {"material_uuid": content}
-                            if isinstance(content, str)
+                            if isinstance(content, str) else (content.serialize() if content else {})
-                            else (content.serialize() if content else {})
                         ),
                     )
                     for sample_uuid, content in sample_uuids.items()
@@ -870,8 +638,7 @@ class VirtualWorkbench:
                             oss_path="",
                             extra=(
                                 {"material_uuid": content}
-                                if isinstance(content, str)
+                                if isinstance(content, str) else (content.serialize() if content else {})
-                                else (content.serialize() if content else {})
                             ),
                         )
                         for sample_uuid, content in sample_uuids.items()
@@ -891,8 +658,7 @@ class VirtualWorkbench:
                             oss_path="",
                             extra=(
                                 {"material_uuid": content}
-                                if isinstance(content, str)
+                                if isinstance(content, str) else (content.serialize() if content else {})
-                                else (content.serialize() if content else {})
                             ),
                         )
                         for sample_uuid, content in sample_uuids.items()
@@ -932,9 +698,7 @@ class VirtualWorkbench:
             self._update_data_status(f"加热台{station_id}加热中: {progress:.1f}%")
 
             if time.time() - last_countdown_log >= 5.0:
-                self.logger.info(
+                self.logger.info(f"[加热台{station_id}] {material_id} 剩余 {remaining:.1f}s")
-                    f"[加热台{station_id}] {material_id} 剩余 {remaining:.1f}s"
-                )
                 last_countdown_log = time.time()
 
             if elapsed >= self.HEATING_TIME:
@@ -951,9 +715,7 @@ class VirtualWorkbench:
                 self._active_tasks[material_id]["status"] = "heating_completed"
 
         self._update_data_status(f"加热台{station_id}加热完成")
-        self.logger.info(
+        self.logger.info(f"[加热台{station_id}] {material_id}加热完成 (用时{self.HEATING_TIME}s)")
-            f"[加热台{station_id}] {material_id}加热完成 (用时{self.HEATING_TIME}s)"
-        )
 
         return {
             "success": True,
@@ -967,8 +729,7 @@ class VirtualWorkbench:
                     oss_path="",
                     extra=(
                         {"material_uuid": content}
-                        if isinstance(content, str)
+                        if isinstance(content, str) else (content.serialize() if content else {})
-                        else (content.serialize() if content else {})
                     ),
                 )
                 for sample_uuid, content in sample_uuids.items()
@@ -979,20 +740,10 @@ class VirtualWorkbench:
         auto_prefix=True,
         description="将物料从加热台移动到输出位置Cn",
         handles=[
-            ActionInputHandle(
+            ActionInputHandle(key="output_station_input", data_type="workbench_station",
-                key="output_station_input",
+                        label="加热台ID", data_key="station_id", data_source=DataSource.HANDLE),
-                data_type="workbench_station",
+            ActionInputHandle(key="output_material_input", data_type="workbench_material",
-                label="加热台ID",
+                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
-                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(
@@ -1003,10 +754,6 @@ class VirtualWorkbench:
     ) -> MoveToOutputResult:
         """
         将物料从加热台移动到输出位置Cn
-
-        Args:
-            station_id[加热台ID]: 已完成加热的加热台编号。
-            material_number[物料编号]: 要移动到输出位置的物料编号，对应 Cn。
         """
         output_number = material_number
 
@@ -1023,8 +770,7 @@ class VirtualWorkbench:
                         oss_path="",
                         extra=(
                             {"material_uuid": content}
-                            if isinstance(content, str)
+                            if isinstance(content, str) else (content.serialize() if content else {})
-                            else (content.serialize() if content else {})
                         ),
                     )
                     for sample_uuid, content in sample_uuids.items()
@@ -1048,8 +794,7 @@ class VirtualWorkbench:
                             oss_path="",
                             extra=(
                                 {"material_uuid": content}
-                                if isinstance(content, str)
+                                if isinstance(content, str) else (content.serialize() if content else {})
-                                else (content.serialize() if content else {})
                             ),
                         )
                         for sample_uuid, content in sample_uuids.items()
@@ -1069,8 +814,7 @@ class VirtualWorkbench:
                             oss_path="",
                             extra=(
                                 {"material_uuid": content}
-                                if isinstance(content, str)
+                                if isinstance(content, str) else (content.serialize() if content else {})
-                                else (content.serialize() if content else {})
                             ),
                         )
                         for sample_uuid, content in sample_uuids.items()
@@ -1152,8 +896,7 @@ class VirtualWorkbench:
                         oss_path="",
                         extra=(
                             {"material_uuid": content}
-                            if isinstance(content, str)
+                            if isinstance(content, str) else (content.serialize() if content else {})
-                            else (content.serialize() if content else {})
                         ),
                     )
                     for sample_uuid, content in sample_uuids.items()

unilabos/registry/ast_registry_scanner.py

@@ -32,7 +32,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 
 MAX_SCAN_DEPTH = 10      # 最大目录递归深度
 MAX_SCAN_FILES = 1000    # 最大扫描文件数量
-_CACHE_VERSION = 2       # 缓存格式版本号，格式变更时递增
+_CACHE_VERSION = 1       # 缓存格式版本号，格式变更时递增
 
 # 合法的装饰器来源模块
 _REGISTRY_DECORATOR_MODULE = "unilabos.registry.decorators"
@@ -258,6 +258,8 @@ def scan_directory(
     }
 
 
+
+
 # ---------------------------------------------------------------------------
 # File-level parsing
 # ---------------------------------------------------------------------------
@@ -359,7 +361,6 @@ def _parse_file(
                     "actions": class_body.get("actions", {}),
                     "status_properties": class_body.get("status_properties", {}),
                     "init_params": class_body.get("init_params", []),
-                    "init_docstring": class_body.get("init_docstring"),
                     "auto_methods": class_body.get("auto_methods", {}),
                     "import_map": import_map,
                 }
@@ -496,6 +497,7 @@ def _collect_imports(tree: ast.Module, module_path: str = "") -> Dict[str, str]:
     return import_map
 
 
+
 # ---------------------------------------------------------------------------
 # Decorator finding & argument extraction
 # ---------------------------------------------------------------------------
@@ -766,7 +768,6 @@ def _extract_class_body(
         "actions": {},          # method_name -> action_info
         "status_properties": {},  # prop_name -> status_info
         "init_params": [],      # [{"name": ..., "type": ..., "default": ...}, ...]
-        "init_docstring": None,
         "auto_methods": {},     # method_name -> method_info (no @action decorator)
     }
 
@@ -779,7 +780,6 @@ def _extract_class_body(
         # --- __init__ ---
         if method_name == "__init__":
             result["init_params"] = _extract_method_params(item, import_map)
-            result["init_docstring"] = ast.get_docstring(item)
             continue
 
         # --- Skip private/dunder ---

unilabos/registry/devices/Qone_nmr.yaml

@@ -51,18 +51,14 @@ Qone_nmr:
               properties:
                 check_interval:
                   default: 60
-                  description: 检查间隔时间（秒），默认60秒
                   type: string
                 expected_count:
                   default: 1
-                  description: 期望生成的.nmr文件数量，默认1个
                   type: string
                 monitor_dir:
-                  description: 要监督的目录路径，如果未指定则使用self.monitor_directory
                   type: string
                 stability_checks:
                   default: 3
-                  description: 文件大小稳定性检查次数，默认3次
                   type: string
               required: []
               type: object
@@ -89,14 +85,11 @@ Qone_nmr:
             goal:
               properties:
                 output_dir:
-                  description: 输出目录（如果未指定，使用self.output_directory）
                   type: string
                 string_list:
-                  description: 字符串列表
                   type: string
                 txt_encoding:
                   default: utf-8
-                  description: 文件编码
                   type: string
               required:
               - string_list
@@ -158,13 +151,6 @@ Qone_nmr:
               additionalProperties: false
               properties:
                 string:
-                  description: '包含多个字符串的输入数据，支持两种格式：
-
-                    1. 逗号分隔：如 "A 1 B 2 C 3, X 10 Y 20 Z 30"
-
-                    2. 换行分隔：如 "A 1 B 2 C 3
-
-                    X 10 Y 20 Z 30"'
                   type: string
               title: StrSingleInput_Goal
               type: object

unilabos/registry/devices/bioyond_cell.yaml

@@ -491,17 +491,14 @@ bioyond_cell:
             goal:
               properties:
                 material_names:
-                  description: 物料名称列表；默认使用 [LiPF6, LiDFOB, DTD, LiFSI, LiPO2F2]
                   items:
                     type: string
                   type: array
                 type_id:
                   default: 3a190ca0-b2f6-9aeb-8067-547e72c11469
-                  description: 物料类型ID
                   type: string
                 warehouse_name:
                   default: 粉末加样头堆栈
-                  description: 目标仓库名（用于取位置信息）
                   type: string
               required: []
               type: object
@@ -530,16 +527,12 @@ bioyond_cell:
             goal:
               properties:
                 location_name_or_id:
-                  description: 具体库位名称（如 A01）或库位 UUID，由用户指定。
                   type: string
                 material_name:
-                  description: 物料名称（会优先匹配配置模板）。
                   type: string
                 type_id:
-                  description: 物料类型 ID（若为空则尝试从配置推断）。
                   type: string
                 warehouse_name:
-                  description: 需要入库的仓库名称；若为空则仅创建不入库。
                   type: string
               required:
               - material_name
@@ -668,20 +661,15 @@ bioyond_cell:
             goal:
               properties:
                 board_type:
-                  description: 板类型，如 "5ml分液瓶板"、"配液瓶(小)板"
                   type: string
                 bottle_type:
-                  description: 瓶类型，如 "5ml分液瓶"、"配液瓶(小)"
                   type: string
                 location_code:
-                  description: 库位编号，例如 "A01"
                   type: string
                 name:
-                  description: 物料名称
                   type: string
                 warehouse_name:
                   default: 手动堆栈
-                  description: 仓库名称，默认为 "手动堆栈"，支持 "自动堆栈-左"、"自动堆栈-右" 等
                   type: string
               required:
               - name
@@ -1968,19 +1956,19 @@ bioyond_cell:
               properties:
                 source_wh_id:
                   default: 3a19debc-84b4-0359-e2d4-b3beea49348b
-                  description: 来源仓库 Id (默认为3号仓库)
+                  description: 来源仓库ID
                   type: string
                 source_x:
                   default: 1
-                  description: 来源位置 X 坐标
+                  description: 来源位置X坐标
                   type: integer
                 source_y:
                   default: 1
-                  description: 来源位置 Y 坐标
+                  description: 来源位置Y坐标
                   type: integer
                 source_z:
                   default: 1
-                  description: 来源位置 Z 坐标
+                  description: 来源位置Z坐标
                   type: integer
               required: []
               type: object
@@ -2073,11 +2061,9 @@ bioyond_cell:
             goal:
               properties:
                 order_code:
-                  description: 任务编号
                   type: string
                 timeout:
                   default: 36000
-                  description: 超时时间（秒）
                   type: integer
               required:
               - order_code
@@ -2106,15 +2092,12 @@ bioyond_cell:
             goal:
               properties:
                 order_code:
-                  description: 任务编号
                   type: string
                 poll_interval:
                   default: 0.5
-                  description: 轮询间隔（秒），默认 0.5 秒
                   type: number
                 timeout:
                   default: 36000
-                  description: 超时时间（秒）
                   type: integer
               required:
               - order_code
@@ -2171,15 +2154,10 @@ bioyond_cell:
     config:
       properties:
         bioyond_config:
-          description: '从 JSON 文件加载的 bioyond 配置字典
-
-            包含 api_host, api_key, HTTP_host, HTTP_port 等配置'
           type: object
         deck:
-          description: Deck 配置（可选，会从 JSON 中自动处理）
           type: string
         protocol_type:
-          description: 协议类型（可选）
           type: string
       required: []
       type: object

unilabos/registry/devices/bioyond_dispensing_station.yaml

@@ -47,10 +47,8 @@ bioyond_dispensing_station:
             goal:
               properties:
                 report_request:
-                  description: WorkstationReportRequest 对象，包含任务完成信息
                   type: string
                 used_materials:
-                  description: 物料使用记录列表
                   type: string
               required:
               - report_request
@@ -104,7 +102,6 @@ bioyond_dispensing_station:
             goal:
               properties:
                 material_name:
-                  description: 物料名称
                   type: string
               required:
               - material_name
@@ -614,10 +611,10 @@ bioyond_dispensing_station:
             goal:
               properties:
                 target_device_id:
-                  description: 目标反应站设备ID(所有转移组使用同一个设备)
+                  description: 目标反应站设备ID（从设备列表中选择，所有转移组都使用同一个目标设备）
                   type: string
                 transfer_groups:
-                  description: '转移任务组列表,每组包含:'
+                  description: 转移任务组列表，每组包含物料名称、目标堆栈和目标库位，可以添加多组
                   type: array
               required:
               - target_device_id
@@ -697,13 +694,10 @@ bioyond_dispensing_station:
     config:
       properties:
         config:
-          description: 配置字典,应包含material_type_mappings等配置
           type: object
         deck:
-          description: Deck对象
           type: string
         protocol_type:
-          description: 协议类型(由ROS系统传递,此处忽略)
           type: string
       required: []
       type: object

unilabos/registry/devices/coin_cell_workstation.yaml

@@ -150,15 +150,15 @@ coincellassemblyworkstation_device:
               properties:
                 assembly_pressure:
                   default: 4200
-                  description: 电池压制力 (N)
+                  description: 电池压制力(N)
                   type: integer
                 assembly_type:
                   default: 7
-                  description: 组装类型 (7=不用铝箔垫, 8=使用铝箔垫)
+                  description: 组装类型(7=不用铝箔垫, 8=使用铝箔垫)
                   type: integer
                 battery_clean_ignore:
                   default: false
-                  description: 是否忽略电池清洁
+                  description: 是否忽略电池清洁步骤
                   type: boolean
                 battery_pressure_mode:
                   default: true
@@ -166,29 +166,29 @@ coincellassemblyworkstation_device:
                   type: boolean
                 dual_drop_first_volume:
                   default: 25
-                  description: 二次滴液第一次排液体积 (μL)
+                  description: 二次滴液第一次排液体积(μL)
                   type: integer
                 dual_drop_mode:
                   default: false
-                  description: 电解液添加模式 (False=单次滴液, True=二次滴液)
+                  description: 电解液添加模式(false=单次滴液, true=二次滴液)
                   type: boolean
                 dual_drop_start_timing:
                   default: false
-                  description: 二次滴液开始滴液时机 (False=正极片前, True=正极片后)
+                  description: 二次滴液开始滴液时机(false=正极片前, true=正极片后)
                   type: boolean
                 dual_drop_suction_timing:
                   default: false
-                  description: 二次滴液吸液时机 (False=正常吸液, True=先吸液)
+                  description: 二次滴液吸液时机(false=正常吸液, true=先吸液)
                   type: boolean
                 elec_num:
                   description: 电解液瓶数
                   type: string
                 elec_use_num:
-                  description: 每瓶电解液组装的电池数
+                  description: 每瓶电解液组装电池数
                   type: string
                 elec_vol:
                   default: 50
-                  description: 电解液吸液量 (μL)
+                  description: 电解液吸液量(μL)
                   type: integer
                 file_path:
                   default: /Users/sml/work
@@ -196,7 +196,7 @@ coincellassemblyworkstation_device:
                   type: string
                 fujipian_juzhendianwei:
                   default: 0
-                  description: 负极片矩阵点位
+                  description: 负极片矩阵点位。盘位置从1开始计数，有效范围：1-8, 13-20 (写入值比实际位置少1，例如：写0取盘位1，写1取盘位2)
                   type: integer
                 fujipian_panshu:
                   default: 0
@@ -204,7 +204,7 @@ coincellassemblyworkstation_device:
                   type: integer
                 gemo_juzhendianwei:
                   default: 0
-                  description: 隔膜矩阵点位
+                  description: 隔膜矩阵点位。盘位置从1开始计数，有效范围：1-8, 13-20 (写入值比实际位置少1，例如：写0取盘位1，写1取盘位2)
                   type: integer
                 gemopanshu:
                   default: 0
@@ -216,7 +216,7 @@ coincellassemblyworkstation_device:
                   type: boolean
                 qiangtou_juzhendianwei:
                   default: 0
-                  description: 枪头盒矩阵点位
+                  description: 枪头盒矩阵点位。盘位置从1开始计数，有效范围：1-32, 64-96 (写入值比实际位置少1，例如：写0取盘位1，写1取盘位2)
                   type: integer
               required:
               - elec_num
@@ -308,13 +308,7 @@ coincellassemblyworkstation_device:
               properties:
                 material_search_enable:
                   default: false
-                  description: '是否启用物料搜寻功能。
+                  description: 是否启用物料搜寻功能。设备初始化后会弹出物料搜寻确认弹窗，此参数控制自动点击"是"(启用)或"否"(不启用)。默认为false(不启用物料搜寻)
-
-                    设备初始化后会弹出物料搜寻确认弹窗，
-
-                    此参数控制自动点击''是''（启用）或''否''（不启用）。
-
-                    默认为False（不启用物料搜寻）。'
                   type: boolean
               required: []
               type: object
@@ -553,15 +547,15 @@ coincellassemblyworkstation_device:
               properties:
                 assembly_pressure:
                   default: 4200
-                  description: 电池压制力 (N)
+                  description: 电池压制力(N)
                   type: integer
                 assembly_type:
                   default: 7
-                  description: 组装类型 (7=不用铝箔垫, 8=使用铝箔垫)
+                  description: 组装类型(7=不用铝箔垫, 8=使用铝箔垫)
                   type: integer
                 battery_clean_ignore:
                   default: false
-                  description: 是否忽略电池清洁
+                  description: 是否忽略电池清洁步骤
                   type: boolean
                 battery_pressure_mode:
                   default: true
@@ -569,29 +563,29 @@ coincellassemblyworkstation_device:
                   type: boolean
                 dual_drop_first_volume:
                   default: 25
-                  description: 二次滴液第一次排液体积 (μL)
+                  description: 二次滴液第一次排液体积(μL)
                   type: integer
                 dual_drop_mode:
                   default: false
-                  description: 电解液添加模式 (False=单次滴液, True=二次滴液)
+                  description: 电解液添加模式(false=单次滴液, true=二次滴液)
                   type: boolean
                 dual_drop_start_timing:
                   default: false
-                  description: 二次滴液开始滴液时机 (False=正极片前, True=正极片后)
+                  description: 二次滴液开始滴液时机(false=正极片前, true=正极片后)
                   type: boolean
                 dual_drop_suction_timing:
                   default: false
-                  description: 二次滴液吸液时机 (False=正常吸液, True=先吸液)
+                  description: 二次滴液吸液时机(false=正常吸液, true=先吸液)
                   type: boolean
                 elec_num:
-                  description: 电解液瓶数
+                  description: 电解液瓶数，如果在workflow中已通过handles连接上游(create_orders的bottle_count输出)，则此参数会自动从上游获取，无需手动填写；如果单独使用此函数(没有上游连接)，则必须手动填写电解液瓶数
                   type: string
                 elec_use_num:
-                  description: 每瓶电解液组装的电池数
+                  description: 每瓶电解液组装电池数
                   type: string
                 elec_vol:
                   default: 50
-                  description: 电解液吸液量 (μL)
+                  description: 电解液吸液量(μL)
                   type: integer
                 file_path:
                   default: /Users/sml/work
@@ -599,7 +593,7 @@ coincellassemblyworkstation_device:
                   type: string
                 fujipian_juzhendianwei:
                   default: 0
-                  description: 负极片矩阵点位
+                  description: 负极片矩阵点位。盘位置从1开始计数，有效范围：1-8, 13-20 (写入值比实际位置少1，例如：写0取盘位1，写1取盘位2)
                   type: integer
                 fujipian_panshu:
                   default: 0
@@ -607,7 +601,7 @@ coincellassemblyworkstation_device:
                   type: integer
                 gemo_juzhendianwei:
                   default: 0
-                  description: 隔膜矩阵点位
+                  description: 隔膜矩阵点位。盘位置从1开始计数，有效范围：1-8, 13-20 (写入值比实际位置少1，例如：写0取盘位1，写1取盘位2)
                   type: integer
                 gemopanshu:
                   default: 0
@@ -619,7 +613,7 @@ coincellassemblyworkstation_device:
                   type: boolean
                 qiangtou_juzhendianwei:
                   default: 0
-                  description: 枪头盒矩阵点位
+                  description: 枪头盒矩阵点位。盘位置从1开始计数，有效范围：1-32, 64-96 (写入值比实际位置少1，例如：写0取盘位1，写1取盘位2)
                   type: integer
               required:
               - elec_num

unilabos/registry/devices/laiyu_liquid_test.yaml

@@ -18,7 +18,6 @@ xyz_stepper_controller:
             goal:
               properties:
                 degrees:
-                  description: 角度值
                   type: number
               required:
               - degrees
@@ -45,7 +44,6 @@ xyz_stepper_controller:
             goal:
               properties:
                 axis:
-                  description: 电机轴
                   type: object
               required:
               - axis
@@ -73,7 +71,6 @@ xyz_stepper_controller:
               properties:
                 enable:
                   default: true
-                  description: True为使能，False为失能
                   type: boolean
               required: []
               type: object
@@ -102,11 +99,9 @@ xyz_stepper_controller:
             goal:
               properties:
                 axis:
-                  description: 电机轴
                   type: object
                 enable:
                   default: true
-                  description: True为使能，False为失能
                   type: boolean
               required:
               - axis
@@ -157,7 +152,6 @@ xyz_stepper_controller:
             goal:
               properties:
                 axis:
-                  description: 电机轴
                   type: object
               required:
               - axis
@@ -189,21 +183,16 @@ xyz_stepper_controller:
               properties:
                 acceleration:
                   default: 1000
-                  description: 加速度(rpm/s)
                   type: integer
                 axis:
-                  description: 电机轴
                   type: object
                 position:
-                  description: 目标位置(步数)
                   type: integer
                 precision:
                   default: 100
-                  description: 到位精度
                   type: integer
                 speed:
                   default: 5000
-                  description: 运行速度(rpm)
                   type: integer
               required:
               - axis
@@ -236,21 +225,16 @@ xyz_stepper_controller:
               properties:
                 acceleration:
                   default: 1000
-                  description: 加速度
                   type: integer
                 axis:
-                  description: 电机轴
                   type: object
                 degrees:
-                  description: 目标角度（度）
                   type: number
                 precision:
                   default: 100
-                  description: 精度
                   type: integer
                 speed:
                   default: 5000
-                  description: 移动速度
                   type: integer
               required:
               - axis
@@ -283,21 +267,16 @@ xyz_stepper_controller:
               properties:
                 acceleration:
                   default: 1000
-                  description: 加速度
                   type: integer
                 axis:
-                  description: 电机轴
                   type: object
                 precision:
                   default: 100
-                  description: 精度
                   type: integer
                 revolutions:
-                  description: 目标圈数
                   type: number
                 speed:
                   default: 5000
-                  description: 移动速度
                   type: integer
               required:
               - axis
@@ -330,20 +309,15 @@ xyz_stepper_controller:
               properties:
                 acceleration:
                   default: 1000
-                  description: 加速度
                   type: integer
                 speed:
                   default: 5000
-                  description: 运行速度
                   type: integer
                 x:
-                  description: X轴目标位置
                   type: integer
                 y:
-                  description: Y轴目标位置
                   type: integer
                 z:
-                  description: Z轴目标位置
                   type: integer
               required: []
               type: object
@@ -376,20 +350,15 @@ xyz_stepper_controller:
               properties:
                 acceleration:
                   default: 1000
-                  description: 加速度
                   type: integer
                 speed:
                   default: 5000
-                  description: 移动速度
                   type: integer
                 x_deg:
-                  description: X轴目标角度（度）
                   type: number
                 y_deg:
-                  description: Y轴目标角度（度）
                   type: number
                 z_deg:
-                  description: Z轴目标角度（度）
                   type: number
               required: []
               type: object
@@ -422,20 +391,15 @@ xyz_stepper_controller:
               properties:
                 acceleration:
                   default: 1000
-                  description: 加速度
                   type: integer
                 speed:
                   default: 5000
-                  description: 移动速度
                   type: integer
                 x_rev:
-                  description: X轴目标圈数
                   type: number
                 y_rev:
-                  description: Y轴目标圈数
                   type: number
                 z_rev:
-                  description: Z轴目标圈数
                   type: number
               required: []
               type: object
@@ -463,7 +427,6 @@ xyz_stepper_controller:
             goal:
               properties:
                 revolutions:
-                  description: 圈数
                   type: number
               required:
               - revolutions
@@ -493,13 +456,10 @@ xyz_stepper_controller:
               properties:
                 acceleration:
                   default: 1000
-                  description: 加速度(rpm/s)
                   type: integer
                 axis:
-                  description: 电机轴
                   type: object
                 speed:
-                  description: 运行速度(rpm)，正值正转，负值反转
                   type: integer
               required:
               - axis
@@ -527,7 +487,6 @@ xyz_stepper_controller:
             goal:
               properties:
                 steps:
-                  description: 步数
                   type: integer
               required:
               - steps
@@ -554,7 +513,6 @@ xyz_stepper_controller:
             goal:
               properties:
                 steps:
-                  description: 步数
                   type: integer
               required:
               - steps
@@ -606,11 +564,9 @@ xyz_stepper_controller:
             goal:
               properties:
                 axis:
-                  description: 电机轴
                   type: object
                 timeout:
                   default: 30.0
-                  description: 超时时间(秒)
                   type: number
               required:
               - axis
@@ -635,14 +591,11 @@ xyz_stepper_controller:
       properties:
         baudrate:
           default: 115200
-          description: 波特率
           type: integer
         port:
-          description: 串口端口名
           type: string
         timeout:
           default: 1.0
-          description: 通信超时时间
           type: number
       required:
       - port

unilabos/registry/devices/liquid_handler.yaml

@@ -510,11 +510,9 @@ liquid_handler:
             goal:
               properties:
                 msg:
-                  description: information to be printed
                   type: string
                 seconds:
                   default: 0
-                  description: seconds to wait
                   type: string
               required: []
               type: object
@@ -2965,22 +2963,15 @@ liquid_handler:
               additionalProperties: false
               properties:
                 channel:
-                  description: int
                   maximum: 2147483647
                   minimum: -2147483648
                   type: integer
                 dis_to_top:
-                  description: 'float
-
-                    Height in mm to move to relative to the well top.'
                   maximum: 1.7976931348623157e+308
                   minimum: -1.7976931348623157e+308
                   type: number
                 well:
                   additionalProperties: false
-                  description: 'Well
-
-                    The target well.'
                   properties:
                     category:
                       type: string
@@ -4838,13 +4829,11 @@ liquid_handler:
     config:
       properties:
         backend:
-          description: Backend to use.
           type: object
         channel_num:
           default: 8
           type: integer
         deck:
-          description: Deck to use.
           type: object
         simulator:
           default: false
@@ -4894,17 +4883,14 @@ liquid_handler.biomek:
                 bind_parent_id:
                   type: string
                 liquid_input_slot:
-                  description: 液体输入槽列表
                   items:
                     type: integer
                   type: array
                 liquid_type:
-                  description: 液体类型列表
                   items:
                     type: string
                   type: array
                 liquid_volume:
-                  description: 液体体积列表
                   items:
                     type: integer
                   type: array
@@ -4915,7 +4901,6 @@ liquid_handler.biomek:
                     type: object
                   type: array
                 slot_on_deck:
-                  description: 甲板上的槽位
                   type: integer
               required:
               - resource_tracker
@@ -5051,27 +5036,20 @@ liquid_handler.biomek:
               additionalProperties: false
               properties:
                 none_keys:
-                  description: 需要设置为None的键列表
                   items:
                     type: string
                   type: array
                 protocol_author:
-                  description: 协议作者
                   type: string
                 protocol_date:
-                  description: 协议日期
                   type: string
                 protocol_description:
-                  description: 协议描述
                   type: string
                 protocol_name:
-                  description: 协议名称
                   type: string
                 protocol_type:
-                  description: 协议类型
                   type: string
                 protocol_version:
-                  description: 协议版本
                   type: string
               title: LiquidHandlerProtocolCreation_Goal
               type: object

unilabos/registry/devices/neware_battery_test_system.yaml

@@ -87,7 +87,7 @@ neware_battery_test_system:
               properties:
                 filepath:
                   default: bts_status.json
-                  description: 输出文件路径
+                  description: 输出JSON文件路径
                   type: string
               required: []
               type: object
@@ -146,7 +146,7 @@ neware_battery_test_system:
             goal:
               properties:
                 plate_num:
-                  description: 盘号 (1 或 2)，如果为None则返回所有盘的状态
+                  description: 盘号 (1 或 2)，如果为null则返回所有盘的状态
                   type: integer
               required: []
               type: object
@@ -237,11 +237,11 @@ neware_battery_test_system:
             goal:
               properties:
                 csv_path:
-                  description: 输入CSV文件路径
+                  description: 输入CSV文件的绝对路径
                   type: string
                 output_dir:
                   default: .
-                  description: 输出目录，用于存储XML文件和备份，默认当前目录
+                  description: 输出目录（用于存储XML和备份文件），默认当前目录
                   type: string
               required:
               - csv_path
@@ -302,14 +302,14 @@ neware_battery_test_system:
             goal:
               properties:
                 backup_dir:
-                  description: 备份目录路径，默认使用最近一次 submit_from_csv 的 backup_dir
+                  description: 备份目录路径（默认使用最近一次submit_from_csv的backup_dir）
                   type: string
                 file_pattern:
                   default: '*'
-                  description: 文件通配符模式，默认 "*" 上传所有文件（例如 "*.csv" 仅上传 CSV 文件）
+                  description: 文件通配符模式，例如 *.csv 或 Battery_*.nda
                   type: string
                 oss_prefix:
-                  description: OSS 对象前缀，默认使用类初始化时的配置
+                  description: OSS对象路径前缀（默认使用self.oss_prefix）
                   type: string
               required: []
               type: object
@@ -336,25 +336,19 @@ neware_battery_test_system:
     config:
       properties:
         devtype:
-          description: 设备类型标识
           type: string
         ip:
-          description: TCP服务器IP地址
           type: string
         machine_id:
           default: 1
-          description: 机器ID
           type: integer
         oss_prefix:
           default: neware_backup
-          description: OSS对象路径前缀，默认"neware_backup"
           type: string
         oss_upload_enabled:
           default: false
-          description: 是否启用OSS上传功能，默认False
           type: boolean
         port:
-          description: TCP端口
           type: integer
         size_x:
           default: 50
@@ -366,7 +360,6 @@ neware_battery_test_system:
           default: 20
           type: number
         timeout:
-          description: 通信超时时间（秒）
           type: integer
       required: []
       type: object

unilabos/registry/devices/organic_miscellaneous.yaml

@@ -207,12 +207,8 @@ separator.homemade:
             goal:
               properties:
                 condition:
-                  description: The condition to be monitored, either 'delta' or 'time'.
                   type: string
                 value:
-                  description: 'The threshold value for the condition.
-
-                    `delta > 0.05`, `time > 60`'
                   type: string
               required:
               - condition
@@ -309,17 +305,12 @@ separator.homemade:
                 event:
                   type: string
                 settling_time:
-                  description: The duration for which to settle after stirring, in
-                    seconds. Defaults to 10.
                   type: string
                 stir_speed:
-                  description: The speed of stirring, in RPM. Defaults to 300.
                   maximum: 1.7976931348623157e+308
                   minimum: -1.7976931348623157e+308
                   type: number
                 stir_time:
-                  description: The duration for which to stir, in seconds. Defaults
-                    to 10.
                   maximum: 1.7976931348623157e+308
                   minimum: -1.7976931348623157e+308
                   type: number

unilabos/registry/devices/pump_and_valve.yaml

@@ -456,7 +456,6 @@ syringe_pump_with_valve.runze.SY03B-T06:
             goal:
               properties:
                 volume:
-                  description: 'absolute position of the plunger, unit: mL'
                   type: number
               required:
               - volume
@@ -482,7 +481,6 @@ syringe_pump_with_valve.runze.SY03B-T06:
             goal:
               properties:
                 volume:
-                  description: 'absolute position of the plunger, unit: mL'
                   type: number
               required:
               - volume
@@ -689,10 +687,8 @@ syringe_pump_with_valve.runze.SY03B-T06:
             goal:
               properties:
                 max_velocity:
-                  description: 'maximum velocity of the plunger, unit: ml/s'
                   type: number
                 position:
-                  description: 'absolute position of the plunger, unit: ml'
                   type: number
               required:
               - position
@@ -1007,7 +1003,6 @@ syringe_pump_with_valve.runze.SY03B-T08:
             goal:
               properties:
                 volume:
-                  description: 'absolute position of the plunger, unit: mL'
                   type: number
               required:
               - volume
@@ -1033,7 +1028,6 @@ syringe_pump_with_valve.runze.SY03B-T08:
             goal:
               properties:
                 volume:
-                  description: 'absolute position of the plunger, unit: mL'
                   type: number
               required:
               - volume
@@ -1240,10 +1234,8 @@ syringe_pump_with_valve.runze.SY03B-T08:
             goal:
               properties:
                 max_velocity:
-                  description: 'maximum velocity of the plunger, unit: ml/s'
                   type: number
                 position:
-                  description: 'absolute position of the plunger, unit: ml'
                   type: number
               required:
               - position

unilabos/registry/devices/reaction_station_bioyond.yaml

@@ -32,7 +32,7 @@ reaction_station.bioyond:
                   type: integer
                 end_point:
                   default: 0
-                  description: 终点计时点 (Start=0, End=1)
+                  description: 终点计时点 (Start=开始前, End=结束后)
                   type: integer
                 end_step_key:
                   default: ''
@@ -40,11 +40,11 @@ reaction_station.bioyond:
                   type: string
                 start_point:
                   default: 0
-                  description: 起点计时点 (Start=0, End=1)
+                  description: 起点计时点 (Start=开始前, End=结束后)
                   type: integer
                 start_step_key:
                   default: ''
-                  description: 起点步骤Key (可选, 默认为空则自动选择)
+                  description: 起点步骤Key (例如 "feeding", "liquid", 可选, 默认为空则自动选择)
                   type: string
               required:
               - duration
@@ -91,7 +91,6 @@ reaction_station.bioyond:
             goal:
               properties:
                 json_str:
-                  description: 订单参数的JSON字符串
                   type: string
               required:
               - json_str
@@ -118,7 +117,6 @@ reaction_station.bioyond:
             goal:
               properties:
                 workflow_ids:
-                  description: 要删除的工作流ID数组
                   items:
                     type: string
                   type: array
@@ -147,7 +145,6 @@ reaction_station.bioyond:
             goal:
               properties:
                 json_str:
-                  description: 'JSON格式的字符串,包含:'
                   type: string
               required:
               - json_str
@@ -200,7 +197,6 @@ reaction_station.bioyond:
             goal:
               properties:
                 web_workflow_json:
-                  description: JSON 格式的网页工作流列表
                   type: string
               required:
               - web_workflow_json
@@ -232,10 +228,8 @@ reaction_station.bioyond:
             goal:
               properties:
                 reactor_id:
-                  description: 反应器编号 (1-5)
                   type: integer
                 temperature:
-                  description: 目标温度 (°C)
                   type: number
               required:
               - reactor_id
@@ -263,7 +257,6 @@ reaction_station.bioyond:
             goal:
               properties:
                 preintake_id:
-                  description: 通量ID
                   type: string
               required:
               - preintake_id
@@ -345,7 +338,6 @@ reaction_station.bioyond:
             goal:
               properties:
                 value:
-                  description: 工作流 ID 列表
                   items:
                     type: string
                   type: array
@@ -373,7 +365,6 @@ reaction_station.bioyond:
             goal:
               properties:
                 workflow_id:
-                  description: 工作流ID
                   type: string
               required:
               - workflow_id
@@ -433,11 +424,11 @@ reaction_station.bioyond:
             goal:
               properties:
                 assign_material_name:
-                  description: 物料名称(液体种类)
+                  description: 物料名称（不能为空）
                   type: string
                 temperature:
                   default: 25.0
-                  description: 温度(C)
+                  description: 温度设定(°C)
                   type: number
                 time:
                   default: '90'
@@ -445,14 +436,14 @@ reaction_station.bioyond:
                   type: string
                 titration_type:
                   default: '1'
-                  description: 是否滴定(NO=1, YES=2)
+                  description: 是否滴定(NO=否, YES=是)
                   type: string
                 torque_variation:
                   default: 2
-                  description: 是否观察(NO=1, YES=2)
+                  description: 是否观察 (NO=否, YES=是)
                   type: integer
                 volume:
-                  description: 分液量(μL)
+                  description: 分液公式(mL)
                   type: string
               required:
               - assign_material_name
@@ -534,11 +525,11 @@ reaction_station.bioyond:
               properties:
                 assign_material_name:
                   default: BAPP
-                  description: 物料名称(试剂瓶位)
+                  description: 物料名称
                   type: string
                 temperature:
                   default: 25.0
-                  description: 温度设定(C)
+                  description: 温度设定(°C)
                   type: number
                 time:
                   default: '0'
@@ -546,15 +537,15 @@ reaction_station.bioyond:
                   type: string
                 titration_type:
                   default: '1'
-                  description: 是否滴定(NO=1, YES=2)
+                  description: 是否滴定(NO=否, YES=是)
                   type: string
                 torque_variation:
                   default: 1
-                  description: 是否观察(int类型, 1=否, 2=是)
+                  description: 是否观察 (NO=否, YES=是)
                   type: integer
                 volume:
                   default: '350'
-                  description: 分液质量(g)
+                  description: 分液公式(mL)
                   type: string
               required: []
               type: object
@@ -602,28 +593,26 @@ reaction_station.bioyond:
                   description: 物料名称
                   type: string
                 solvents:
-                  description: '溶剂信息的字典或JSON字符串(可选),格式如下:
+                  description: '溶剂信息对象(可选),包含: additional_solvent(溶剂体积mL), total_liquid_volume(总液体体积mL)。如果提供,将自动计算volume'
-
-                    {'
                   type: string
                 temperature:
                   default: 25.0
-                  description: 温度设定(C)
+                  description: 温度设定(°C),默认25.00
                   type: number
                 time:
                   default: '360'
-                  description: 观察时间(分钟)
+                  description: 观察时间(分钟),默认360
                   type: string
                 titration_type:
                   default: '1'
-                  description: 是否滴定(NO=1, YES=2)
+                  description: 是否滴定(NO=否, YES=是),默认NO
                   type: string
                 torque_variation:
                   default: 2
-                  description: 是否观察(NO=1, YES=2)
+                  description: 是否观察 (NO=否, YES=是),默认YES
                   type: integer
                 volume:
-                  description: 分液量(μL),直接指定体积(可选,如果提供solvents则自动计算)
+                  description: 分液量(mL)。可直接提供,或通过solvents参数自动计算
                   type: string
               required:
               - assign_material_name
@@ -682,32 +671,33 @@ reaction_station.bioyond:
                   description: 物料名称
                   type: string
                 extracted_actuals:
-                  description: 从报告提取的实际加料量JSON字符串,包含actualTargetWeigh和actualVolume
+                  description: 从报告提取的实际加料量JSON字符串,包含actualTargetWeigh(m二酐滴定)和actualVolume(V二酐滴定)
                   type: string
                 feeding_order_data:
-                  description: feeding_order JSON字符串或对象,用于获取m二酐值
+                  description: 'feeding_order JSON对象,用于获取m二酐值(type为main_anhydride的amount)。示例:
+                    {"feeding_order": [{"type": "main_anhydride", "amount": 1.915}]}'
                   type: string
                 temperature:
                   default: 25.0
-                  description: 温度(C)
+                  description: 温度设定(°C),默认25.00
                   type: number
                 time:
                   default: '90'
-                  description: 观察时间(分钟)
+                  description: 观察时间(分钟),默认90
                   type: string
                 titration_type:
                   default: '2'
-                  description: 是否滴定(NO=1, YES=2),默认2
+                  description: 是否滴定(NO=否, YES=是),默认YES
                   type: string
                 torque_variation:
                   default: 2
-                  description: 是否观察(NO=1, YES=2)
+                  description: 是否观察 (NO=否, YES=是),默认YES
                   type: integer
                 volume_formula:
-                  description: 分液公式(μL),如果提供则直接使用,否则自动计算
+                  description: 分液公式(mL)。可直接提供固定公式,或留空由系统根据x_value、feeding_order_data、extracted_actuals自动生成
                   type: string
                 x_value:
-                  description: 手工输入的x值,格式如 "1-2-3"
+                  description: 公式中的x值,手工输入,格式为"{{1-2-3}}"(包含双花括号)。用于自动公式计算
                   type: string
               required:
               - assign_material_name
@@ -748,7 +738,7 @@ reaction_station.bioyond:
                   type: string
                 temperature:
                   default: 25.0
-                  description: 温度(C)
+                  description: 温度设定(°C)
                   type: number
                 time:
                   default: '0'
@@ -756,14 +746,14 @@ reaction_station.bioyond:
                   type: string
                 titration_type:
                   default: '1'
-                  description: 是否滴定(NO=1, YES=2)
+                  description: 是否滴定(NO=否, YES=是)
                   type: string
                 torque_variation:
                   default: 1
-                  description: 是否观察(NO=1, YES=2)
+                  description: 是否观察 (NO=否, YES=是)
                   type: integer
                 volume_formula:
-                  description: 分液公式(μL)
+                  description: 分液公式(mL)
                   type: string
               required:
               - volume_formula
@@ -796,7 +786,7 @@ reaction_station.bioyond:
                   description: 任务名称
                   type: string
                 workflow_name:
-                  description: 合并后的工作流名称
+                  description: 工作流名称
                   type: string
               required:
               - workflow_name
@@ -829,15 +819,15 @@ reaction_station.bioyond:
             goal:
               properties:
                 assign_material_name:
-                  description: 物料名称(不能为空)
+                  description: 物料名称
                   type: string
                 cutoff:
                   default: '900000'
-                  description: 粘度上限(需为有效数字字符串,默认 "900000")
+                  description: 粘度上限
                   type: string
                 temperature:
                   default: -10.0
-                  description: 温度设定(C,范围:-50.00 至 100.00)
+                  description: 温度设定(°C)
                   type: number
               required:
               - assign_material_name
@@ -919,11 +909,11 @@ reaction_station.bioyond:
                   description: 物料名称(用于获取试剂瓶位ID)
                   type: string
                 material_id:
-                  description: 粉末类型ID, Salt=1, Flour=2, BTDA=3
+                  description: 粉末类型ID，Salt=盐（21分钟），Flour=面粉（27分钟），BTDA=BTDA（38分钟）
                   type: string
                 temperature:
                   default: 25.0
-                  description: 温度设定(C)
+                  description: 温度设定(°C)
                   type: number
                 time:
                   default: '0'
@@ -931,7 +921,7 @@ reaction_station.bioyond:
                   type: string
                 torque_variation:
                   default: 1
-                  description: 是否观察(NO=1, YES=2)
+                  description: 是否观察 (NO=否, YES=是)
                   type: integer
               required:
               - material_id
@@ -955,13 +945,10 @@ reaction_station.bioyond:
     config:
       properties:
         config:
-          description: 配置字典,应包含workflow_mappings等配置
           type: object
         deck:
-          description: Deck对象
           type: string
         protocol_type:
-          description: 协议类型(由ROS系统传递,此处忽略)
           type: string
       required: []
       type: object

unilabos/registry/devices/robot_arm.yaml

@@ -198,8 +198,6 @@ robotic_arm.SCARA_with_slider.moveit.virtual:
               additionalProperties: false
               properties:
                 command:
-                  description: A JSON-formatted string that includes option, target,
-                    speed, lift_height, mt_height
                   type: string
               title: SendCmd_Goal
               type: object
@@ -243,8 +241,6 @@ robotic_arm.SCARA_with_slider.moveit.virtual:
               additionalProperties: false
               properties:
                 command:
-                  description: A JSON-formatted string that includes quaternion, speed,
-                    position
                   type: string
               title: SendCmd_Goal
               type: object
@@ -288,7 +284,6 @@ robotic_arm.SCARA_with_slider.moveit.virtual:
               additionalProperties: false
               properties:
                 command:
-                  description: A JSON-formatted string that includes speed
                   type: string
               title: SendCmd_Goal
               type: object

unilabos/registry/devices/robot_linear_motion.yaml

@@ -709,8 +709,6 @@ linear_motion.toyo_xyz.sim:
               additionalProperties: false
               properties:
                 command:
-                  description: A JSON-formatted string that includes option, target,
-                    speed, lift_height, mt_height
                   type: string
               title: SendCmd_Goal
               type: object
@@ -754,8 +752,6 @@ linear_motion.toyo_xyz.sim:
               additionalProperties: false
               properties:
                 command:
-                  description: A JSON-formatted string that includes quaternion, speed,
-                    position
                   type: string
               title: SendCmd_Goal
               type: object
@@ -799,7 +795,6 @@ linear_motion.toyo_xyz.sim:
               additionalProperties: false
               properties:
                 command:
-                  description: A JSON-formatted string that includes speed
                   type: string
               title: SendCmd_Goal
               type: object

unilabos/registry/devices/virtual_device.yaml

@@ -2179,7 +2179,6 @@ virtual_multiway_valve:
             goal:
               properties:
                 port_number:
-                  description: 端口号 (1-8)
                   type: integer
               required:
               - port_number
@@ -2226,7 +2225,6 @@ virtual_multiway_valve:
             goal:
               properties:
                 port_number:
-                  description: 目标端口号 (1-8)
                   type: integer
               required:
               - port_number
@@ -2263,7 +2261,6 @@ virtual_multiway_valve:
               additionalProperties: false
               properties:
                 command:
-                  description: 目标位置 (0-8) 或位置字符串
                   type: string
               title: SendCmd_Goal
               type: object
@@ -2307,7 +2304,6 @@ virtual_multiway_valve:
               additionalProperties: false
               properties:
                 command:
-                  description: 目标位置 (0-8) 或位置字符串
                   type: string
               title: SendCmd_Goal
               type: object
@@ -3964,14 +3960,6 @@ virtual_separator:
     io_type: source
     label: bottom_phase_out
     side: SOUTH
-  - data_key: top_outlet
-    data_source: executor
-    data_type: fluid
-    description: 上相（轻相）液体输出口
-    handler_key: topphaseout
-    io_type: source
-    label: top_phase_out
-    side: NORTH
   - data_key: mechanical_port
     data_source: handle
     data_type: mechanical
@@ -4219,7 +4207,6 @@ virtual_solenoid_valve:
               additionalProperties: false
               properties:
                 string:
-                  description: '"ON"/"OFF" 或 "OPEN"/"CLOSED"'
                   type: string
               title: StrSingleInput_Goal
               type: object
@@ -4263,7 +4250,6 @@ virtual_solenoid_valve:
               additionalProperties: false
               properties:
                 command:
-                  description: '"OPEN"/"CLOSED" 或其他控制命令'
                   type: string
               title: SendCmd_Goal
               type: object
@@ -4424,20 +4410,16 @@ virtual_solid_dispenser:
                 event:
                   type: string
                 mass:
-                  description: 质量字符串 (如 "2.9 g")
                   type: string
                 mol:
-                  description: 摩尔数字符串 (如 "0.12 mol")
                   type: string
                 purpose:
-                  description: 添加目的
                   type: string
                 rate_spec:
                   type: string
                 ratio:
                   type: string
                 reagent:
-                  description: 试剂名称
                   type: string
                 stir:
                   type: boolean
@@ -4449,7 +4431,6 @@ virtual_solid_dispenser:
                   type: string
                 vessel:
                   additionalProperties: false
-                  description: 目标容器
                   properties:
                     category:
                       type: string
@@ -5579,10 +5560,8 @@ virtual_transfer_pump:
             goal:
               properties:
                 velocity:
-                  description: 拉取速度 (ml/s)
                   type: number
                 volume:
-                  description: 要拉取的体积 (ml)
                   type: number
               required:
               - volume
@@ -5609,10 +5588,8 @@ virtual_transfer_pump:
             goal:
               properties:
                 velocity:
-                  description: 推出速度 (ml/s)
                   type: number
                 volume:
-                  description: 要推出的体积 (ml)
                   type: number
               required:
               - volume
@@ -5708,12 +5685,10 @@ virtual_transfer_pump:
               additionalProperties: false
               properties:
                 max_velocity:
-                  description: 移动速度 (ml/s)
                   maximum: 1.7976931348623157e+308
                   minimum: -1.7976931348623157e+308
                   type: number
                 position:
-                  description: 目标位置 (ml)
                   maximum: 1.7976931348623157e+308
                   minimum: -1.7976931348623157e+308
                   type: number
@@ -5862,10 +5837,8 @@ virtual_transfer_pump:
     config:
       properties:
         config:
-          description: 配置字典，包含max_volume, port等参数
           type: object
         device_id:
-          description: 设备ID
           type: string
       required: []
       type: object

unilabos/registry/devices/xrd_d7mate.yaml

@@ -409,11 +409,11 @@ xrd_d7mate:
               properties:
                 end_theta:
                   default: 80.0
-                  description: 结束角度（≥5.5°，且必须大于 start_theta）
+                  description: 结束角度（≥5.5°，且必须大于start_theta）
                   type: number
                 exp_time:
                   default: 0.1
-                  description: 曝光时间（0.1-5.0 秒）
+                  description: 曝光时间（0.1-5.0秒）
                   type: number
                 increment:
                   default: 0.05
@@ -421,7 +421,7 @@ xrd_d7mate:
                   type: number
                 sample_id:
                   default: ''
-                  description: 样品名称
+                  description: 样品标识符
                   type: string
                 start_theta:
                   default: 10.0
@@ -433,7 +433,7 @@ xrd_d7mate:
                   type: string
                 wait_minutes:
                   default: 3.0
-                  description: 在允许上样后、发送样品准备完成前的等待分钟数（默认 3 分钟）
+                  description: 允许上样后等待分钟数
                   type: number
               required: []
               title: StartWorkflow_Goal
@@ -492,15 +492,12 @@ xrd_d7mate:
       properties:
         host:
           default: 127.0.0.1
-          description: 设备IP地址
           type: string
         port:
           default: 6001
-          description: 通信端口，默认6001
           type: string
         timeout:
           default: 10.0
-          description: 超时时间，单位秒
           type: string
       required: []
       type: object

unilabos/registry/devices/zhida_gcms.yaml

@@ -217,7 +217,6 @@ zhida_gcms:
               additionalProperties: false
               properties:
                 string:
-                  description: Base64编码的CSV数据（ROS2参数名）
                   type: string
               title: StrSingleInput_Goal
               type: object
@@ -258,7 +257,6 @@ zhida_gcms:
               additionalProperties: false
               properties:
                 string:
-                  description: CSV文件路径（ROS2参数名）
                   type: string
               title: StrSingleInput_Goal
               type: object
@@ -291,15 +289,12 @@ zhida_gcms:
       properties:
         host:
           default: 192.168.3.184
-          description: 设备IP地址，本地部署时可使用'127.0.0.1'
           type: string
         port:
           default: 5792
-          description: 通信端口，默认5792
           type: string
         timeout:
           default: 10.0
-          description: 超时时间，单位秒
           type: string
       required: []
       type: object

unilabos/registry/registry.py

@@ -271,7 +271,6 @@ class Registry:
         registry_cache.pkl 一个文件中，删除即可完全重置。
         """
         import time as _time
-        from unilabos.registry.ast_registry_scanner import _CACHE_VERSION as AST_SCAN_CACHE_VERSION
         from unilabos.registry.ast_registry_scanner import scan_directory
 
         scan_t0 = _time.perf_counter()
@@ -287,10 +286,6 @@ class Registry:
         # ---- 统一缓存：一个 pkl 包含所有数据 ----
         unified_cache = self._load_config_cache()
         ast_cache = unified_cache.setdefault("_ast_scan", {"files": {}})
-        if ast_cache.get("version") != AST_SCAN_CACHE_VERSION:
-            ast_cache = {"version": AST_SCAN_CACHE_VERSION, "files": {}}
-            unified_cache["_ast_scan"] = ast_cache
-            unified_cache.pop("_build_results", None)
 
         # 默认：扫描 unilabos 包所在的父目录
         pkg_root = Path(__file__).resolve().parent.parent          # .../unilabos
@@ -566,47 +561,13 @@ class Registry:
 
         return prop_schema
 
-    @staticmethod
-    def _apply_docstring_param_metadata(
-        schema: Dict[str, Any],
-        doc_info: Dict[str, Any],
-        field_to_param: Optional[Dict[str, str]] = None,
-        apply_defaults: bool = False,
-    ) -> None:
-        """Apply parsed docstring display names and descriptions to schema properties."""
-        if not schema or not doc_info:
-            return
-
-        props = schema.get("properties", {})
-        if not isinstance(props, dict):
-            return
-
-        param_descs = doc_info.get("params", {}) or {}
-        param_display_names = doc_info.get("param_display_names", {}) or {}
-        for field_name, prop_schema in props.items():
-            if not isinstance(prop_schema, dict):
-                continue
-            param_name = field_to_param.get(field_name, field_name) if field_to_param else field_name
-            if not isinstance(param_name, str):
-                continue
-            param_name = param_name.removesuffix("[]")
-            if param_name in param_display_names:
-                prop_schema["title"] = param_display_names[param_name]
-            elif apply_defaults and not prop_schema.get("title"):
-                prop_schema["title"] = field_name
-
-            if param_name in param_descs:
-                prop_schema["description"] = param_descs[param_name]
-            elif apply_defaults and "description" not in prop_schema:
-                prop_schema["description"] = ""
-
     def _generate_unilab_json_command_schema(
         self, method_args: list, docstring: Optional[str] = None,
         import_map: Optional[Dict[str, str]] = None,
-        apply_doc_defaults: bool = False,
     ) -> Dict[str, Any]:
         """根据方法参数和 docstring 生成 UniLabJsonCommand schema"""
         doc_info = parse_docstring(docstring)
+        param_descs = doc_info.get("params", {})
 
         schema = {
             "type": "object",
@@ -637,10 +598,12 @@ class Registry:
                     param_name, param_type, param_default, import_map=import_map
                 )
 
+            if param_name in param_descs:
+                schema["properties"][param_name]["description"] = param_descs[param_name]
+
             if param_required:
                 schema["required"].append(param_name)
 
-        self._apply_docstring_param_metadata(schema, doc_info, apply_defaults=apply_doc_defaults)
         return schema
 
     def _generate_status_types_schema(self, status_methods: Dict[str, Any]) -> Dict[str, Any]:
@@ -836,7 +799,6 @@ class Registry:
             type_str = "UniLabJsonCommandAsync" if is_async else "UniLabJsonCommand"
             params = method_info.get("params", [])
             method_doc = method_info.get("docstring")
-            method_doc_info = parse_docstring(method_doc)
             goal_schema = self._generate_schema_from_ast_params(params, method_name, method_doc, imap)
 
             if action_args is not None:
@@ -866,11 +828,7 @@ class Registry:
 
             # action handles: 从 @action(handles=[...]) 提取并转换为标准格式
             raw_handles = (action_args or {}).get("handles")
-            handles = (
+            handles = normalize_ast_action_handles(raw_handles) if isinstance(raw_handles, list) else (raw_handles or {})
-                normalize_ast_action_handles(raw_handles)
-                if isinstance(raw_handles, list)
-                else (raw_handles or {})
-            )
 
             # placeholder_keys: 先从参数类型自动检测，再用装饰器显式配置覆盖/补充
             pk = detect_placeholder_keys(params)
@@ -889,12 +847,7 @@ class Registry:
                 "goal": goal,
                 "feedback": (action_args or {}).get("feedback") or {},
                 "result": (action_args or {}).get("result") or {},
-                "schema": wrap_action_schema(
+                "schema": wrap_action_schema(goal_schema, action_name, result_schema=result_schema),
-                    goal_schema,
-                    action_name,
-                    description=(action_args or {}).get("description") or method_doc_info.get("description", ""),
-                    result_schema=result_schema,
-                ),
                 "goal_default": goal_default,
                 "handles": handles,
                 "placeholder_keys": pk,
@@ -933,11 +886,7 @@ class Registry:
                 action_name = f"auto-{action_name}"
 
             raw_handles = action_args.get("handles")
-            handles = (
+            handles = normalize_ast_action_handles(raw_handles) if isinstance(raw_handles, list) else (raw_handles or {})
-                normalize_ast_action_handles(raw_handles)
-                if isinstance(raw_handles, list)
-                else (raw_handles or {})
-            )
 
             method_params = method_info.get("params", [])
 
@@ -1030,10 +979,7 @@ class Registry:
                 "schema": schema,
                 "goal_default": goal_default,
                 "handles": handles,
-                "placeholder_keys": {
+                "placeholder_keys": {**detect_placeholder_keys(method_params), **(action_args.get("placeholder_keys") or {})},
-                    **detect_placeholder_keys(method_params),
-                    **(action_args.get("placeholder_keys") or {}),
-                },
             }
             if action_args.get("always_free") or method_info.get("always_free"):
                 action_entry["always_free"] = True
@@ -1042,22 +988,13 @@ class Registry:
             nt = normalize_enum_value(action_args.get("node_type"), NodeType)
             if nt:
                 action_entry["node_type"] = nt
-            goal_schema_for_docs = action_entry.get("schema", {}).get("properties", {}).get("goal", {})
-            self._apply_docstring_param_metadata(
-                goal_schema_for_docs,
-                parse_docstring(method_info.get("docstring")),
-                goal,
-                apply_defaults=True,
-            )
             action_value_mappings[action_name] = action_entry
 
         action_value_mappings = dict(sorted(action_value_mappings.items()))
 
         # --- init_param_schema = { config: <init_params>, data: <status_types> } ---
         init_params = ast_meta.get("init_params", [])
-        config_schema = self._generate_schema_from_ast_params(
+        config_schema = self._generate_schema_from_ast_params(init_params, "__init__", import_map=imap)
-            init_params, "__init__", ast_meta.get("init_docstring"), import_map=imap
-        )
         data_schema = self._generate_status_schema_from_ast(
             ast_meta.get("status_properties", {}), imap
         )
@@ -1105,6 +1042,7 @@ class Registry:
     ) -> Dict[str, Any]:
         """Generate JSON Schema from AST-extracted parameter list."""
         doc_info = parse_docstring(docstring)
+        param_descs = doc_info.get("params", {})
 
         schema: Dict[str, Any] = {
             "type": "object",
@@ -1134,10 +1072,12 @@ class Registry:
                     pname, ptype, pdefault, import_map
                 )
 
+            if pname in param_descs:
+                schema["properties"][pname]["description"] = param_descs[pname]
+
             if prequired:
                 schema["required"].append(pname)
 
-        self._apply_docstring_param_metadata(schema, doc_info, apply_defaults=True)
         return schema
 
     def _generate_status_schema_from_ast(
@@ -1867,7 +1807,7 @@ class Registry:
                         else:
                             action_key = f"auto-{k}"
                         goal_schema = self._generate_unilab_json_command_schema(
-                            v["args"], docstring=v.get("docstring"), import_map=enhanced_import_map
+                            v["args"], import_map=enhanced_import_map
                         )
                         ret_type = v.get("return_type", "")
                         result_schema = None
@@ -1876,13 +1816,7 @@ class Registry:
                                 "result", ret_type, None, import_map=enhanced_import_map
                             )
                         old_cfg = old_action_configs.get(action_key) or old_action_configs.get(f"auto-{k}", {})
-                        doc_info = parse_docstring(v.get("docstring"))
+                        new_schema = wrap_action_schema(goal_schema, action_key, result_schema=result_schema)
-                        new_schema = wrap_action_schema(
-                            goal_schema,
-                            action_key,
-                            description=doc_info.get("description", ""),
-                            result_schema=result_schema,
-                        )
                         old_schema = old_cfg.get("schema", {})
                         if old_schema:
                             preserve_field_descriptions(new_schema, old_schema)
@@ -1948,12 +1882,6 @@ class Registry:
 
                         merged_pk = dict(old_cfg.get("placeholder_keys", {}))
                         merged_pk.update(detect_placeholder_keys(v["args"]))
-                        goal_schema_for_docs = (
-                            entry_schema.get("properties", {}).get("goal", {})
-                            if isinstance(entry_schema, dict)
-                            else {}
-                        )
-                        self._apply_docstring_param_metadata(goal_schema_for_docs, doc_info, entry_goal)
 
                         entry = {
                             "type": entry_type,
@@ -1974,8 +1902,7 @@ class Registry:
 
                     device_config["init_param_schema"] = {}
                     init_schema = self._generate_unilab_json_command_schema(
-                        enhanced_info["init_params"],
+                        enhanced_info["init_params"], "__init__",
-                        docstring=enhanced_info.get("init_docstring"),
                         import_map=enhanced_import_map,
                     )
                     device_config["init_param_schema"]["config"] = init_schema
@@ -2022,9 +1949,7 @@ class Registry:
                             action_str_type_mapping[action_type_str] = target_type
                             if target_type is not None:
                                 try:
-                                    action_config["goal_default"] = ROS2MessageInstance(
+                                    action_config["goal_default"] = ROS2MessageInstance(target_type.Goal()).get_python_dict()
-                                        target_type.Goal()
-                                    ).get_python_dict()
                                 except Exception:
                                     action_config["goal_default"] = {}
                                 prev_schema = action_config.get("schema", {})
@@ -2216,7 +2141,6 @@ class Registry:
                                 "unilabos_device_id": {
                                     "type": "string",
                                     "default": "",
-                                    "title": "设备ID",
                                     "description": "UniLabOS设备ID，用于指定执行动作的具体设备实例",
                                 },
                                 **schema["properties"]["goal"]["properties"],
@@ -2288,14 +2212,7 @@ class Registry:
 lab_registry = Registry()
 
 
-def build_registry(
+def build_registry(registry_paths=None, devices_dirs=None, upload_registry=False, check_mode=False, complete_registry=False, external_only=False):
-    registry_paths=None,
-    devices_dirs=None,
-    upload_registry=False,
-    check_mode=False,
-    complete_registry=False,
-    external_only=False,
-):
     """
     构建或获取Registry单例实例
     """
@@ -2309,12 +2226,7 @@ def build_registry(
             if path not in current_paths:
                 lab_registry.registry_paths.append(path)
 
-    lab_registry.setup(
+    lab_registry.setup(devices_dirs=devices_dirs, upload_registry=upload_registry, complete_registry=complete_registry, external_only=external_only)
-        devices_dirs=devices_dirs,
-        upload_registry=upload_registry,
-        complete_registry=complete_registry,
-        external_only=external_only,
-    )
 
     # 将 AST 扫描的字符串类型替换为实际 ROS2 消息类（仅查找 ROS2 类型，不 import 设备模块）
     lab_registry.resolve_all_types()

unilabos/registry/utils.py

@@ -36,40 +36,16 @@ class ROSMsgNotFound(Exception):
 # ---------------------------------------------------------------------------
 
 _SECTION_RE = re.compile(r"^(\w[\w\s]*):\s*$")
-_PARAM_HEADER_RE = re.compile(
-    r"^\s*(?P<name>\w[\w]*)\s*(?:\[(?P<display_name>[^\]]+)\])?(?:\s*\([^)]*\))?\s*$"
-)
-
-
-def _parse_docstring_param_header(param_part: str) -> Tuple[str, Optional[str]]:
-    """Parse ``name[display_name]`` or Google-style ``name (type)``."""
-    match = _PARAM_HEADER_RE.match(param_part.strip())
-    if not match:
-        return param_part.strip().split("(")[0].strip(), None
-
-    display_name = match.group("display_name")
-    if display_name is not None:
-        display_name = display_name.strip() or None
-    return match.group("name").strip(), display_name
 
 
 def parse_docstring(docstring: Optional[str]) -> Dict[str, Any]:
     """
-    解析 docstring，提取描述和参数说明。
+    解析 Google-style docstring，提取描述和参数说明。
-
-    支持:
-      - Google-style ``Args:`` / ``Parameters:`` 小节
-      - 直接参数行 ``field: desc``
-      - 带显示名参数行 ``field[Display Name]: desc``
 
     Returns:
-        {
+        {"description": "短描述", "params": {"param1": "参数1描述", ...}}
-            "description": "短描述",
-            "params": {"param1": "参数1描述", ...},
-            "param_display_names": {"param1": "显示名", ...},
-        }
     """
-    result: Dict[str, Any] = {"description": "", "params": {}, "param_display_names": {}}
+    result: Dict[str, Any] = {"description": "", "params": {}}
     if not docstring:
         return result
 
@@ -77,53 +53,33 @@ def parse_docstring(docstring: Optional[str]) -> Dict[str, Any]:
     if not lines:
         return result
 
+    result["description"] = lines[0].strip()
+
     in_args = False
-    current_section: Optional[str] = None
     current_param: Optional[str] = None
-    current_display_name: Optional[str] = None
     current_desc_parts: list = []
 
-    def flush_current_param() -> None:
+    for line in lines[1:]:
-        nonlocal current_param, current_display_name, current_desc_parts
-        if current_param is None:
-            return
-        result["params"][current_param] = "\n".join(current_desc_parts).strip()
-        if current_display_name:
-            result["param_display_names"][current_param] = current_display_name
-        current_param = None
-        current_display_name = None
-        current_desc_parts = []
-
-    first_line = lines[0].strip()
-    start_index = 0
-    if not _SECTION_RE.match(first_line) and ":" not in first_line:
-        result["description"] = first_line
-        start_index = 1
-
-    for line in lines[start_index:]:
         stripped = line.strip()
-        if not stripped:
-            if current_param is not None:
-                current_desc_parts.append("")
-            continue
-
         section_match = _SECTION_RE.match(stripped)
         if section_match:
-            flush_current_param()
+            if current_param is not None:
-            current_section = section_match.group(1).lower()
+                result["params"][current_param] = "\n".join(current_desc_parts).strip()
-            in_args = current_section in ("args", "arguments", "parameters", "params")
+                current_param = None
+                current_desc_parts = []
+            section_name = section_match.group(1).lower()
+            in_args = section_name in ("args", "arguments", "parameters", "params")
             continue
 
-        parse_as_param = in_args or current_section is None
+        if not in_args:
-        if not parse_as_param:
             continue
 
-        if ":" in stripped:
+        if ":" in stripped and not stripped.startswith(" "):
-            flush_current_param()
+            if current_param is not None:
+                result["params"][current_param] = "\n".join(current_desc_parts).strip()
             param_part, _, desc_part = stripped.partition(":")
-            param_name, display_name = _parse_docstring_param_header(param_part)
+            param_name = param_part.strip().split("(")[0].strip()
             current_param = param_name
-            current_display_name = display_name
             current_desc_parts = [desc_part.strip()]
         elif current_param is not None:
             aline = line
@@ -133,7 +89,8 @@ def parse_docstring(docstring: Optional[str]) -> Dict[str, Any]:
                 aline = aline[1:]
             current_desc_parts.append(aline.strip())
 
-    flush_current_param()
+    if current_param is not None:
+        result["params"][current_param] = "\n".join(current_desc_parts).strip()
 
     return result
 

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

unilabos/ros/nodes/base_device_node.py

@@ -45,7 +45,6 @@ from unilabos.resources.graphio import (
 )
 from unilabos.resources.plr_additional_res_reg import register
 from unilabos.ros.msgs.message_converter import (
-    String,
     convert_to_ros_msg,
     convert_from_ros_msg_with_mapping,
     convert_to_ros_msg_with_mapping,
@@ -251,8 +250,7 @@ class PropertyPublisher:
     ):
         self.node = node
         self.name = name
-        self.msg_type = self._normalize_msg_type(msg_type)
+        self.msg_type = msg_type
-        self.original_msg_type = msg_type
         self.get_method = get_method
         self.timer_period = initial_period
         self.print_publish = print_publish
@@ -260,36 +258,16 @@ class PropertyPublisher:
 
         self._value = None
         try:
-            self.publisher_ = node.create_publisher(self.msg_type, f"{name}", qos)
+            self.publisher_ = node.create_publisher(msg_type, f"{name}", qos)
         except Exception as e:
             self.node.lab_logger().error(
-                f"StatusError, DeviceId: {self.node.device_id} 创建发布者 {name} 失败，"
+                f"StatusError, DeviceId: {self.node.device_id} 创建发布者 {name} 失败，可能由于注册表有误，类型: {msg_type}，错误: {e}"
-                f"可能由于注册表有误，类型: {msg_type}，错误: {e}"
             )
-            self.msg_type = String
-            try:
-                self.publisher_ = node.create_publisher(self.msg_type, f"{name}", qos)
-                self.node.lab_logger().warning(
-                    f"属性 {name} 的发布类型已降级为 String，原始类型: {msg_type}"
-                )
-            except Exception:
-                self.publisher_ = None
         self.timer = node.create_timer(self.timer_period, self.publish_property)
         self.__loop = ROS2DeviceNode.get_asyncio_loop()
-        str_msg_type = str(self.msg_type)[8:-2]
+        str_msg_type = str(msg_type)[8:-2]
         self.node.lab_logger().trace(f"发布属性: {name}, 类型: {str_msg_type}, 周期: {initial_period}秒, QoS: {qos}")
 
-    @staticmethod
-    def _normalize_msg_type(msg_type):
-        if msg_type in (dict, list, tuple, set) or msg_type in ("dict", "list", "tuple", "set"):
-            return String
-        return msg_type
-
-    def _normalize_value(self, value):
-        if self.msg_type is String and isinstance(value, (dict, list, tuple, set)):
-            return json.dumps(value, ensure_ascii=False, cls=TypeEncoder)
-        return value
-
     def get_property(self):
         if asyncio.iscoroutinefunction(self.get_method):
             # 如果是异步函数，运行事件循环并等待结果
@@ -324,16 +302,12 @@ class PropertyPublisher:
                 pass
                 # self.node.lab_logger().trace(f"【.publish_property】发布 {self.msg_type}: {value}")
             if value is not None:
-                if self.publisher_ is None:
-                    return
-                value = self._normalize_value(value)
                 msg = convert_to_ros_msg(self.msg_type, value)
                 self.publisher_.publish(msg)
                 # self.node.lab_logger().trace(f"【.publish_property】属性 {self.name} 发布成功")
         except Exception as e:
-            topic = getattr(self.publisher_, "topic", self.name)
             self.node.lab_logger().error(
-                f"【.publish_property】发布属性 {topic} 出错: {str(e)}\n{traceback.format_exc()}"
+                f"【.publish_property】发布属性 {self.publisher_.topic} 出错: {str(e)}\n{traceback.format_exc()}"
             )
 
     def change_frequency(self, period):
@@ -1997,15 +1971,10 @@ class BaseROS2DeviceNode(Node, Generic[T]):
 
         mapped_plr_resources = []
         for uuid in uuids_list:
-            found = None
             for plr_resource in figured_resources:
                 r = self.resource_tracker.loop_find_with_uuid(plr_resource, uuid)
-                if r is not None:
+                mapped_plr_resources.append(r)
-                    found = r
                 break
-            if found is None:
-                raise Exception(f"未能在已解析的资源树中找到 uuid={uuid} 对应的资源")
-            mapped_plr_resources.append(found)
 
         return mapped_plr_resources
 

unilabos/ros/nodes/presets/host_node.py

@@ -1691,9 +1691,7 @@ class HostNode(BaseROS2DeviceNode):
         else:
             self.lab_logger().warning("⚠️ 收到无效的Pong响应（缺少ping_id）")
 
-    def notify_resource_tree_update(
+    def notify_resource_tree_update(self, device_id: str, action: str, resource_uuid_list: List[str]) -> bool:
-        self, device_id: str, action: str, resource_uuid_list: List[str]
-    ) -> Optional[bool]:
         """
         通知设备节点更新资源树
 
@@ -1703,14 +1701,13 @@ class HostNode(BaseROS2DeviceNode):
             resource_uuid_list: 资源UUIDs
 
         Returns:
-            True if the update completed, False if it failed, None if it was intentionally skipped.
+            bool: 操作是否成功
         """
         try:
+            # 检查设备是否存在
             if device_id not in self.devices_names:
-                self.lab_logger().info(
+                self.lab_logger().error(f"[Host Node-Resource] Device {device_id} not found in devices_names")
-                    f"[Host Node-Resource] 在线增加设备暂不支持，跳过设备 {device_id} 的资源树 {action} 更新"
+                return False
-                )
-                return None
 
             namespace = self.devices_names[device_id]
             device_key = f"{namespace}/{device_id}"

unilabos/utils/environment_check.py

@@ -33,83 +33,10 @@ _USE_UV: Optional[bool] = None
 def _has_uv() -> bool:
     global _USE_UV
     if _USE_UV is None:
-        uv_path = shutil.which("uv")
+        _USE_UV = shutil.which("uv") is not None
-        if not uv_path:
-            _USE_UV = False
-        else:
-            try:
-                result = subprocess.run([uv_path, "--version"], capture_output=True, text=True, timeout=10)
-                _USE_UV = result.returncode == 0
-            except Exception:
-                _USE_UV = False
     return _USE_UV
 
 
-def _install_command(installer: str, package: str, upgrade: bool, is_chinese: bool) -> List[str]:
-    if installer == "uv":
-        # uv >= 0.5 默认要求虚拟环境，对 conda env 会报 "No virtual environment found"。
-        # 显式 --python sys.executable 让 uv 把当前解释器（conda/venv/system 都行）
-        # 视为目标环境，绕开 venv 检测。
-        cmd = ["uv", "pip", "install", "--python", sys.executable]
-        if upgrade:
-            cmd.append("--upgrade")
-        cmd.append(package)
-        if is_chinese:
-            cmd.extend(["--index-url", "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"])
-        return cmd
-
-    cmd = [sys.executable, "-m", "pip", "install", "--disable-pip-version-check"]
-    if upgrade:
-        cmd.append("--upgrade")
-    cmd.append(package)
-    if is_chinese:
-        cmd.extend(["-i", "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"])
-    return cmd
-
-
-def _installer_candidates() -> List[str]:
-    installers: List[str] = []
-    if _has_uv():
-        installers.append("uv")
-    installers.append("pip")
-    return installers
-
-
-def _git_url_from_requirement(requirement: str) -> Optional[str]:
-    if not requirement.startswith("git+"):
-        return None
-    return requirement[4:].split("#", 1)[0]
-
-
-def _repo_dir_name(git_url: str) -> str:
-    repo_name = git_url.rstrip("/").rsplit("/", 1)[-1]
-    return repo_name[:-4] if repo_name.endswith(".git") else repo_name
-
-
-def _print_manual_git_install_hint(requirement: str) -> None:
-    git_url = _git_url_from_requirement(requirement)
-    if not git_url:
-        return
-
-    repo_dir = _repo_dir_name(git_url)
-    install_cmd = (
-        f'uv pip install --python "{sys.executable}" -e .'
-        if _has_uv()
-        else f"{sys.executable} -m pip install -e ."
-    )
-    if _is_chinese_locale() and not _has_uv():
-        install_cmd += " -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
-
-    print_status("Git 依赖自动安装失败，通常是网络连接被重置或代码托管站点暂时不可达。", "warning")
-    print_status("可以手动拉取代码后在本地安装:", "warning")
-    print_status(f"  git clone {git_url}", "warning")
-    print_status(f"  cd {repo_dir}", "warning")
-    print_status("  git pull", "warning")
-    print_status(f"  {install_cmd}", "warning")
-    print_status(f"如果目录 {repo_dir} 已存在，直接进入该目录执行 git pull 后再安装。", "warning")
-    print_status("如果 git clone 仍失败，请切换网络/代理，或从浏览器下载源码后进入源码目录执行本地安装命令。", "warning")
-
-
 def _install_packages(
     packages: List[str],
     upgrade: bool = False,
@@ -126,7 +53,7 @@ def _install_packages(
         return True
 
     is_chinese = _is_chinese_locale()
-    installers = _installer_candidates()
+    use_uv = _has_uv()
     failed: List[str] = []
 
     for pkg in packages:
@@ -136,30 +63,35 @@ def _install_packages(
         else:
             print_status(f"正在{action_word} {pkg}...", "info")
 
-        pkg_installed = False
+        if use_uv:
-        last_error = "unknown error"
+            cmd = ["uv", "pip", "install"]
+            if upgrade:
+                cmd.append("--upgrade")
+            cmd.append(pkg)
+            if is_chinese:
+                cmd.extend(["--index-url", "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"])
+        else:
+            cmd = [sys.executable, "-m", "pip", "install"]
+            if upgrade:
+                cmd.append("--upgrade")
+            cmd.append(pkg)
+            if is_chinese:
+                cmd.extend(["-i", "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"])
 
-        for installer in installers:
-            cmd = _install_command(installer, pkg, upgrade, is_chinese)
         try:
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
             if result.returncode == 0:
+                installer = "uv" if use_uv else "pip"
                 print_status(f"✓ {pkg} {action_word}成功 (via {installer})", "success")
-                    pkg_installed = True
+            else:
-                    break
+                stderr_short = result.stderr.strip().split("\n")[-1] if result.stderr else "unknown error"
-
+                print_status(f"× {pkg} {action_word}失败: {stderr_short}", "error")
-                last_error = result.stderr.strip().split("\n")[-1] if result.stderr else "unknown error"
+                failed.append(pkg)
-                print_status(f"× {pkg} {action_word}失败 (via {installer}): {last_error}", "warning")
         except subprocess.TimeoutExpired:
-                last_error = "timeout after 300s"
+            print_status(f"× {pkg} {action_word}超时 (300s)", "error")
-                print_status(f"× {pkg} {action_word}超时 (via {installer}, 300s)", "warning")
+            failed.append(pkg)
         except Exception as e:
-                last_error = str(e)
+            print_status(f"× {pkg} {action_word}异常: {e}", "error")
-                print_status(f"× {pkg} {action_word}异常 (via {installer}): {e}", "warning")
-
-        if not pkg_installed:
-            print_status(f"× {pkg} {action_word}失败: {last_error}", "error")
-            _print_manual_git_install_hint(pkg)
             failed.append(pkg)
 
     if failed:
@@ -256,13 +188,7 @@ class EnvironmentChecker:
             "crcmod": "crcmod-plus",
         }
 
-        # 中文 locale 下走 Gitee 镜像，规避 GitHub 拉取失败
+        self.special_packages = {"pylabrobot": "git+https://github.com/Xuwznln/pylabrobot.git"}
-        pylabrobot_url = (
-            "git+https://gitee.com/xuwznln/pylabrobot.git"
-            if _is_chinese_locale()
-            else "git+https://github.com/Xuwznln/pylabrobot.git"
-        )
-        self.special_packages = {"pylabrobot": pylabrobot_url}
 
         self.version_requirements = {
             "msgcenterpy": "0.1.8",

unilabos/utils/import_manager.py

@@ -206,7 +206,6 @@ class ImportManager:
             "ast_analysis_success": False,
             "import_map": {},
             "init_params": [],
-            "init_docstring": None,
             "status_methods": {},
             "action_methods": {},
         }
@@ -252,7 +251,6 @@ class ImportManager:
 
         # 映射到统一字段名（与 registry.py complete_registry 消费端一致）
         result["init_params"] = body.get("init_params", [])
-        result["init_docstring"] = body.get("init_docstring")
         result["status_methods"] = body.get("status_properties", {})
         result["action_methods"] = {
             k: {

unilabos/workflow/from_python_script.py

@@ -1,241 +0,0 @@
-import ast
-import json
-from typing import Dict, List, Any, Tuple, Optional
-
-from .common import WorkflowGraph, RegistryAdapter
-
-Json = Dict[str, Any]
-
-# ---------------- Converter ----------------
-
-class DeviceMethodConverter:
-    """
-    - 字段统一：resource_name（原 device_class）、template_name（原 action_key）
-    - params 单层；inputs 使用 'params.' 前缀
-    - SimpleGraph.add_workflow_node 负责变量连线与边
-    """
-    def __init__(self, device_registry: Optional[Dict[str, Any]] = None):
-        self.graph = WorkflowGraph()
-        self.variable_sources: Dict[str, Dict[str, Any]] = {}        # var -> {node_id, output_name}
-        self.instance_to_resource: Dict[str, Optional[str]] = {}     # 实例名 -> resource_name
-        self.node_id_counter: int = 0
-        self.registry = RegistryAdapter(device_registry or {})
-
-    # ---- helpers ----
-    def _new_node_id(self) -> int:
-        nid = self.node_id_counter
-        self.node_id_counter += 1
-        return nid
-
-    def _assign_targets(self, targets) -> List[str]:
-        names: List[str] = []
-        import ast
-        if isinstance(targets, ast.Tuple):
-            for elt in targets.elts:
-                if isinstance(elt, ast.Name):
-                    names.append(elt.id)
-        elif isinstance(targets, ast.Name):
-            names.append(targets.id)
-        return names
-
-    def _extract_device_instantiation(self, node) -> Optional[Tuple[str, str]]:
-        import ast
-        if not isinstance(node.value, ast.Call):
-            return None
-        callee = node.value.func
-        if isinstance(callee, ast.Name):
-            class_name = callee.id
-        elif isinstance(callee, ast.Attribute) and isinstance(callee.value, ast.Name):
-            class_name = callee.attr
-        else:
-            return None
-        if isinstance(node.targets[0], ast.Name):
-            instance = node.targets[0].id
-            return instance, class_name
-        return None
-
-    def _extract_call(self, call) -> Tuple[str, str, Dict[str, Any], str]:
-        import ast
-        owner_name, method_name, call_kind = "", "", "func"
-        if isinstance(call.func, ast.Attribute):
-            method_name = call.func.attr
-            if isinstance(call.func.value, ast.Name):
-                owner_name = call.func.value.id
-                call_kind = "instance" if owner_name in self.instance_to_resource else "class_or_module"
-            elif isinstance(call.func.value, ast.Attribute) and isinstance(call.func.value.value, ast.Name):
-                owner_name = call.func.value.attr
-                call_kind = "class_or_module"
-        elif isinstance(call.func, ast.Name):
-            method_name = call.func.id
-            call_kind = "func"
-
-        def pack(node):
-            if isinstance(node, ast.Name):
-                return {"type": "variable", "value": node.id}
-            if isinstance(node, ast.Constant):
-                return {"type": "constant", "value": node.value}
-            if isinstance(node, ast.Dict):
-                return {"type": "dict", "value": self._parse_dict(node)}
-            if isinstance(node, ast.List):
-                return {"type": "list", "value": self._parse_list(node)}
-            return {"type": "raw", "value": ast.unparse(node) if hasattr(ast, "unparse") else str(node)}
-
-        args: Dict[str, Any] = {}
-        pos: List[Any] = []
-        for a in call.args:
-            pos.append(pack(a))
-        for kw in call.keywords:
-            args[kw.arg] = pack(kw.value)
-        if pos:
-            args["_positional"] = pos
-        return owner_name, method_name, args, call_kind
-
-    def _parse_dict(self, node) -> Dict[str, Any]:
-        import ast
-        out: Dict[str, Any] = {}
-        for k, v in zip(node.keys, node.values):
-            if isinstance(k, ast.Constant):
-                key = str(k.value)
-                if isinstance(v, ast.Name):
-                    out[key] = f"var:{v.id}"
-                elif isinstance(v, ast.Constant):
-                    out[key] = v.value
-                elif isinstance(v, ast.Dict):
-                    out[key] = self._parse_dict(v)
-                elif isinstance(v, ast.List):
-                    out[key] = self._parse_list(v)
-        return out
-
-    def _parse_list(self, node) -> List[Any]:
-        import ast
-        out: List[Any] = []
-        for elt in node.elts:
-            if isinstance(elt, ast.Name):
-                out.append(f"var:{elt.id}")
-            elif isinstance(elt, ast.Constant):
-                out.append(elt.value)
-            elif isinstance(elt, ast.Dict):
-                out.append(self._parse_dict(elt))
-            elif isinstance(elt, ast.List):
-                out.append(self._parse_list(elt))
-        return out
-
-    def _normalize_var_tokens(self, x: Any) -> Any:
-        if isinstance(x, str) and x.startswith("var:"):
-            return {"__var__": x[4:]}
-        if isinstance(x, list):
-            return [self._normalize_var_tokens(i) for i in x]
-        if isinstance(x, dict):
-            return {k: self._normalize_var_tokens(v) for k, v in x.items()}
-        return x
-
-    def _make_params_payload(self, resource_name: Optional[str], template_name: str, call_args: Dict[str, Any]) -> Dict[str, Any]:
-        input_keys = self.registry.get_action_input_keys(resource_name, template_name) if resource_name else []
-        defaults = self.registry.get_action_goal_default(resource_name, template_name) if resource_name else {}
-        params: Dict[str, Any] = dict(defaults)
-
-        def unpack(p):
-            t, v = p.get("type"), p.get("value")
-            if t == "variable":
-                return {"__var__": v}
-            if t == "dict":
-                return self._normalize_var_tokens(v)
-            if t == "list":
-                return self._normalize_var_tokens(v)
-            return v
-
-        for k, p in call_args.items():
-            if k == "_positional":
-                continue
-            params[k] = unpack(p)
-
-        pos = call_args.get("_positional", [])
-        if pos:
-            if input_keys:
-                for i, p in enumerate(pos):
-                    if i >= len(input_keys):
-                        break
-                    name = input_keys[i]
-                    if name in params:
-                        continue
-                    params[name] = unpack(p)
-            else:
-                for i, p in enumerate(pos):
-                    params[f"arg_{i}"] = unpack(p)
-        return params
-
-    # ---- handlers ----
-    def _on_assign(self, stmt):
-        import ast
-        inst = self._extract_device_instantiation(stmt)
-        if inst:
-            instance, code_class = inst
-            resource_name = self.registry.resolve_resource_by_classname(code_class)
-            self.instance_to_resource[instance] = resource_name
-            return
-
-        if isinstance(stmt.value, ast.Call):
-            owner, method, call_args, kind = self._extract_call(stmt.value)
-            if kind == "instance":
-                device_key = owner
-                resource_name = self.instance_to_resource.get(owner)
-            else:
-                device_key = owner
-                resource_name = self.registry.resolve_resource_by_classname(owner)
-
-            module = self.registry.get_device_module(resource_name)
-            params = self._make_params_payload(resource_name, method, call_args)
-
-            nid = self._new_node_id()
-            self.graph.add_workflow_node(
-                nid,
-                device_key=device_key,
-                resource_name=resource_name,      # ✅
-                module=module,
-                template_name=method,             # ✅
-                params=params,
-                variable_sources=self.variable_sources,
-                add_ready_if_no_vars=True,
-                prev_node_id=(nid - 1) if nid > 0 else None,
-            )
-
-            out_vars = self._assign_targets(stmt.targets[0])
-            for var in out_vars:
-                self.variable_sources[var] = {"node_id": nid, "output_name": "result"}
-
-    def _on_expr(self, stmt):
-        import ast
-        if not isinstance(stmt.value, ast.Call):
-            return
-        owner, method, call_args, kind = self._extract_call(stmt.value)
-        if kind == "instance":
-            device_key = owner
-            resource_name = self.instance_to_resource.get(owner)
-        else:
-            device_key = owner
-            resource_name = self.registry.resolve_resource_by_classname(owner)
-
-        module = self.registry.get_device_module(resource_name)
-        params = self._make_params_payload(resource_name, method, call_args)
-
-        nid = self._new_node_id()
-        self.graph.add_workflow_node(
-            nid,
-            device_key=device_key,
-            resource_name=resource_name,      # ✅
-            module=module,
-            template_name=method,             # ✅
-            params=params,
-            variable_sources=self.variable_sources,
-            add_ready_if_no_vars=True,
-            prev_node_id=(nid - 1) if nid > 0 else None,
-        )
-
-    def convert(self, python_code: str):
-        tree = ast.parse(python_code)
-        for stmt in tree.body:
-            if isinstance(stmt, ast.Assign):
-                self._on_assign(stmt)
-            elif isinstance(stmt, ast.Expr):
-                self._on_expr(stmt)
-        return self

unilabos/workflow/from_xdl.py

@@ -1,131 +0,0 @@
-from typing import List, Any, Dict
-import xml.etree.ElementTree as ET
-
-
-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 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)}"
-        return {"error": error_msg, "success": False}

unilabos_msgs/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="3">
   <name>unilabos_msgs</name>
-  <version>0.11.3</version>
+  <version>0.11.0</version>
   <description>ROS2 Messages package for unilabos devices</description>
   <maintainer email="changjh@pku.edu.cn">Junhan Chang</maintainer>
   <maintainer email="18435084+Xuwznln@users.noreply.github.com">Xuwznln</maintainer>