ci(deps): bump actions/upload-pages-artifact from 4 to 5

Bumps [actions/upload-pages-artifact](https://github.com/actions/upload-pages-artifact) from 4 to 5.
- [Release notes](https://github.com/actions/upload-pages-artifact/releases)
- [Commits](https://github.com/actions/upload-pages-artifact/compare/v4...v5)

---
updated-dependencies:
- dependency-name: actions/upload-pages-artifact
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

.conda/base/recipe.yaml

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

.conda/environment/recipe.yaml

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

.conda/full/recipe.yaml

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

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

@@ -71,22 +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=""`，但新设备应优先写清楚显示名和说明。
-
 ### @topic_config — 状态属性配置
 
 ```python
@@ -121,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(
-    id="my_device",
-    category=["my_category"],
-    description="设备描述",
-    display_name="设备显示名",
-)
+@device(id="my_device", category=["my_category"], description="设备描述")
 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}")
@@ -163,13 +133,7 @@ class MyDevice:
 
     @action(description="执行操作")
     def my_action(self, param: float = 0.0, name: str = "") -> Dict[str, Any]:
-        """
-        带 @action 装饰器 → 注册为 'my_action' 动作。
-
-        Args:
-            param[操作数值]: 操作使用的数值参数。
-            name[操作名称]: 操作名称或备注。
-        """
+        """带 @action 装饰器 → 注册为 'my_action' 动作"""
         return {"success": True}
 
     def get_info(self) -> Dict[str, Any]:

.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()

.github/workflows/ci-check.yml

@@ -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:
@@ -68,9 +54,7 @@ jobs:
         id: should_build
         shell: bash
         run: |
-          if [[ "${{ github.event_name }}" != "workflow_dispatch" ]]; then
-            echo "should_build=true" >> $GITHUB_OUTPUT
-          elif [[ -z "${{ github.event.inputs.platforms }}" ]]; then
+          if [[ -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,7 +65,7 @@ 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)
@@ -91,7 +75,7 @@ jobs:
           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 }}
-          if "${{ env.BUILD_FULL }}"=="true" (
+          echo Build full: ${{ github.event.inputs.build_full }}
+          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 }}"
-          if [[ "${{ env.BUILD_FULL }}" == "true" ]]; then
+          echo "Build full: ${{ github.event.inputs.build_full }}"
+          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"
-          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
+          mamba activate unilab && conda pack -n unilab -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"])')"
-          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
+          mamba install conda-pack -c conda-forge -y
+          conda pack -n unilab -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

@@ -56,7 +56,7 @@ jobs:
           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: |
@@ -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@v4
+        uses: actions/upload-pages-artifact@v5
         if: |
           github.event.workflow_run.head_branch == 'main' ||
           (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')

.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:
@@ -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,13 +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@v3
         with:
-          miniforge-version: latest
-          use-mamba: true
-          channels: conda-forge,robostack-staging
+          miniconda-version: 'latest'
+          channels: conda-forge,robostack-staging,defaults
           channel-priority: strict
           activate-environment: build-env
           auto-update-conda: false
@@ -114,7 +110,7 @@ jobs:
       - name: Install rattler-build and anaconda-client
         if: steps.should_build.outputs.should_build == 'true'
         run: |
-          mamba install --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'
@@ -161,13 +157,7 @@ jobs:
           retention-days: 30
 
       - name: Upload to Anaconda.org (unilab organization)
-        if: |
-          steps.should_build.outputs.should_build == 'true' &&
-          (
-            github.event_name == 'release' ||
-            startsWith(github.ref, 'refs/tags/') ||
-            github.event.inputs.upload_to_anaconda == 'true'
-          )
+        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
         run: |
           for package in $(find ./output -name "*.conda"); do
             echo "Uploading $package to unilab organization..."

.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,30 +33,30 @@ on:
         type: boolean
 
 jobs:
-  # 等待上游 msgs 构建完成的 job (仅用于 workflow_run 触发)
-  wait-for-upstream:
+  # 等待 CI Check 完成的 job (仅用于 workflow_run 触发)
+  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]
-    # 运行条件：workflow_run 触发且上游成功，或者手动触发
+    needs: [wait-for-ci]
+    # 运行条件：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:
@@ -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,13 +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@v3
         with:
-          miniforge-version: latest
-          use-mamba: true
-          channels: conda-forge,robostack-staging,uni-lab
+          miniconda-version: 'latest'
+          channels: conda-forge,robostack-staging,uni-lab,defaults
           channel-priority: strict
           activate-environment: build-env
           auto-update-conda: false
@@ -107,7 +110,7 @@ jobs:
       - name: Install rattler-build and anaconda-client
         if: steps.should_build.outputs.should_build == 'true'
         run: |
-          mamba install --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'
@@ -116,11 +119,11 @@ jobs:
           conda list | grep -E "(rattler-build|anaconda-client)"
           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,12 +134,7 @@ jobs:
           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: |
-          steps.should_build.outputs.should_build == 'true' &&
-          (
-            github.event_name == 'workflow_run' ||
-            github.event.inputs.upload_to_anaconda == 'true'
-          )
+        if: steps.should_build.outputs.should_build == 'true' && 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
@@ -151,12 +149,7 @@ jobs:
           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: |
-          steps.should_build.outputs.should_build == 'true' &&
-          (
-            github.event_name == 'workflow_run' ||
-            github.event.inputs.upload_to_anaconda == 'true'
-          )
+        if: steps.should_build.outputs.should_build == 'true' && 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
@@ -166,7 +159,6 @@ jobs:
       - 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 }}..."
@@ -175,7 +167,6 @@ jobs:
       - 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: |

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.2
+  version: 0.10.19
 source:
   path: ../../unilabos_msgs
   target_directory: src

recipes/unilabos/recipe.yaml

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

scripts/workflow.py

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

setup.py

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

unilabos/__init__.py

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

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/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 加载。
-
-    背景：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 同时打印明显的重启提示，避免用户被后续报错淹没。
-    """
+    """在 Windows + conda 环境下为 rclpy 打 DLL 加载补丁"""
     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")
-    site_packages = os.path.join(cp, "Lib", "site-packages")
-    if not os.path.isdir(lib_bin):
+    impl = os.path.join(cp, "Lib", "site-packages", "rclpy", "impl", "implementation_singleton.py")
+    pyd = glob.glob(os.path.join(cp, "Lib", "site-packages", "rclpy", "_rclpy_pybind11*.pyd"))
+    if not os.path.exists(impl) or not pyd:
         return
-
-    patched = []
-
-    # 1) rclpy 自身的入口
-    rclpy_impl = os.path.join(site_packages, "rclpy", "impl", "implementation_singleton.py")
-    rclpy_pyd_matches = glob.glob(os.path.join(site_packages, "rclpy", "_rclpy_pybind11*.pyd"))
-    rclpy_pyd = rclpy_pyd_matches[0] if rclpy_pyd_matches else ""
-    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)
+    with open(impl, "r", encoding="utf-8") as f:
+        content = f.read()
+    lib_bin = os.path.join(cp, "Library", "bin").replace("\\", "/")
+    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'
+    shutil.copy2(impl, impl + ".bak")
+    with open(impl, "w", encoding="utf-8") as f:
+        f.write(patch + content)
 
 
 patch_rclpy_dll_windows()

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
-    @topic_config()
-    def current_port(self) -> str:
-        """当前连接的端口名称 🔌"""
-        return self.port
+    def get_current_position(self) -> int:
+        """获取当前阀门位置 📍"""
+        return self._current_position
+
+    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
-    @topic_config()
-    def valve_position(self) -> int:
-        """阀门位置 📍"""
+    def get_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
-    @topic_config()
-    def flow_path(self) -> str:
-        """当前流路路径描述 🌊"""
+    def get_flow_path(self) -> str:
+        """获取当前流路路径描述 🌊"""
+        current_port = self.get_current_port()
         if self._current_position == 0:
-            return f"🚰 转移泵已连接 (位置 {self._current_position})"
-        return f"🔌 端口 {self._current_position} 已连接 ({self.current_port})"
+            flow_path = f"🚰 转移泵已连接 (位置 {self._current_position})"
+        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
-    @topic_config()
-    def device_info(self) -> Dict[str, Any]:
-        """设备状态快照信息 📊"""
-        return {
+    def get_device_info(self) -> Dict[str, Any]:
+        """获取设备状态信息 📊"""
+        info = {
             "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
-    @topic_config()
-    def remaining_capacity(self) -> float:
-        """剩余容量 (ml)"""
+    def get_remaining_capacity(self) -> float:
+        """获取剩余容量"""
         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,
-    ActionOutputHandle,
-    DataSource,
-    NodeType,
-    action,
-    device,
-    not_action,
-    topic_config,
+    device, action, ActionInputHandle, ActionOutputHandle, DataSource, topic_config, not_action, NodeType
 )
 from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, ROS2DeviceNode
-from unilabos.resources.resource_tracker import (
-    SampleUUIDsType,
-    LabSample,
-    ResourceTreeSet,
-)
+from unilabos.resources.resource_tracker import 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__(
-        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。
-        """
+    def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
         # 处理可能的不同调用方式
         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.config.get("arm_operation_time", self.ARM_OPERATION_TIME)
-        )
+        self.ARM_OPERATION_TIME = float(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.config.get("num_heating_stations", self.NUM_HEATING_STATIONS)
-        )
+        self.NUM_HEATING_STATIONS = int(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)
-            for i in range(1, self.NUM_HEATING_STATIONS + 1)
+            i: HeatingStation(station_id=i) 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,
-        node_type=NodeType.MANUAL_CONFIRM,
-        placeholder_keys={"assignee_user_ids": "unilabos_manual_confirm"},
-        goal_default={"timeout_seconds": 3600, "assignee_user_ids": []},
-        feedback_interval=300,
+        always_free=True, node_type=NodeType.MANUAL_CONFIRM, placeholder_keys={
+            "assignee_user_ids": "unilabos_manual_confirm"
+        }, goal_default={
+            "timeout_seconds": 3600,
+            "assignee_user_ids": []
+        }, feedback_interval=300,
         handles=[
-            ActionInputHandle(
-                key="target_device",
-                data_type="device_id",
-                label="目标设备",
-                data_key="target_device",
-                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,
-            ),
-            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,
-            ),
+            ActionInputHandle(key="target_device", data_type="device_id",
+                              label="目标设备", data_key="target_device", 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),
+
+            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(
-                key="target_device",
-                data_type="device_id",
-                label="目标设备",
-                data_key="target_device",
-                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,
-            ),
+            ActionOutputHandle(key="target_device", data_type="device_id",
+                               label="目标设备", data_key="target_device", 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(
-                key="collector_mass",
-                data_type="collector_mass",
-                label="极流体质量",
-                data_key="collector_mass",
-                data_source=DataSource.EXECUTOR,
-            ),
-            ActionOutputHandle(
-                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,
-            ),
-        ],
+            ActionOutputHandle(key="collector_mass", data_type="collector_mass",
+                              label="极流体质量", data_key="collector_mass", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(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:
         """
-        人工确认资源转移和扣电测试参数。
-
-        Args:
-            resource[待转移资源]: 需要人工确认的资源列表。
-            target_device[目标设备]: 资源要转移到的目标设备 ID。
-            mount_resource[目标孔位]: 资源要挂载到的目标孔位列表。
-            collector_mass[极流体质量]: 每个样品对应的极流体质量。
-            active_material[活性物质含量]: 每个样品对应的活性物质含量。
-            capacity[克容量]: 每个样品对应的克容量，单位 mAh/g。
-            battery_system[电池体系]: 每个样品对应的电池体系名称。
-            timeout_seconds[超时时间]: 人工确认超时时间，单位秒。
-            assignee_user_ids[确认人]: 指定处理人工确认任务的用户 ID 列表。
-
-        Note:
-            修改的结果无效，是只读的。
+        timeout_seconds: 超时时间（秒），默认3600秒
+        collector_mass: 极流体质量
+        active_material: 活性物质含量
+        capacity: 克容量（mAh/g）
+        battery_system: 电池体系
+        修改的结果无效，是只读的
         """
-        resource_tree = ResourceTreeSet.from_plr_resources(cast(Any, resource)).dump()
-        mount_resource_tree = ResourceTreeSet.from_plr_resources(cast(Any, mount_resource)).dump()
+        resource = ResourceTreeSet.from_plr_resources(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(
-                key="target_device",
-                data_type="device_id",
-                label="目标设备",
-                data_key="target_device",
-                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,
-            ),
-        ],
+            ActionInputHandle(key="target_device", data_type="device_id",
+                              label="目标设备", data_key="target_device", 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(
-        self,
-        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,
+    async def transfer(self, resource: List[ResourceSlot], target_device: DeviceSlot, mount_resource: List[ResourceSlot]):
+        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(
-                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,
-            ),
-            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,
-            ),
-        ],
+            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),
+
+            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,
-        resource: List[ResourceSlot],
-        mount_resource: List[ResourceSlot],
-        collector_mass: List[float],
-        active_material: List[float],
-        capacity: List[float],
-        battery_system: list[str],
+        self, 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_2", data_type="workbench_material", label="实验2", data_key="material_2", data_source=DataSource.EXECUTOR),  # noqa: E501
-            ActionOutputHandle(key="channel_3", data_type="workbench_material", label="实验3", data_key="material_3", data_source=DataSource.EXECUTOR),  # noqa: E501
-            ActionOutputHandle(key="channel_4", data_type="workbench_material", label="实验4", data_key="material_4", data_source=DataSource.EXECUTOR),  # noqa: E501
-            ActionOutputHandle(key="channel_5", data_type="workbench_material", label="实验5", data_key="material_5", data_source=DataSource.EXECUTOR),  # noqa: E501
+            ActionOutputHandle(key="channel_1", data_type="workbench_material",
+                         label="实验1", data_key="material_1", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="channel_2", data_type="workbench_material",
+                         label="实验2", data_key="material_2", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="channel_3", data_type="workbench_material",
+                         label="实验3", data_key="material_3", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="channel_4", data_type="workbench_material",
+                         label="实验4", data_key="material_4", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="channel_5", data_type="workbench_material",
+                         label="实验5", data_key="material_5", data_source=DataSource.EXECUTOR),
         ],
     )
     def prepare_materials(
@@ -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=(
-                        {"material_uuid": content}
-                        if isinstance(content, str)
-                        else (content.serialize() if content else {})
-                    ),
+                    extra={"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(
-                key="material_input",
-                data_type="workbench_material",
-                label="物料编号",
-                data_key="material_number",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionOutputHandle(
-                key="heating_station_output",
-                data_type="workbench_station",
-                label="加热台ID",
-                data_key="station_id",
-                data_source=DataSource.EXECUTOR,
-            ),
-            ActionOutputHandle(
-                key="material_number_output",
-                data_type="workbench_material",
-                label="物料编号",
-                data_key="material_number",
-                data_source=DataSource.EXECUTOR,
-            ),
+            ActionInputHandle(key="material_input", data_type="workbench_material",
+                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
+            ActionOutputHandle(key="heating_station_output", data_type="workbench_station",
+                         label="加热台ID", data_key="station_id", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="material_number_output", data_type="workbench_material",
+                         label="物料编号", data_key="material_number", data_source=DataSource.EXECUTOR),
         ],
     )
     def move_to_heating_station(
@@ -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)
-                            else (content.serialize() if content else {})
+                            if isinstance(content, str) 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)
-                            else (content.serialize() if content else {})
+                            if isinstance(content, str) 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(
-                key="station_id_input",
-                data_type="workbench_station",
-                label="加热台ID",
-                data_key="station_id",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="material_number_input",
-                data_type="workbench_material",
-                label="物料编号",
-                data_key="material_number",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionOutputHandle(
-                key="heating_done_station",
-                data_type="workbench_station",
-                label="加热完成-加热台ID",
-                data_key="station_id",
-                data_source=DataSource.EXECUTOR,
-            ),
-            ActionOutputHandle(
-                key="heating_done_material",
-                data_type="workbench_material",
-                label="加热完成-物料编号",
-                data_key="material_number",
-                data_source=DataSource.EXECUTOR,
-            ),
+            ActionInputHandle(key="station_id_input", data_type="workbench_station",
+                        label="加热台ID", data_key="station_id", data_source=DataSource.HANDLE),
+            ActionInputHandle(key="material_number_input", data_type="workbench_material",
+                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
+            ActionOutputHandle(key="heating_done_station", data_type="workbench_station",
+                         label="加热完成-加热台ID", data_key="station_id", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="heating_done_material", data_type="workbench_material",
+                         label="加热完成-物料编号", data_key="material_number", data_source=DataSource.EXECUTOR),
         ],
     )
     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)
-                            else (content.serialize() if content else {})
+                            if isinstance(content, str) 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)
-                                else (content.serialize() if content else {})
+                                if isinstance(content, str) 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)
-                                else (content.serialize() if content else {})
+                                if isinstance(content, str) 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(
-                    f"[加热台{station_id}] {material_id} 剩余 {remaining:.1f}s"
-                )
+                self.logger.info(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(
-            f"[加热台{station_id}] {material_id}加热完成 (用时{self.HEATING_TIME}s)"
-        )
+        self.logger.info(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)
-                        else (content.serialize() if content else {})
+                        if isinstance(content, str) 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(
-                key="output_station_input",
-                data_type="workbench_station",
-                label="加热台ID",
-                data_key="station_id",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="output_material_input",
-                data_type="workbench_material",
-                label="物料编号",
-                data_key="material_number",
-                data_source=DataSource.HANDLE,
-            ),
+            ActionInputHandle(key="output_station_input", data_type="workbench_station",
+                        label="加热台ID", data_key="station_id", data_source=DataSource.HANDLE),
+            ActionInputHandle(key="output_material_input", data_type="workbench_material",
+                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
         ],
     )
     def move_to_output(
@@ -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)
-                            else (content.serialize() if content else {})
+                            if isinstance(content, str) 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)
-                                else (content.serialize() if content else {})
+                                if isinstance(content, str) 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)
-                                else (content.serialize() if content else {})
+                                if isinstance(content, str) 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)
-                            else (content.serialize() if content else {})
+                            if isinstance(content, str) 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: '是否启用物料搜寻功能。
-
-                    设备初始化后会弹出物料搜寻确认弹窗，
-
-                    此参数控制自动点击''是''（启用）或''否''（不启用）。
-
-                    默认为False（不启用物料搜寻）。'
+                  description: 是否启用物料搜寻功能。设备初始化后会弹出物料搜寻确认弹窗，此参数控制自动点击"是"(启用)或"否"(不启用)。默认为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 = (
-                normalize_ast_action_handles(raw_handles)
-                if isinstance(raw_handles, list)
-                else (raw_handles or {})
-            )
+            handles = 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(
-                    goal_schema,
-                    action_name,
-                    description=(action_args or {}).get("description") or method_doc_info.get("description", ""),
-                    result_schema=result_schema,
-                ),
+                "schema": wrap_action_schema(goal_schema, action_name, 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 = (
-                normalize_ast_action_handles(raw_handles)
-                if isinstance(raw_handles, list)
-                else (raw_handles or {})
-            )
+            handles = 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": {
-                    **detect_placeholder_keys(method_params),
-                    **(action_args.get("placeholder_keys") or {}),
-                },
+                "placeholder_keys": {**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(
-            init_params, "__init__", ast_meta.get("init_docstring"), import_map=imap
-        )
+        config_schema = self._generate_schema_from_ast_params(init_params, "__init__", 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,
-                            description=doc_info.get("description", ""),
-                            result_schema=result_schema,
-                        )
+                        new_schema = wrap_action_schema(goal_schema, action_key, 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"],
-                        docstring=enhanced_info.get("init_docstring"),
+                        enhanced_info["init_params"], "__init__",
                         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(
-                                        target_type.Goal()
-                                    ).get_python_dict()
+                                    action_config["goal_default"] = ROS2MessageInstance(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(
-    registry_paths=None,
-    devices_dirs=None,
-    upload_registry=False,
-    check_mode=False,
-    complete_registry=False,
-    external_only=False,
-):
+def build_registry(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(
-        devices_dirs=devices_dirs,
-        upload_registry=upload_registry,
-        complete_registry=complete_registry,
-        external_only=external_only,
-    )
+    lab_registry.setup(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 ``Args:`` / ``Parameters:`` 小节
-      - 直接参数行 ``field: desc``
-      - 带显示名参数行 ``field[Display Name]: desc``
+    解析 Google-style docstring，提取描述和参数说明。
 
     Returns:
-        {
-            "description": "短描述",
-            "params": {"param1": "参数1描述", ...},
-            "param_display_names": {"param1": "显示名", ...},
-        }
+        {"description": "短描述", "params": {"param1": "参数1描述", ...}}
     """
-    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:
-        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:]:
+    for line in lines[1:]:
         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()
-            current_section = section_match.group(1).lower()
-            in_args = current_section in ("args", "arguments", "parameters", "params")
+            if current_param is not None:
+                result["params"][current_param] = "\n".join(current_desc_parts).strip()
+                current_param = None
+                current_desc_parts = []
+            section_name = section_match.group(1).lower()
+            in_args = section_name in ("args", "arguments", "parameters", "params")
             continue
 
-        parse_as_param = in_args or current_section is None
-        if not parse_as_param:
+        if not in_args:
             continue
 
-        if ":" in stripped:
-            flush_current_param()
+        if ":" in stripped and not stripped.startswith(" "):
+            if current_param is not None:
+                result["params"][current_param] = "\n".join(current_desc_parts).strip()
             param_part, _, desc_part = stripped.partition(":")
-            param_name, 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

@@ -1971,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:
-                    found = r
-                    break
-            if found is None:
-                raise Exception(f"未能在已解析的资源树中找到 uuid={uuid} 对应的资源")
-            mapped_plr_resources.append(found)
+                mapped_plr_resources.append(r)
+                break
 
         return mapped_plr_resources
 

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")
-        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
+        _USE_UV = shutil.which("uv") is not None
     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
-        last_error = "unknown error"
+        if use_uv:
+            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:
-                    print_status(f"✓ {pkg} {action_word}成功 (via {installer})", "success")
-                    pkg_installed = True
-                    break
-
-                last_error = result.stderr.strip().split("\n")[-1] if result.stderr else "unknown error"
-                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}超时 (via {installer}, 300s)", "warning")
-            except Exception as e:
-                last_error = str(e)
-                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)
+        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")
+            else:
+                stderr_short = result.stderr.strip().split("\n")[-1] if result.stderr else "unknown error"
+                print_status(f"× {pkg} {action_word}失败: {stderr_short}", "error")
+                failed.append(pkg)
+        except subprocess.TimeoutExpired:
+            print_status(f"× {pkg} {action_word}超时 (300s)", "error")
+            failed.append(pkg)
+        except Exception as e:
+            print_status(f"× {pkg} {action_word}异常: {e}", "error")
             failed.append(pkg)
 
     if failed:
@@ -256,13 +188,7 @@ class EnvironmentChecker:
             "crcmod": "crcmod-plus",
         }
 
-        # 中文 locale 下走 Gitee 镜像，规避 GitHub 拉取失败
-        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.special_packages = {"pylabrobot": "git+https://github.com/Xuwznln/pylabrobot.git"}
 
         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

@@ -0,0 +1,241 @@
+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

@@ -0,0 +1,131 @@
+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.2</version>
+  <version>0.10.19</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>