v0.11.0

update workbench example
update aksk desc print res query logs Fix skills exec error with action type Update Skills Update Skills addr Change uni-lab. to leap-lab. Support unit in pylabrobot Support async func. change to leap-lab backend. Support feedback interval. Reduce cocurrent lags. fix create_resource_with_slot update unilabos_formulation & batch-submit-exp scale multi exec thread up to 48 update handle creation api fit cocurrent gap add running status debounce allow non @topic_config support update skill add placeholder keys always free 提交实验技能 disable samples correct sample demo ret value 新增试剂reagent update registry 新增manual_confirm add workstation creation skill add virtual_sample_demo 样品追踪测试设备 add external devices param fix registry upload missing type fast registry load minor fix on skill & registry stripe ros2 schema desc add create-device-skill new registry system backwards to yaml remove not exist resource new registry sys exp. support with add device correct raise create resource error ret info fix revert ret info fix fix prcxi check add create_resource schema re signal host ready event add websocket connection timeout and improve reconnection logic add open_timeout parameter to websocket connection add TimeoutError and InvalidStatus exception handling implement exponential backoff for reconnection attempts simplify reconnection logic flow
2026-04-24 03:29:55 +00:00 · 2026-04-16 01:35:01 +08:00 · 2026-04-16 01:33:36 +08:00 · 2026-03-22 04:25:07 +08:00 · 2026-03-03 18:03:53 +08:00 · 2026-03-03 17:20:06 +08:00
103 changed files with 8726 additions and 5540 deletions
--- a/.conda/base/recipe.yaml
+++ b/.conda/base/recipe.yaml
@@ -3,7 +3,7 @@

 package:
  name: unilabos
-  version: 0.10.19
+  version: 0.11.0

 source:
  path: ../../unilabos
@@ -54,7 +54,7 @@ requirements:
  - pymodbus
  - matplotlib
  - pylibftdi
-  - uni-lab::unilabos-env ==0.10.19
+  - uni-lab::unilabos-env ==0.11.0

 about:
  repository: https://github.com/deepmodeling/Uni-Lab-OS
--- a/.conda/environment/recipe.yaml
+++ b/.conda/environment/recipe.yaml
@@ -2,7 +2,7 @@

 package:
  name: unilabos-env
-  version: 0.10.19
+  version: 0.11.0

 build:
  noarch: generic
--- a/.conda/full/recipe.yaml
+++ b/.conda/full/recipe.yaml
@@ -3,7 +3,7 @@

 package:
  name: unilabos-full
-  version: 0.10.19
+  version: 0.11.0

 build:
  noarch: generic
@@ -11,7 +11,7 @@ build:
 requirements:
  run:
  # Base unilabos package (includes unilabos-env)
-  - uni-lab::unilabos ==0.10.19
+  - uni-lab::unilabos ==0.11.0
  # Documentation tools
  - sphinx
  - sphinx_rtd_theme
--- a/.cursor/skills/batch-insert-reagent/SKILL.md
+++ b/.cursor/skills/batch-insert-reagent/SKILL.md
@@ -27,14 +27,15 @@ python -c "import base64,sys; print('Authorization: Lab ' + base64.b64encode(f'{

 ### 2. --addr → BASE URL

-| `--addr` 值 | BASE |
-|-------------|------|
-| `test` | `https://uni-lab.test.bohrium.com` |
-| `uat` | `https://uni-lab.uat.bohrium.com` |
-| `local` | `http://127.0.0.1:48197` |
-| 不传（默认） | `https://uni-lab.bohrium.com` |
+| `--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 <gen_auth.py 输出的 token>"
@@ -65,7 +66,7 @@ curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
 返回：

 ```json
-{"code": 0, "data": {"uuid": "xxx", "name": "实验室名称"}}
+{ "code": 0, "data": { "uuid": "xxx", "name": "实验室名称" } }
 ```

 记住 `data.uuid` 为 `lab_uuid`。
@@ -90,6 +91,7 @@ curl -s -X POST "$BASE/api/v1/lab/reagent" \
 ```

 返回成功时包含试剂 UUID：
+
 ```json
 {"code": 0, "data": {"uuid": "xxx", ...}}
 ```
@@ -98,28 +100,28 @@ curl -s -X POST "$BASE/api/v1/lab/reagent" \

 ## 试剂字段说明

-| 字段 | 类型 | 必填 | 说明 | 示例 |
-|------|------|------|------|------|
-| `lab_uuid` | string | 是 | 实验室 UUID（从 API #1 获取） | `"8511c672-..."` |
-| `cas` | string | 是 | CAS 注册号 | `"7732-18-3"` |
-| `name` | string | 是 | 试剂中文/英文名称 | `"水"` |
-| `molecular_formula` | string | 是 | 分子式 | `"H2O"` |
-| `smiles` | string | 是 | SMILES 表示 | `"O"` |
-| `stock_in_quantity` | number | 是 | 入库数量 | `10` |
-| `unit` | string | 是 | 单位（字符串，见下表） | `"mL"` |
-| `supplier` | string | 否 | 供应商名称 | `"国药集团"` |
-| `production_date` | string | 否 | 生产日期（ISO 8601） | `"2025-11-18T00:00:00Z"` |
-| `expiry_date` | string | 否 | 过期日期（ISO 8601） | `"2026-11-18T00:00:00Z"` |
+| 字段                | 类型   | 必填 | 说明                          | 示例                     |
+| ------------------- | ------ | ---- | ----------------------------- | ------------------------ |
+| `lab_uuid`          | string | 是   | 实验室 UUID（从 API #1 获取） | `"8511c672-..."`         |
+| `cas`               | string | 是   | CAS 注册号                    | `"7732-18-3"`            |
+| `name`              | string | 是   | 试剂中文/英文名称             | `"水"`                   |
+| `molecular_formula` | string | 是   | 分子式                        | `"H2O"`                  |
+| `smiles`            | string | 是   | SMILES 表示                   | `"O"`                    |
+| `stock_in_quantity` | number | 是   | 入库数量                      | `10`                     |
+| `unit`              | string | 是   | 单位（字符串，见下表）        | `"mL"`                   |
+| `supplier`          | string | 否   | 供应商名称                    | `"国药集团"`             |
+| `production_date`   | string | 否   | 生产日期（ISO 8601）          | `"2025-11-18T00:00:00Z"` |
+| `expiry_date`       | string | 否   | 过期日期（ISO 8601）          | `"2026-11-18T00:00:00Z"` |

 ### unit 单位值

-| 值 | 单位 |
-|------|------|
+| 值     | 单位 |
+| ------ | ---- |
 | `"mL"` | 毫升 |
-| `"L"` | 升 |
-| `"g"` | 克 |
+| `"L"`  | 升   |
+| `"g"`  | 克   |
 | `"kg"` | 千克 |
-| `"瓶"` | 瓶 |
+| `"瓶"` | 瓶   |

 > 根据试剂状态选择：液体用 `"mL"` / `"L"`，固体用 `"g"` / `"kg"`。

@@ -133,8 +135,22 @@ curl -s -X POST "$BASE/api/v1/lab/reagent" \

 ```json
 [
-  {"cas": "7732-18-3", "name": "水", "molecular_formula": "H2O", "smiles": "O", "stock_in_quantity": 10, "unit": "mL"},
-  {"cas": "64-17-5", "name": "乙醇", "molecular_formula": "C2H6O", "smiles": "CCO", "stock_in_quantity": 5, "unit": "L"}
+  {
+    "cas": "7732-18-3",
+    "name": "水",
+    "molecular_formula": "H2O",
+    "smiles": "O",
+    "stock_in_quantity": 10,
+    "unit": "mL"
+  },
+  {
+    "cas": "64-17-5",
+    "name": "乙醇",
+    "molecular_formula": "C2H6O",
+    "smiles": "CCO",
+    "stock_in_quantity": 5,
+    "unit": "L"
+  }
 ]
 ```

@@ -160,9 +176,20 @@ cas,name,molecular_formula,smiles,stock_in_quantity,unit,supplier,production_dat
 7732-18-3,水,H2O,O,10,mL,农夫山泉,2025-11-18T00:00:00Z,2026-11-18T00:00:00Z
 ```

+### 日期格式规则（重要）
+
+所有日期字段（`production_date`、`expiry_date`）**必须**使用 ISO 8601 完整格式：`YYYY-MM-DDTHH:MM:SSZ`。
+
+- 用户输入 `2025-03-01` → 转换为 `"2025-03-01T00:00:00Z"`
+- 用户输入 `2025/9/1` → 转换为 `"2025-09-01T00:00:00Z"`
+- 用户未提供日期 → 使用当天日期 + `T00:00:00Z`，有效期默认 +1 年
+
+**禁止**发送不带时间部分的日期字符串（如 `"2025-03-01"`），API 会拒绝。
+
 ### 执行与汇报

 每次 API 调用后：
+
 1. 检查返回 `code`（0 = 成功）
 2. 记录成功/失败数量
 3. 全部完成后汇总：「共录入 N 条试剂，成功 X 条，失败 Y 条」
@@ -172,28 +199,29 @@ cas,name,molecular_formula,smiles,stock_in_quantity,unit,supplier,production_dat

 ## 常见试剂速查表

-| 名称 | CAS | 分子式 | SMILES |
-|------|-----|--------|--------|
-| 水 | 7732-18-3 | H2O | O |
-| 乙醇 | 64-17-5 | C2H6O | CCO |
-| 甲醇 | 67-56-1 | CH4O | CO |
-| 丙酮 | 67-64-1 | C3H6O | CC(C)=O |
-| 二甲基亚砜(DMSO) | 67-68-5 | C2H6OS | CS(C)=O |
-| 乙酸乙酯 | 141-78-6 | C4H8O2 | CCOC(C)=O |
-| 二氯甲烷 | 75-09-2 | CH2Cl2 | ClCCl |
-| 四氢呋喃(THF) | 109-99-9 | C4H8O | C1CCOC1 |
-| N,N-二甲基甲酰胺(DMF) | 68-12-2 | C3H7NO | CN(C)C=O |
-| 氯仿 | 67-66-3 | CHCl3 | ClC(Cl)Cl |
-| 乙腈 | 75-05-8 | C2H3N | CC#N |
-| 甲苯 | 108-88-3 | C7H8 | Cc1ccccc1 |
-| 正己烷 | 110-54-3 | C6H14 | CCCCCC |
-| 异丙醇 | 67-63-0 | C3H8O | CC(C)O |
-| 盐酸 | 7647-01-0 | HCl | Cl |
-| 硫酸 | 7664-93-9 | H2SO4 | OS(O)(=O)=O |
-| 氢氧化钠 | 1310-73-2 | NaOH | [Na]O |
-| 碳酸钠 | 497-19-8 | Na2CO3 | [Na]OC([O-])=O.[Na+] |
-| 氯化钠 | 7647-14-5 | NaCl | [Na]Cl |
-| 乙二胺四乙酸(EDTA) | 60-00-4 | C10H16N2O8 | OC(=O)CN(CCN(CC(O)=O)CC(O)=O)CC(O)=O |
+| 名称                  | CAS       | 分子式     | SMILES                               |
+| --------------------- | --------- | ---------- | ------------------------------------ |
+| 水                    | 7732-18-3 | H2O        | O                                    |
+| 乙醇                  | 64-17-5   | C2H6O      | CCO                                  |
+| 乙酸                  | 64-19-7   | C2H4O2     | CC(O)=O                              |
+| 甲醇                  | 67-56-1   | CH4O       | CO                                   |
+| 丙酮                  | 67-64-1   | C3H6O      | CC(C)=O                              |
+| 二甲基亚砜(DMSO)      | 67-68-5   | C2H6OS     | CS(C)=O                              |
+| 乙酸乙酯              | 141-78-6  | C4H8O2     | CCOC(C)=O                            |
+| 二氯甲烷              | 75-09-2   | CH2Cl2     | ClCCl                                |
+| 四氢呋喃(THF)         | 109-99-9  | C4H8O      | C1CCOC1                              |
+| N,N-二甲基甲酰胺(DMF) | 68-12-2   | C3H7NO     | CN(C)C=O                             |
+| 氯仿                  | 67-66-3   | CHCl3      | ClC(Cl)Cl                            |
+| 乙腈                  | 75-05-8   | C2H3N      | CC#N                                 |
+| 甲苯                  | 108-88-3  | C7H8       | Cc1ccccc1                            |
+| 正己烷                | 110-54-3  | C6H14      | CCCCCC                               |
+| 异丙醇                | 67-63-0   | C3H8O      | CC(C)O                               |
+| 盐酸                  | 7647-01-0 | HCl        | Cl                                   |
+| 硫酸                  | 7664-93-9 | H2SO4      | OS(O)(=O)=O                          |
+| 氢氧化钠              | 1310-73-2 | NaOH       | [Na]O                                |
+| 碳酸钠                | 497-19-8  | Na2CO3     | [Na]OC([O-])=O.[Na+]                 |
+| 氯化钠                | 7647-14-5 | NaCl       | [Na]Cl                               |
+| 乙二胺四乙酸(EDTA)    | 60-00-4   | C10H16N2O8 | OC(=O)CN(CCN(CC(O)=O)CC(O)=O)CC(O)=O |

 > 此表仅供快速参考。对于不在表中的试剂，agent 应根据化学知识推断或提示用户补充。

--- a/.cursor/skills/batch-submit-experiment/SKILL.md
+++ b/.cursor/skills/batch-submit-experiment/SKILL.md
@@ -1,11 +1,13 @@
 ---
 name: batch-submit-experiment
-description: Batch submit experiments (notebooks) to Uni-Lab platform — list workflows, generate node_params from registry schemas, submit multiple rounds. Use when the user wants to submit experiments, create notebooks, batch run workflows, or mentions 提交实验/批量实验/notebook/实验轮次.
+description: Batch submit experiments (notebooks) to the Uni-Lab cloud platform (leap-lab) — list workflows, generate node_params from registry schemas, submit multiple rounds, check notebook status. Use when the user wants to submit experiments, create notebooks, batch run workflows, check experiment status, or mentions 提交实验/批量实验/notebook/实验轮次/实验状态.
 ---

-# 批量提交实验指南
+# Uni-Lab 批量提交实验指南

-通过云端 API 批量提交实验（notebook），支持多轮实验参数配置。根据 workflow 模板详情和本地设备注册表自动生成 `node_params` 模板。
+通过 Uni-Lab 云端 API 批量提交实验（notebook），支持多轮实验参数配置。根据 workflow 模板详情和本地设备注册表自动生成 `node_params` 模板。
+
+> **重要**：本指南中的 `Authorization: Lab <token>` 是 **Uni-Lab 平台专用的认证方式**，`Lab` 是 Uni-Lab 的 auth scheme 关键字，**不是** HTTP Basic 认证。请勿将其替换为 `Basic`。

 ## 前置条件（缺一不可）

@@ -18,25 +20,28 @@ description: Batch submit experiments (notebooks) to Uni-Lab platform — list w
 生成 AUTH token（任选一种方式）：

 ```bash
-# 方式一：Python 一行生成
+# 方式一：Python 一行生成（注意：scheme 是 "Lab" 不是 "Basic"）
 python -c "import base64,sys; print('Authorization: Lab ' + base64.b64encode(f'{sys.argv[1]}:{sys.argv[2]}'.encode()).decode())" <ak> <sk>

 # 方式二：手动计算
 # base64(ak:sk) → Authorization: Lab <token>
+# ⚠️ 这里的 "Lab" 是 Uni-Lab 平台的 auth scheme，绝对不能用 "Basic" 替代
 ```

 ### 2. --addr → BASE URL

-| `--addr` 值 | BASE |
-|-------------|------|
-| `test` | `https://uni-lab.test.bohrium.com` |
-| `uat` | `https://uni-lab.uat.bohrium.com` |
-| `local` | `http://127.0.0.1:48197` |
-| 不传（默认） | `https://uni-lab.bohrium.com` |
+| `--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 scheme 必须是 "Lab"（Uni-Lab 专用），不是 "Basic"
 AUTH="Authorization: Lab <上面命令输出的 token>"
 ```

@@ -44,22 +49,23 @@ AUTH="Authorization: Lab <上面命令输出的 token>"

 **批量提交实验时需要本地注册表来解析 workflow 节点的参数 schema。**

-按优先级搜索：
+**必须先用 Glob 工具搜索文件**，不要直接猜测路径：

 ```
-<workspace 根目录>/unilabos_data/req_device_registry_upload.json
-<workspace 根目录>/req_device_registry_upload.json
+Glob: **/req_device_registry_upload.json
 ```

-也可直接 Glob 搜索：`**/req_device_registry_upload.json`
+常见位置（仅供参考，以 Glob 实际结果为准）：
+- `<workspace>/unilabos_data/req_device_registry_upload.json`
+- `<workspace>/req_device_registry_upload.json`

 找到后**检查文件修改时间**并告知用户。超过 1 天提醒用户是否需要重新启动 `unilab`。

-**如果文件不存在** → 告知用户先运行 `unilab` 启动命令，等注册表生成后再执行。可跳过此步，但将无法自动生成参数模板，需要用户手动填写 `param`。
+**如果 Glob 搜索无结果** → 告知用户先运行 `unilab` 启动命令，等注册表生成后再执行。可跳过此步，但将无法自动生成参数模板，需要用户手动填写 `param`。

 ### 4. workflow_uuid（目标工作流）

-用户需要提供要提交的 workflow UUID。如果用户不确定，通过 API #2 列出可用 workflow 供选择。
+用户需要提供要提交的 workflow UUID。如果用户不确定，通过 API #3 列出可用 workflow 供选择。

 **四项全部就绪后才可开始。**

@@ -68,8 +74,9 @@ AUTH="Authorization: Lab <上面命令输出的 token>"
 在整个对话过程中，agent 需要记住以下状态，避免重复询问用户：

 - `lab_uuid` — 实验室 UUID（首次通过 API #1 自动获取，**不需要问用户**）
+- `project_uuid` — 项目 UUID（通过 API #2 列出项目列表，**让用户选择**）
 - `workflow_uuid` — 工作流 UUID（用户提供或从列表选择）
- `workflow_nodes` — workflow 中各 action 节点的 uuid、设备 ID、动作名（从 API #3 获取）
+- `workflow_nodes` — workflow 中各 action 节点的 uuid、设备 ID、动作名（从 API #4 获取）

 ## 请求约定

@@ -92,12 +99,46 @@ curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
 返回：

 ```json
-{"code": 0, "data": {"uuid": "xxx", "name": "实验室名称"}}
+{ "code": 0, "data": { "uuid": "xxx", "name": "实验室名称" } }
 ```

 记住 `data.uuid` 为 `lab_uuid`。

-### 2. 列出可用 workflow
+### 2. 列出实验室项目（让用户选择项目）
+
+```bash
+curl -s -X GET "$BASE/api/v1/lab/project/list?lab_uuid=$lab_uuid" -H "$AUTH"
+```
+
+返回：
+
+```json
+{
+  "code": 0,
+  "data": {
+    "items": [
+      {
+        "uuid": "1b3f249a-...",
+        "name": "bt",
+        "description": null,
+        "status": "active",
+        "created_at": "2026-04-09T14:31:28+08:00"
+      },
+      {
+        "uuid": "b6366243-...",
+        "name": "default",
+        "description": "默认项目",
+        "status": "active",
+        "created_at": "2026-03-26T11:13:36+08:00"
+      }
+    ]
+  }
+}
+```
+
+展示 `data.items[]` 中每个项目的 `name` 和 `uuid`，让用户选择。用户**必须**选择一个项目，记住 `project_uuid`（即选中项目的 `uuid`），后续创建 notebook 时需要提供。
+
+### 3. 列出可用 workflow

 ```bash
 curl -s -X GET "$BASE/api/v1/lab/workflow/workflows?page=1&page_size=20&lab_uuid=$lab_uuid" -H "$AUTH"
@@ -105,13 +146,14 @@ curl -s -X GET "$BASE/api/v1/lab/workflow/workflows?page=1&page_size=20&lab_uuid

 返回 workflow 列表，展示给用户选择。列出每个 workflow 的 `uuid` 和 `name`。

-### 3. 获取 workflow 模板详情
+### 4. 获取 workflow 模板详情

 ```bash
 curl -s -X GET "$BASE/api/v1/lab/workflow/template/detail/$workflow_uuid" -H "$AUTH"
 ```

 返回 workflow 的完整结构，包含所有 action 节点信息。需要从响应中提取：
+
 - 每个 action 节点的 `node_uuid`
 - 每个节点对应的设备 ID（`resource_template_name`）
 - 每个节点的动作名（`node_template_name`）
@@ -119,7 +161,7 @@ curl -s -X GET "$BASE/api/v1/lab/workflow/template/detail/$workflow_uuid" -H "$A

 > **注意**：此 API 返回格式可能因版本不同而有差异。首次调用时，先打印完整响应分析结构，再提取节点信息。常见的节点字段路径为 `data.nodes[]` 或 `data.workflow_nodes[]`。

-### 4. 提交实验（创建 notebook）
+### 5. 提交实验（创建 notebook）

 ```bash
 curl -s -X POST "$BASE/api/v1/lab/notebook" \
@@ -131,34 +173,45 @@ curl -s -X POST "$BASE/api/v1/lab/notebook" \

 ```json
 {
-    "lab_uuid": "<lab_uuid>",
-    "workflow_uuid": "<workflow_uuid>",
-    "name": "<实验名称>",
-    "node_params": [
+  "lab_uuid": "<lab_uuid>",
+  "project_uuid": "<project_uuid>",
+  "workflow_uuid": "<workflow_uuid>",
+  "name": "<实验名称>",
+  "node_params": [
+    {
+      "sample_uuids": ["<样品UUID1>", "<样品UUID2>"],
+      "datas": [
        {
-            "sample_uuids": ["<样品UUID1>", "<样品UUID2>"],
-            "datas": [
-                {
-                    "node_uuid": "<workflow中的节点UUID>",
-                    "param": {},
-                    "sample_params": [
-                        {
-                            "container_uuid": "<容器UUID>",
-                            "sample_value": {
-                                "liquid_names": "<液体名称>",
-                                "volumes": 1000
-                            }
-                        }
-                    ]
-                }
-            ]
+          "node_uuid": "<workflow中的节点UUID>",
+          "param": {},
+          "sample_params": [
+            {
+              "container_uuid": "<容器UUID>",
+              "sample_value": {
+                "liquid_names": "<液体名称>",
+                "volumes": 1000
+              }
+            }
+          ]
        }
-    ]
+      ]
+    }
+  ]
 }
 ```

 > **注意**：`sample_uuids` 必须是 **UUID 数组**（`[]uuid.UUID`），不是字符串。无样品时传空数组 `[]`。

+### 6. 查询 notebook 状态
+
+提交成功后，使用返回的 notebook UUID 查询执行状态：
+
+```bash
+curl -s -X GET "$BASE/api/v1/lab/notebook/status?uuid=$notebook_uuid" -H "$AUTH"
+```
+
+提交后应**立即查询一次**状态，确认 notebook 已被正确接收并开始调度。
+
 ---

 ## Notebook 请求体详解
@@ -172,25 +225,25 @@ curl -s -X POST "$BASE/api/v1/lab/notebook" \

 ### 每轮的字段

-| 字段 | 类型 | 说明 |
-|------|------|------|
+| 字段           | 类型          | 说明                                      |
+| -------------- | ------------- | ----------------------------------------- |
 | `sample_uuids` | array\<uuid\> | 该轮实验的样品 UUID 数组，无样品时传 `[]` |
-| `datas` | array | 该轮中每个 workflow 节点的参数配置 |
+| `datas`        | array         | 该轮中每个 workflow 节点的参数配置        |

 ### datas 中每个节点

-| 字段 | 类型 | 说明 |
-|------|------|------|
-| `node_uuid` | string | workflow 模板中的节点 UUID（从 API #3 获取） |
-| `param` | object | 动作参数（根据本地注册表 schema 填写） |
-| `sample_params` | array | 样品相关参数（液体名、体积等） |
+| 字段            | 类型   | 说明                                         |
+| --------------- | ------ | -------------------------------------------- |
+| `node_uuid`     | string | workflow 模板中的节点 UUID（从 API #4 获取） |
+| `param`         | object | 动作参数（根据本地注册表 schema 填写）       |
+| `sample_params` | array  | 样品相关参数（液体名、体积等）               |

 ### sample_params 中每条

-| 字段 | 类型 | 说明 |
-|------|------|------|
-| `container_uuid` | string | 容器 UUID |
-| `sample_value` | object | 样品值，如 `{"liquid_names": "水", "volumes": 1000}` |
+| 字段             | 类型   | 说明                                                 |
+| ---------------- | ------ | ---------------------------------------------------- |
+| `container_uuid` | string | 容器 UUID                                            |
+| `sample_value`   | object | 样品值，如 `{"liquid_names": "水", "volumes": 1000}` |

 ---

@@ -211,6 +264,7 @@ python scripts/gen_notebook_params.py \
 > 脚本位于本文档同级目录下的 `scripts/gen_notebook_params.py`。

 脚本会：
+
 1. 调用 workflow detail API 获取所有 action 节点
 2. 读取本地注册表，为每个节点查找对应的 action schema
 3. 生成 `notebook_template.json`，包含：
@@ -222,7 +276,7 @@ python scripts/gen_notebook_params.py \

 如果脚本不可用或注册表不存在：

-1. 调用 API #3 获取 workflow 详情
+1. 调用 API #4 获取 workflow 详情
 2. 找到每个 action 节点的 `node_uuid`
 3. 在本地注册表中查找对应设备的 `action_value_mappings`：
   ```
@@ -248,8 +302,11 @@ python scripts/gen_notebook_params.py \
              "properties": {
                "goal": {
                  "properties": {
-                    "asp_vols": {"type": "array", "items": {"type": "number"}},
-                    "sources": {"type": "array"}
+                    "asp_vols": {
+                      "type": "array",
+                      "items": { "type": "number" }
+                    },
+                    "sources": { "type": "array" }
                  },
                  "required": ["asp_vols", "sources"]
                }
@@ -275,13 +332,15 @@ Task Progress:
 - [ ] Step 1: 确认 ak/sk → 生成 AUTH token
 - [ ] Step 2: 确认 --addr → 设置 BASE URL
 - [ ] Step 3: GET /edge/lab/info → 获取 lab_uuid
- [ ] Step 4: 确认 workflow_uuid（用户提供或从 GET #2 列表选择）
- [ ] Step 5: GET workflow detail (#3) → 提取各节点 uuid、设备ID、动作名
- [ ] Step 6: 定位本地注册表 req_device_registry_upload.json
- [ ] Step 7: 运行 gen_notebook_params.py 或手动匹配 → 生成 node_params 模板
- [ ] Step 8: 引导用户填写每轮的参数（sample_uuids、param、sample_params）
- [ ] Step 9: 构建完整请求体 → POST /lab/notebook 提交
- [ ] Step 10: 检查返回结果，确认提交成功
+- [ ] Step 4: GET /lab/project/list → 列出项目，让用户选择 → 获取 project_uuid
+- [ ] Step 5: 确认 workflow_uuid（用户提供或从 GET #3 列表选择）
+- [ ] Step 6: GET workflow detail (#4) → 提取各节点 uuid、设备ID、动作名
+- [ ] Step 7: 定位本地注册表 req_device_registry_upload.json
+- [ ] Step 8: 运行 gen_notebook_params.py 或手动匹配 → 生成 node_params 模板
+- [ ] Step 9: 引导用户填写每轮的参数（sample_uuids、param、sample_params）
+- [ ] Step 10: 构建完整请求体（含 project_uuid）→ POST /lab/notebook 提交
+- [ ] Step 11: 检查返回结果，记录 notebook UUID
+- [ ] Step 12: GET /lab/notebook/status → 查询 notebook 状态，确认已调度
 ```

 ---
--- a/.cursor/skills/batch-submit-experiment/scripts/gen_notebook_params.py
+++ b/.cursor/skills/batch-submit-experiment/scripts/gen_notebook_params.py
@@ -7,7 +7,7 @@

 选项:
  --auth <token>          Lab token（base64(ak:sk) 的结果，不含 "Lab " 前缀）
-  --base <url>            API 基础 URL（如 https://uni-lab.test.bohrium.com）
+  --base <url>            API 基础 URL（如 https://leap-lab.test.bohrium.com）
  --workflow-uuid <uuid>  目标 workflow 的 UUID
  --registry <path>       本地注册表文件路径（默认自动搜索）
  --rounds <n>            实验轮次数（默认 1）
@@ -17,7 +17,7 @@
 示例:
  python gen_notebook_params.py \\
    --auth YTFmZDlkNGUtxxxx \\
-    --base https://uni-lab.test.bohrium.com \\
+    --base https://leap-lab.test.bohrium.com \\
    --workflow-uuid abc-123-def \\
    --rounds 2
 """
@@ -265,6 +265,7 @@ def generate_template(nodes, registry_index, rounds):

    return {
        "lab_uuid": "$TODO_LAB_UUID",
+        "project_uuid": "$TODO_PROJECT_UUID",
        "workflow_uuid": "$TODO_WORKFLOW_UUID",
        "name": "$TODO_EXPERIMENT_NAME",
        "node_params": node_params,
--- a/.cursor/skills/create-device-skill/SKILL.md
+++ b/.cursor/skills/create-device-skill/SKILL.md
@@ -40,13 +40,13 @@ python ./scripts/gen_auth.py --config <config.py>

 决定 API 请求发往哪个服务器。从启动命令的 `--addr` 参数获取：

-| `--addr` 值 | BASE URL |
-|-------------|----------|
-| `test` | `https://uni-lab.test.bohrium.com` |
-| `uat` | `https://uni-lab.uat.bohrium.com` |
-| `local` | `http://127.0.0.1:48197` |
-| 不传（默认） | `https://uni-lab.bohrium.com` |
-| 其他自定义 URL | 直接使用该 URL |
+| `--addr` 值    | BASE URL                            |
+| -------------- | ----------------------------------- |
+| `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`      |
+| 其他自定义 URL | 直接使用该 URL                      |

 #### 必备项 ③：req_device_registry_upload.json（设备注册表）

@@ -54,11 +54,11 @@ python ./scripts/gen_auth.py --config <config.py>

 **推断 working_dir**（即 `unilabos_data` 所在目录）：

-| 条件 | working_dir 取值 |
-|------|------------------|
+| 条件                 | working_dir 取值                                         |
+| -------------------- | -------------------------------------------------------- |
 | 传了 `--working_dir` | `<working_dir>/unilabos_data/`（若子目录已存在则直接用） |
-| 仅传了 `--config` | `<config 文件所在目录>/unilabos_data/` |
-| 都没传 | `<当前工作目录>/unilabos_data/` |
+| 仅传了 `--config`    | `<config 文件所在目录>/unilabos_data/`                   |
+| 都没传               | `<当前工作目录>/unilabos_data/`                          |

 **按优先级搜索文件**：

@@ -84,24 +84,6 @@ python ./scripts/gen_auth.py --config <config.py>
 python ./scripts/extract_device_actions.py --registry <找到的文件路径>
 ```

-#### 完整示例
-
-用户提供：
-
-```
--ak a1fd9d4e-xxxx-xxxx-xxxx-d9a69c09f0fd
--sk 136ff5c6-xxxx-xxxx-xxxx-a03e301f827b
--addr test
--port 8003
--disable_browser
-```
-
-从中提取：
- ✅ ak/sk → 运行 `gen_auth.py` 得到 `AUTH="Authorization: Lab YTFmZDlk..."`
- ✅ addr=test → `BASE=https://uni-lab.test.bohrium.com`
- ✅ 搜索 `unilabos_data/req_device_registry_upload.json` → 找到并确认时间
- ✅ 用户指明目标设备 → 如 `liquid_handler.prcxi`
-
 **四项全部就绪后才进入 Step 1。**

 ### Step 1 — 列出可用设备
@@ -129,6 +111,7 @@ python ./scripts/extract_device_actions.py [--registry <path>] <device_id> ./ski
 脚本会显示设备的 Python 源码路径和类名，方便阅读源码了解参数含义。

 每个 action 生成一个 JSON 文件，包含：
+
 - `type` — 作为 API 调用的 `action_type`
 - `schema` — 完整 JSON Schema（含 `properties.goal.properties` 参数定义）
 - `goal` — goal 字段映射（含占位符 `$placeholder`）
@@ -136,13 +119,14 @@ python ./scripts/extract_device_actions.py [--registry <path>] <device_id> ./ski

 ### Step 3 — 写 action-index.md

-按模板为每个 action 写条目：
+按模板为每个 action 写条目（**必须包含 `action_type`**）：

 ```markdown
 ### `<action_name>`

 <用途描述（一句话）>

+- **action_type**: `<从 actions/<name>.json 的 type 字段获取>`
 - **Schema**: [`actions/<filename>.json`](actions/<filename>.json)
 - **核心参数**: `param1`, `param2`（从 schema.required 获取）
 - **可选参数**: `param3`, `param4`
@@ -150,6 +134,8 @@ python ./scripts/extract_device_actions.py [--registry <path>] <device_id> ./ski
 ```

 描述规则：
+
+- **每个 action 必须标注 `action_type`**（从 JSON 的 `type` 字段读取），这是 API #9 调用时的必填参数，传错会导致任务永远卡住
 - 从 `schema.properties` 读参数列表（schema 已提升为 goal 内容）
 - 从 `schema.required` 区分核心/可选参数
 - 按功能分类（移液、枪头、外设等）
@@ -158,12 +144,14 @@ python ./scripts/extract_device_actions.py [--registry <path>] <device_id> ./ski
  - `unilabos_devices` → **DeviceSlot**，填入路径字符串如 `"/host_node"`（从资源树筛选 type=device）
  - `unilabos_nodes` → **NodeSlot**，填入路径字符串如 `"/PRCXI/PRCXI_Deck"`（资源树中任意节点）
  - `unilabos_class` → **ClassSlot**，填入类名字符串如 `"container"`（从注册表查找）
+  - `unilabos_formulation` → **FormulationSlot**，填入配方数组 `[{well_name, liquids: [{name, volume}]}]`（well_name 为目标物料的 name）
 - array 类型字段 → `[{id, name, uuid}, ...]`
 - 特殊：`create_resource` 的 `res_id`（ResourceSlot）可填不存在的路径

 ### Step 4 — 写 SKILL.md

-直接复用 `unilab-device-api` 的 API 模板（10 个 endpoint），修改：
+直接复用 `unilab-device-api` 的 API 模板，修改：
+
 - 设备名称
 - Action 数量
 - 目录列表
@@ -171,43 +159,96 @@ python ./scripts/extract_device_actions.py [--registry <path>] <device_id> ./ski
 - **AUTH 头** — 使用 Step 0 中 `gen_auth.py` 生成的 `Authorization: Lab <token>`（不要硬编码 `Api` 类型的 key）
 - **Python 源码路径** — 在 SKILL.md 开头注明设备对应的源码文件，方便参考参数含义
 - **Slot 字段表** — 列出本设备哪些 action 的哪些字段需要填入 Slot（物料/设备/节点/类名）
+- **action_type 速查表** — 在 API #9 说明后面紧跟一个表格，列出每个 action 对应的 `action_type` 值（从 JSON `type` 字段提取），方便 agent 快速查找而无需打开 JSON 文件

 API 模板结构：

 ```markdown
 ## 设备信息
+
 - device_id, Python 源码路径, 设备类名

 ## 前置条件（缺一不可）
+
 - ak/sk → AUTH, --addr → BASE URL

-## Session State
- lab_uuid（通过 API #1 自动匹配，不要问用户）, device_name
+## 请求约定

-## API Endpoints (10 个)
-# 注意：
-# - #1 获取 lab 列表 + 自动匹配 lab_uuid（遍历 is_admin 的 lab，
-#   调用 /lab/info/{uuid} 比对 access_key == ak）
-# - #2 创建工作流用 POST /lab/workflow
-# - #10 获取资源树路径含 lab_uuid: /lab/material/download/{lab_uuid}
+- Windows 平台必须用 curl.exe（非 PowerShell 的 curl 别名）
+
+## Session State
+
+- lab_uuid（通过 GET /edge/lab/info 直接获取，不要问用户）, device_name
+
+## API Endpoints
+
+# - #1 GET /edge/lab/info → 直接拿到 lab_uuid
+
+# - #2 创建工作流 POST /lab/workflow/owner → 拼 URL 告知用户
+
+# - #3 创建节点 POST /edge/workflow/node
+
+# body: {workflow_uuid, resource_template_name: "<device_id>", node_template_name: "<action_name>"}
+
+# - #4 删除节点 DELETE /lab/workflow/nodes
+
+# - #5 更新节点参数 PATCH /lab/workflow/node
+
+# - #6 查询节点 handles POST /lab/workflow/node-handles
+
+# body: {node_uuids: ["uuid1","uuid2"]} → 返回各节点的 handle_uuid
+
+# - #7 批量创建边 POST /lab/workflow/edges
+
+# body: {edges: [{source_node_uuid, target_node_uuid, source_handle_uuid, target_handle_uuid}]}
+
+# - #8 启动工作流 POST /lab/workflow/{uuid}/run
+
+# - #9 运行设备单动作 POST /lab/mcp/run/action（⚠️ action_type 必须从 action-index.md 或 actions/<name>.json 的 type 字段获取，传错会导致任务永远卡住）
+
+# - #10 查询任务状态 GET /lab/mcp/task/{task_uuid}
+
+# - #11 运行工作流单节点 POST /lab/mcp/run/workflow/action
+
+# - #12 获取资源树 GET /lab/material/download/{lab_uuid}
+
+# - #13 获取工作流模板详情 GET /lab/workflow/template/detail/{workflow_uuid}
+
+# 返回 workflow 完整结构：data.nodes[] 含每个节点的 uuid、name、param、device_name、handles
+
+# - #14 按名称查询物料模板 GET /lab/material/template/by-name?lab_uuid=&name=
+
+# 返回 res_template_uuid，用于 #15 创建物料时的必填字段
+
+# - #15 创建物料节点 POST /edge/material/node
+
+# body: {res_template_uuid(从#14获取), name(自定义), display_name, parent_uuid?(从#12获取), ...}
+
+# - #16 更新物料节点 PUT /edge/material/node
+
+# body: {uuid(从#12获取), display_name?, description?, init_param_data?, data?, ...}

 ## Placeholder Slot 填写规则
+
 - unilabos_resources → ResourceSlot → {"id":"/path/name","name":"name","uuid":"xxx"}
 - unilabos_devices → DeviceSlot → "/parent/device" 路径字符串
 - unilabos_nodes → NodeSlot → "/parent/node" 路径字符串
 - unilabos_class → ClassSlot → "class_name" 字符串
+- unilabos_formulation → FormulationSlot → [{well_name, liquids: [{name, volume}]}] 配方数组
 - 特例：create_resource 的 res_id 允许填不存在的路径
 - 列出本设备所有 Slot 字段、类型及含义

 ## 渐进加载策略
+
 ## 完整工作流 Checklist
 ```

 ### Step 5 — 验证

 检查文件完整性：
- [ ] `SKILL.md` 包含 10 个 API endpoint
- [ ] `SKILL.md` 包含 Placeholder Slot 填写规则（ResourceSlot / DeviceSlot / NodeSlot / ClassSlot + create_resource 特例）和本设备的 Slot 字段表
+
+- [ ] `SKILL.md` 包含 API endpoint（#1 获取 lab_uuid、#2-#7 工作流/节点/边、#8-#11 运行/查询、#12 资源树、#13 工作流模板详情、#14-#16 物料管理）
+- [ ] `SKILL.md` 包含 Placeholder Slot 填写规则（ResourceSlot / DeviceSlot / NodeSlot / ClassSlot / FormulationSlot + create_resource 特例）和本设备的 Slot 字段表
 - [ ] `action-index.md` 列出所有 action 并有描述
 - [ ] `actions/` 目录中每个 action 有对应 JSON 文件
 - [ ] JSON 文件包含 `type`, `schema`（已提升为 goal 内容）, `goal`, `goal_default`, `placeholder_keys` 字段
@@ -249,71 +290,202 @@ API 模板结构：
 ```

 > **注意**：`schema` 已由脚本从原始 `schema.properties.goal` 提升为顶层，直接包含参数定义。
-> `schema.properties` 中的字段即为 API 请求 `param.goal` 中的字段。
+> `schema.properties` 中的字段即为 API 创建节点返回的 `data.param` 中的字段，PATCH 更新时直接修改 `param` 即可。

 ## Placeholder Slot 类型体系

-`placeholder_keys` / `_unilabos_placeholder_info` 中有 4 种值，对应不同的填写方式：
+`placeholder_keys` / `_unilabos_placeholder_info` 中有 5 种值，对应不同的填写方式：

-| placeholder 值 | Slot 类型 | 填写格式 | 选取范围 |
-|---------------|-----------|---------|---------|
-| `unilabos_resources` | ResourceSlot | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` | 仅**物料**节点（不含设备） |
-| `unilabos_devices` | DeviceSlot | `"/parent/device_name"` | 仅**设备**节点（type=device），路径字符串 |
-| `unilabos_nodes` | NodeSlot | `"/parent/node_name"` | **设备 + 物料**，即所有节点，路径字符串 |
-| `unilabos_class` | ClassSlot | `"class_name"` | 注册表中已上报的资源类 name |
+| placeholder 值         | Slot 类型       | 填写格式                                              | 选取范围                                  |
+| ---------------------- | --------------- | ----------------------------------------------------- | ----------------------------------------- |
+| `unilabos_resources`   | ResourceSlot    | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` | 仅**物料**节点（不含设备）                |
+| `unilabos_devices`     | DeviceSlot      | `"/parent/device_name"`                               | 仅**设备**节点（type=device），路径字符串 |
+| `unilabos_nodes`       | NodeSlot        | `"/parent/node_name"`                                 | **设备 + 物料**，即所有节点，路径字符串   |
+| `unilabos_class`       | ClassSlot       | `"class_name"`                                        | 注册表中已上报的资源类 name               |
+| `unilabos_formulation` | FormulationSlot | `[{well_name, liquids: [{name, volume}]}]`            | 资源树中物料节点的 **name**，配合液体配方 |

 ### ResourceSlot（`unilabos_resources`）

 最常见的类型。从资源树中选取**物料**节点（孔板、枪头盒、试剂槽等）：

+- 单个：`{"id": "/workstation/container1", "name": "container1", "uuid": "ff149a9a-..."}`
+- 数组：`[{"id": "/path/a", "name": "a", "uuid": "xxx"}, ...]`
+- `id` 从 parent 计算的路径格式，根据 action 语义选择正确的物料
+
+> **特例**：`create_resource` 的 `res_id`，目标物料可能尚不存在，直接填期望路径，不需要 uuid。
+
+### DeviceSlot / NodeSlot / ClassSlot
+
+- **DeviceSlot**（`unilabos_devices`）：路径字符串如 `"/host_node"`，仅 type=device 的节点
+- **NodeSlot**（`unilabos_nodes`）：路径字符串如 `"/PRCXI/PRCXI_Deck"`，设备 + 物料均可选
+- **ClassSlot**（`unilabos_class`）：类名字符串如 `"container"`，从 `req_resource_registry_upload.json` 查找
+
+### FormulationSlot（`unilabos_formulation`）
+
+描述**液体配方**：向哪些容器中加入哪些液体及体积。
+
 ```json
-{"id": "/workstation/container1", "name": "container1", "uuid": "ff149a9a-2cb8-419d-8db5-d3ba056fb3c2"}
+[
+  {
+    "sample_uuid": "",
+    "well_name": "bottle_A1",
+    "liquids": [{ "name": "LiPF6", "volume": 0.6 }]
+  }
+]
 ```

- 单个（schema type=object）：`{"id": "/path/name", "name": "name", "uuid": "xxx"}`
- 数组（schema type=array）：`[{"id": "/path/a", "name": "a", "uuid": "xxx"}, ...]`
- `id` 本身是从 parent 计算的路径格式
- 根据 action 语义选择正确的物料（如 `sources` = 液体来源，`targets` = 目标位置）
+- `well_name` — 目标物料的 **name**（从资源树取，不是 `id` 路径）
+- `liquids[]` — 液体列表，每条含 `name`（试剂名）和 `volume`（体积，单位由上下文决定；pylabrobot 内部统一 uL）
+- `sample_uuid` — 样品 UUID，无样品传 `""`
+- 与 ResourceSlot 的区别：ResourceSlot 指向物料本身，FormulationSlot 引用物料名并附带配方信息

-> **特例**：`create_resource` 的 `res_id` 字段，目标物料可能**尚不存在**，此时直接填写期望的路径（如 `"/workstation/container1"`），不需要 uuid。
-
-### DeviceSlot（`unilabos_devices`）
-
-填写**设备路径字符串**。从资源树中筛选 type=device 的节点，从 parent 计算路径：
-
-```
-"/host_node"
-"/bioyond_cell/reaction_station"
-```
-
- 只填路径字符串，不需要 `{id, uuid}` 对象
- 根据 action 语义选择正确的设备（如 `target_device_id` = 目标设备）
-
-### NodeSlot（`unilabos_nodes`）
-
-范围 = 设备 + 物料。即资源树中**所有节点**都可以选，填写**路径字符串**：
-
-```
-"/PRCXI/PRCXI_Deck"
-```
-
- 使用场景：当参数既可能指向物料也可能指向设备时（如 `PumpTransferProtocol` 的 `from_vessel`/`to_vessel`，`create_resource` 的 `parent`）
-
-### ClassSlot（`unilabos_class`）
-
-填写注册表中已上报的**资源类 name**。从本地 `req_resource_registry_upload.json` 中查找：
-
-```
-"container"
-```
-
-### 通过 API #10 获取资源树
+### 通过 API #12 获取资源树

 ```bash
 curl -s -X GET "$BASE/api/v1/lab/material/download/$lab_uuid" -H "$AUTH"
 ```

-注意 `lab_uuid` 在路径中（不是查询参数）。资源树返回所有节点，每个节点包含 `id`（路径格式）、`name`、`uuid`、`type`、`parent` 等字段。填写 Slot 时需根据 placeholder 类型筛选正确的节点。
+注意 `lab_uuid` 在路径中（不是查询参数）。返回结构：
+
+```json
+{
+  "code": 0,
+  "data": {
+    "nodes": [
+      {"name": "host_node", "uuid": "c3ec1e68-...", "type": "device", "parent": ""},
+      {"name": "PRCXI", "uuid": "e249c9a6-...", "type": "device", "parent": ""},
+      {"name": "PRCXI_Deck", "uuid": "fb6a8b71-...", "type": "deck", "parent": "PRCXI"}
+    ],
+    "edges": [...]
+  }
+}
+```
+
+- `data.nodes[]` — 所有节点（设备 + 物料），每个节点含 `name`、`uuid`、`type`、`parent`
+- `type` 区分设备（`device`）和物料（`deck`、`container`、`resource` 等）
+- `parent` 为父节点名称（空字符串表示顶级）
+- 填写 Slot 时根据 placeholder 类型筛选：ResourceSlot 取非 device 节点，DeviceSlot 取 device 节点
+- 创建/更新物料时：`parent_uuid` 取父节点的 `uuid`，更新目标的 `uuid` 取节点自身的 `uuid`
+
+## 物料管理 API
+
+设备 Skill 除了设备动作外，还需支持物料节点的创建和参数设定，用于在资源树中动态管理物料。
+
+典型流程：先通过 **#14 按名称查询模板** 获取 `res_template_uuid` → 再通过 **#15 创建物料** → 之后可通过 **#16 更新物料** 修改属性。更新时需要的 `uuid` 和 `parent_uuid` 均从 **#12 资源树下载** 获取。
+
+### API #14 — 按名称查询物料模板
+
+创建物料前，需要先获取物料模板的 UUID。通过模板名称查询：
+
+```bash
+curl -s -X GET "$BASE/api/v1/lab/material/template/by-name?lab_uuid=$lab_uuid&name=<template_name>" -H "$AUTH"
+```
+
+| 参数       | 必填   | 说明                             |
+| ---------- | ------ | -------------------------------- |
+| `lab_uuid` | **是** | 实验室 UUID（从 API #1 获取）    |
+| `name`     | **是** | 物料模板名称（如 `"container"`） |
+
+返回 `code: 0` 时，**`data.uuid`** 即为 `res_template_uuid`，用于 API #15 创建物料。返回还包含 `name`、`resource_type`、`handles`、`config_infos` 等模板元信息。
+
+模板不存在时返回 `code: 10002`，`data` 为空对象。模板名称来自资源注册表中已注册的资源类型。
+
+### API #15 — 创建物料节点
+
+```bash
+curl -s -X POST "$BASE/api/v1/edge/material/node" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '<request_body>'
+```
+
+请求体：
+
+```json
+{
+  "res_template_uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+  "name": "my_custom_bottle",
+  "display_name": "自定义瓶子",
+  "parent_uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+  "type": "",
+  "init_param_data": {},
+  "schema": {},
+  "data": {
+    "liquids": [["water", 1000, "uL"]],
+    "max_volume": 50000
+  },
+  "plate_well_datas": {},
+  "plate_reagent_datas": {},
+  "pose": {},
+  "model": {}
+}
+```
+
+| 字段                  | 必填   | 类型          | 数据来源                            | 说明                                   |
+| --------------------- | ------ | ------------- | ----------------------------------- | -------------------------------------- |
+| `res_template_uuid`   | **是** | string (UUID) | **API #14** 按名称查询获取          | 物料模板 UUID                          |
+| `name`                | 否     | string        | **用户自定义**                      | 节点名称（标识符），可自由命名         |
+| `display_name`        | 否     | string        | 用户自定义                          | 显示名称（UI 展示用）                  |
+| `parent_uuid`         | 否     | string (UUID) | **API #12** 资源树中父节点的 `uuid` | 父节点，为空则创建顶级节点             |
+| `type`                | 否     | string        | 从模板继承                          | 节点类型                               |
+| `init_param_data`     | 否     | object        | 用户指定                            | 初始化参数，覆盖模板默认值             |
+| `data`                | 否     | object        | 用户指定                            | 节点数据，container 见下方 data 格式   |
+| `plate_well_datas`    | 否     | object        | 用户指定                            | 孔板子节点数据（创建带孔位的板时使用） |
+| `plate_reagent_datas` | 否     | object        | 用户指定                            | 试剂关联数据                           |
+| `schema`              | 否     | object        | 从模板继承                          | 自定义 schema，不传则从模板继承        |
+| `pose`                | 否     | object        | 用户指定                            | 位姿信息                               |
+| `model`               | 否     | object        | 用户指定                            | 3D 模型信息                            |
+
+#### container 的 `data` 格式
+
+> **体积单位统一为 uL（微升）**。pylabrobot 体系中所有体积值（`max_volume`、`liquids` 中的 volume）均为 uL。外部如果是 mL 需乘 1000 转换。
+
+```json
+{
+  "liquids": [["water", 1000, "uL"], ["ethanol", 500, "uL"]],
+  "max_volume": 50000
+}
+```
+
+- `liquids` — 液体列表，每条为 `[液体名称, 体积(uL), 单位字符串]`
+- `max_volume` — 容器最大容量（uL），如 50 mL = 50000 uL
+
+### API #16 — 更新物料节点
+
+```bash
+curl -s -X PUT "$BASE/api/v1/edge/material/node" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '<request_body>'
+```
+
+请求体：
+
+```json
+{
+  "uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+  "parent_uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+  "display_name": "新显示名称",
+  "description": "新描述",
+  "init_param_data": {},
+  "data": {},
+  "pose": {},
+  "schema": {},
+  "extra": {}
+}
+```
+
+| 字段              | 必填   | 类型          | 数据来源                              | 说明             |
+| ----------------- | ------ | ------------- | ------------------------------------- | ---------------- |
+| `uuid`            | **是** | string (UUID) | **API #12** 资源树中目标节点的 `uuid` | 要更新的物料节点 |
+| `parent_uuid`     | 否     | string (UUID) | API #12 资源树                        | 移动到新父节点   |
+| `display_name`    | 否     | string        | 用户指定                              | 更新显示名称     |
+| `description`     | 否     | string        | 用户指定                              | 更新描述         |
+| `init_param_data` | 否     | object        | 用户指定                              | 更新初始化参数   |
+| `data`            | 否     | object        | 用户指定                              | 更新节点数据     |
+| `pose`            | 否     | object        | 用户指定                              | 更新位姿         |
+| `schema`          | 否     | object        | 用户指定                              | 更新 schema      |
+| `extra`           | 否     | object        | 用户指定                              | 更新扩展数据     |
+
+> 只传需要更新的字段，未传的字段保持不变。

 ## 最终目录结构

--- a/.cursor/skills/host-node/SKILL.md
+++ b/.cursor/skills/host-node/SKILL.md
@@ -0,0 +1,251 @@
+---
+name: host-node
+description: Operate Uni-Lab host node via REST API — create resources, test latency, test resource tree, manual confirm. Use when the user mentions host_node, creating resources, resource management, testing latency, or any host node operation.
+---
+
+# Host Node API Skill
+
+## 设备信息
+
+- **device_id**: `host_node`
+- **Python 源码**: `unilabos/ros/nodes/presets/host_node.py`
+- **设备类**: `HostNode`
+- **动作数**: 4（`create_resource`, `test_latency`, `auto-test_resource`, `manual_confirm`）
+
+## 前置条件（缺一不可）
+
+使用本 skill 前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
+
+### 1. ak / sk → AUTH
+
+从启动参数 `--ak` `--sk` 或 config.py 中获取，生成 token：`base64(ak:sk)` → `Authorization: Lab <token>`
+
+### 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>"
+```
+
+**两项全部就绪后才可发起 API 请求。**
+
+## Session State
+
+在整个对话过程中，agent 需要记住以下状态，避免重复询问用户：
+
+- `lab_uuid` — 实验室 UUID（首次通过 API #1 自动获取，**不需要问用户**）
+- `device_name` — `host_node`
+
+## 请求约定
+
+所有请求使用 `curl -s`，POST/PATCH/DELETE 需加 `Content-Type: application/json`。
+
+> **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名）。
+
+---
+
+## API Endpoints
+
+### 1. 获取实验室信息（自动获取 lab_uuid）
+
+```bash
+curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
+```
+
+返回 `data.uuid` 为 `lab_uuid`，`data.name` 为 `lab_name`。
+
+### 2. 创建工作流
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/workflow/owner" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"name":"<名称>","lab_uuid":"<lab_uuid>","description":"<描述>"}'
+```
+
+返回 `data.uuid` 为 `workflow_uuid`。创建成功后告知用户链接：`$BASE/laboratory/$lab_uuid/workflow/$workflow_uuid`
+
+### 3. 创建节点
+
+```bash
+curl -s -X POST "$BASE/api/v1/edge/workflow/node" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"workflow_uuid":"<workflow_uuid>","resource_template_name":"host_node","node_template_name":"<action_name>"}'
+```
+
+- `resource_template_name` 固定为 `host_node`
+- `node_template_name` — action 名称（如 `create_resource`, `test_latency`）
+
+### 4. 删除节点
+
+```bash
+curl -s -X DELETE "$BASE/api/v1/lab/workflow/nodes" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"node_uuids":["<uuid1>"],"workflow_uuid":"<workflow_uuid>"}'
+```
+
+### 5. 更新节点参数
+
+```bash
+curl -s -X PATCH "$BASE/api/v1/lab/workflow/node" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"workflow_uuid":"<wf_uuid>","uuid":"<node_uuid>","param":{...}}'
+```
+
+`param` 直接使用创建节点返回的 `data.param` 结构，修改需要填入的字段值。参考 [action-index.md](action-index.md) 确定哪些字段是 Slot。
+
+### 6. 查询节点 handles
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/workflow/node-handles" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"node_uuids":["<node_uuid_1>","<node_uuid_2>"]}'
+```
+
+### 7. 批量创建边
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/workflow/edges" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"edges":[{"source_node_uuid":"<uuid>","target_node_uuid":"<uuid>","source_handle_uuid":"<uuid>","target_handle_uuid":"<uuid>"}]}'
+```
+
+### 8. 启动工作流
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/workflow/<workflow_uuid>/run" -H "$AUTH"
+```
+
+### 9. 运行设备单动作
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/mcp/run/action" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"lab_uuid":"<lab_uuid>","device_id":"host_node","action":"<action_name>","action_type":"<type>","param":{...}}'
+```
+
+`param` 直接放 goal 里的属性，**不要**再包一层 `{"goal": {...}}`。
+
+> **WARNING: `action_type` 必须正确，传错会导致任务永远卡住无法完成。** 从下表或 `actions/<name>.json` 的 `type` 字段获取。
+
+#### action_type 速查表
+
+| action | action_type |
+|--------|-------------|
+| `test_latency` | `UniLabJsonCommand` |
+| `create_resource` | `ResourceCreateFromOuterEasy` |
+| `auto-test_resource` | `UniLabJsonCommand` |
+| `manual_confirm` | `UniLabJsonCommand` |
+
+### 10. 查询任务状态
+
+```bash
+curl -s -X GET "$BASE/api/v1/lab/mcp/task/<task_uuid>" -H "$AUTH"
+```
+
+### 11. 运行工作流单节点
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/mcp/run/workflow/action" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"node_uuid":"<node_uuid>"}'
+```
+
+### 12. 获取资源树（物料信息）
+
+```bash
+curl -s -X GET "$BASE/api/v1/lab/material/download/$lab_uuid" -H "$AUTH"
+```
+
+注意 `lab_uuid` 在路径中。返回 `data.nodes[]` 含所有节点（设备 + 物料），每个节点含 `name`、`uuid`、`type`、`parent`。
+
+### 13. 获取工作流模板详情
+
+```bash
+curl -s -X GET "$BASE/api/v1/lab/workflow/template/detail/$workflow_uuid" -H "$AUTH"
+```
+
+> 必须使用 `/lab/workflow/template/detail/{uuid}`，其他路径会返回 404。
+
+### 14. 按名称查询物料模板
+
+```bash
+curl -s -X GET "$BASE/api/v1/lab/material/template/by-name?lab_uuid=$lab_uuid&name=<template_name>" -H "$AUTH"
+```
+
+返回 `data.uuid` 为 `res_template_uuid`，用于 API #15。
+
+### 15. 创建物料节点
+
+```bash
+curl -s -X POST "$BASE/api/v1/edge/material/node" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"res_template_uuid":"<uuid>","name":"<名称>","display_name":"<显示名>","parent_uuid":"<父节点uuid>","data":{...}}'
+```
+
+### 16. 更新物料节点
+
+```bash
+curl -s -X PUT "$BASE/api/v1/edge/material/node" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"uuid":"<节点uuid>","display_name":"<新名称>","data":{...}}'
+```
+
+---
+
+## Placeholder Slot 填写规则
+
+| `placeholder_keys` 值 | Slot 类型    | 填写格式                                              | 选取范围               |
+| --------------------- | ------------ | ----------------------------------------------------- | ---------------------- |
+| `unilabos_resources`  | ResourceSlot | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` | 仅物料节点（非设备）   |
+| `unilabos_devices`    | DeviceSlot   | `"/parent/device_name"`                               | 仅设备节点（type=device） |
+| `unilabos_nodes`      | NodeSlot     | `"/parent/node_name"`                                 | 所有节点（设备 + 物料）   |
+| `unilabos_class`      | ClassSlot    | `"class_name"`                                        | 注册表中已注册的资源类    |
+
+### host_node 设备的 Slot 字段表
+
+| Action            | 字段        | Slot 类型    | 说明                           |
+| ----------------- | ----------- | ------------ | ------------------------------ |
+| `create_resource` | `res_id`    | ResourceSlot | 新资源路径（可填不存在的路径） |
+| `create_resource` | `device_id` | DeviceSlot   | 归属设备                       |
+| `create_resource` | `parent`    | NodeSlot     | 父节点路径                     |
+| `create_resource` | `class_name`| ClassSlot    | 资源类名如 `"container"`       |
+| `auto-test_resource` | `resource`  | ResourceSlot | 单个测试物料                |
+| `auto-test_resource` | `resources` | ResourceSlot | 测试物料数组                |
+| `auto-test_resource` | `device`    | DeviceSlot   | 测试设备                    |
+| `auto-test_resource` | `devices`   | DeviceSlot   | 测试设备                    |
+
+---
+
+## 渐进加载策略
+
+1. **SKILL.md**（本文件）— API 端点 + session state 管理
+2. **[action-index.md](action-index.md)** — 按分类浏览 4 个动作的描述和核心参数
+3. **[actions/\<name\>.json](actions/)** — 仅在需要构建具体请求时，加载对应 action 的完整 JSON Schema
+
+---
+
+## 完整工作流 Checklist
+
+```
+Task Progress:
+- [ ] Step 1: GET /edge/lab/info 获取 lab_uuid
+- [ ] Step 2: 获取资源树 (GET #12) → 记住可用物料
+- [ ] Step 3: 读 action-index.md 确定要用的 action 名
+- [ ] Step 4: 创建工作流 (POST #2) → 记住 workflow_uuid，告知用户链接
+- [ ] Step 5: 创建节点 (POST #3, resource_template_name=host_node) → 记住 node_uuid + data.param
+- [ ] Step 6: 根据 _unilabos_placeholder_info 和资源树，填写 data.param 中的 Slot 字段
+- [ ] Step 7: 更新节点参数 (PATCH #5)
+- [ ] Step 8: 查询节点 handles (POST #6) → 获取各节点的 handle_uuid
+- [ ] Step 9: 批量创建边 (POST #7) → 用 handle_uuid 连接节点
+- [ ] Step 10: 启动工作流 (POST #8) 或运行单节点 (POST #11)
+- [ ] Step 11: 查询任务状态 (GET #10) 确认完成
+```
--- a/.cursor/skills/host-node/action-index.md
+++ b/.cursor/skills/host-node/action-index.md
@@ -0,0 +1,58 @@
+# Action Index — host_node
+
+4 个动作，按功能分类。每个动作的完整 JSON Schema 在 `actions/<name>.json`。
+
+---
+
+## 资源管理
+
+### `create_resource`
+
+在资源树中创建新资源（容器、物料等），支持指定位置、类型和初始液体
+
+- **action_type**: `ResourceCreateFromOuterEasy`
+- **Schema**: [`actions/create_resource.json`](actions/create_resource.json)
+- **可选参数**: `res_id`, `device_id`, `class_name`, `parent`, `bind_locations`, `liquid_input_slot`, `liquid_type`, `liquid_volume`, `slot_on_deck`
+- **占位符字段**:
+  - `res_id` — **ResourceSlot**（特例：目标物料可能尚不存在，直接填期望路径）
+  - `device_id` — **DeviceSlot**，填路径字符串如 `"/host_node"`
+  - `parent` — **NodeSlot**，填路径字符串如 `"/workstation/deck"`
+  - `class_name` — **ClassSlot**，填类名如 `"container"`
+
+### `auto-test_resource`
+
+测试资源系统，返回当前资源树和设备列表
+
+- **action_type**: `UniLabJsonCommand`
+- **Schema**: [`actions/test_resource.json`](actions/test_resource.json)
+- **可选参数**: `resource`, `resources`, `device`, `devices`
+- **占位符字段**:
+  - `resource` — **ResourceSlot**，单个物料节点 `{id, name, uuid}`
+  - `resources` — **ResourceSlot**，物料节点数组 `[{id, name, uuid}, ...]`
+  - `device` — **DeviceSlot**，设备路径字符串
+  - `devices` — **DeviceSlot**，设备路径字符串
+
+---
+
+## 系统工具
+
+### `test_latency`
+
+测试设备通信延迟，返回 RTT、时间差、任务延迟等指标
+
+- **action_type**: `UniLabJsonCommand`
+- **Schema**: [`actions/test_latency.json`](actions/test_latency.json)
+- **参数**: 无（零参数调用）
+
+---
+
+## 人工确认
+
+### `manual_confirm`
+
+创建人工确认节点，等待用户手动确认后继续
+
+- **action_type**: `UniLabJsonCommand`
+- **Schema**: [`actions/manual_confirm.json`](actions/manual_confirm.json)
+- **核心参数**: `timeout_seconds`（超时时间，秒）, `assignee_user_ids`（指派用户 ID 列表）
+- **占位符字段**: `assignee_user_ids` — `unilabos_manual_confirm` 类型
--- a/.cursor/skills/host-node/actions/create_resource.json
+++ b/.cursor/skills/host-node/actions/create_resource.json
@@ -0,0 +1,93 @@
+{
+  "type": "ResourceCreateFromOuterEasy",
+  "goal": {
+    "res_id": "res_id",
+    "class_name": "class_name",
+    "parent": "parent",
+    "device_id": "device_id",
+    "bind_locations": "bind_locations",
+    "liquid_input_slot": "liquid_input_slot[]",
+    "liquid_type": "liquid_type[]",
+    "liquid_volume": "liquid_volume[]",
+    "slot_on_deck": "slot_on_deck"
+  },
+  "schema": {
+    "type": "object",
+    "properties": {
+      "res_id": {
+        "type": "string"
+      },
+      "device_id": {
+        "type": "string"
+      },
+      "class_name": {
+        "type": "string"
+      },
+      "parent": {
+        "type": "string"
+      },
+      "bind_locations": {
+        "type": "object",
+        "properties": {
+          "x": {
+            "type": "number",
+            "minimum": -1.7976931348623157e+308,
+            "maximum": 1.7976931348623157e+308
+          },
+          "y": {
+            "type": "number",
+            "minimum": -1.7976931348623157e+308,
+            "maximum": 1.7976931348623157e+308
+          },
+          "z": {
+            "type": "number",
+            "minimum": -1.7976931348623157e+308,
+            "maximum": 1.7976931348623157e+308
+          }
+        },
+        "required": [
+          "x",
+          "y",
+          "z"
+        ],
+        "title": "bind_locations",
+        "additionalProperties": false
+      },
+      "liquid_input_slot": {
+        "type": "array",
+        "items": {
+          "type": "integer"
+        }
+      },
+      "liquid_type": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      },
+      "liquid_volume": {
+        "type": "array",
+        "items": {
+          "type": "number"
+        }
+      },
+      "slot_on_deck": {
+        "type": "string"
+      }
+    },
+    "required": [],
+    "_unilabos_placeholder_info": {
+      "res_id": "unilabos_resources",
+      "device_id": "unilabos_devices",
+      "parent": "unilabos_nodes",
+      "class_name": "unilabos_class"
+    }
+  },
+  "goal_default": {},
+  "placeholder_keys": {
+    "res_id": "unilabos_resources",
+    "device_id": "unilabos_devices",
+    "parent": "unilabos_nodes",
+    "class_name": "unilabos_class"
+  }
+}
--- a/.cursor/skills/host-node/actions/manual_confirm.json
+++ b/.cursor/skills/host-node/actions/manual_confirm.json
@@ -0,0 +1,32 @@
+{
+  "type": "UniLabJsonCommand",
+  "goal": {
+    "timeout_seconds": "timeout_seconds",
+    "assignee_user_ids": "assignee_user_ids"
+  },
+  "schema": {
+    "type": "object",
+    "properties": {
+      "timeout_seconds": {
+        "type": "integer"
+      },
+      "assignee_user_ids": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
+    "required": [
+      "timeout_seconds",
+      "assignee_user_ids"
+    ],
+    "_unilabos_placeholder_info": {
+      "assignee_user_ids": "unilabos_manual_confirm"
+    }
+  },
+  "goal_default": {},
+  "placeholder_keys": {
+    "assignee_user_ids": "unilabos_manual_confirm"
+  }
+}
--- a/.cursor/skills/host-node/actions/test_latency.json
+++ b/.cursor/skills/host-node/actions/test_latency.json
@@ -0,0 +1,11 @@
+{
+  "type": "UniLabJsonCommand",
+  "goal": {},
+  "schema": {
+    "type": "object",
+    "properties": {},
+    "required": []
+  },
+  "goal_default": {},
+  "placeholder_keys": {}
+}
--- a/.cursor/skills/host-node/actions/test_resource.json
+++ b/.cursor/skills/host-node/actions/test_resource.json
@@ -0,0 +1,255 @@
+{
+  "type": "UniLabJsonCommand",
+  "goal": {
+    "resource": "resource",
+    "resources": "resources",
+    "device": "device",
+    "devices": "devices"
+  },
+  "schema": {
+    "type": "object",
+    "properties": {
+      "resource": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          },
+          "sample_id": {
+            "type": "string"
+          },
+          "children": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "parent": {
+            "type": "string"
+          },
+          "type": {
+            "type": "string"
+          },
+          "category": {
+            "type": "string"
+          },
+          "pose": {
+            "type": "object",
+            "properties": {
+              "position": {
+                "type": "object",
+                "properties": {
+                  "x": {
+                    "type": "number",
+                    "minimum": -1.7976931348623157e+308,
+                    "maximum": 1.7976931348623157e+308
+                  },
+                  "y": {
+                    "type": "number",
+                    "minimum": -1.7976931348623157e+308,
+                    "maximum": 1.7976931348623157e+308
+                  },
+                  "z": {
+                    "type": "number",
+                    "minimum": -1.7976931348623157e+308,
+                    "maximum": 1.7976931348623157e+308
+                  }
+                },
+                "required": [
+                  "x",
+                  "y",
+                  "z"
+                ],
+                "title": "position",
+                "additionalProperties": false
+              },
+              "orientation": {
+                "type": "object",
+                "properties": {
+                  "x": {
+                    "type": "number",
+                    "minimum": -1.7976931348623157e+308,
+                    "maximum": 1.7976931348623157e+308
+                  },
+                  "y": {
+                    "type": "number",
+                    "minimum": -1.7976931348623157e+308,
+                    "maximum": 1.7976931348623157e+308
+                  },
+                  "z": {
+                    "type": "number",
+                    "minimum": -1.7976931348623157e+308,
+                    "maximum": 1.7976931348623157e+308
+                  },
+                  "w": {
+                    "type": "number",
+                    "minimum": -1.7976931348623157e+308,
+                    "maximum": 1.7976931348623157e+308
+                  }
+                },
+                "required": [
+                  "x",
+                  "y",
+                  "z",
+                  "w"
+                ],
+                "title": "orientation",
+                "additionalProperties": false
+              }
+            },
+            "required": [
+              "position",
+              "orientation"
+            ],
+            "title": "pose",
+            "additionalProperties": false
+          },
+          "config": {
+            "type": "string"
+          },
+          "data": {
+            "type": "string"
+          }
+        },
+        "title": "resource"
+      },
+      "resources": {
+        "items": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "name": {
+              "type": "string"
+            },
+            "sample_id": {
+              "type": "string"
+            },
+            "children": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "parent": {
+              "type": "string"
+            },
+            "type": {
+              "type": "string"
+            },
+            "category": {
+              "type": "string"
+            },
+            "pose": {
+              "type": "object",
+              "properties": {
+                "position": {
+                  "type": "object",
+                  "properties": {
+                    "x": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "y": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "z": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    }
+                  },
+                  "required": [
+                    "x",
+                    "y",
+                    "z"
+                  ],
+                  "title": "position",
+                  "additionalProperties": false
+                },
+                "orientation": {
+                  "type": "object",
+                  "properties": {
+                    "x": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "y": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "z": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "w": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    }
+                  },
+                  "required": [
+                    "x",
+                    "y",
+                    "z",
+                    "w"
+                  ],
+                  "title": "orientation",
+                  "additionalProperties": false
+                }
+              },
+              "required": [
+                "position",
+                "orientation"
+              ],
+              "title": "pose",
+              "additionalProperties": false
+            },
+            "config": {
+              "type": "string"
+            },
+            "data": {
+              "type": "string"
+            }
+          },
+          "title": "resources"
+        },
+        "type": "array"
+      },
+      "device": {
+        "type": "string",
+        "description": "device reference"
+      },
+      "devices": {
+        "type": "string",
+        "description": "device reference"
+      }
+    },
+    "required": [],
+    "_unilabos_placeholder_info": {
+      "resource": "unilabos_resources",
+      "resources": "unilabos_resources",
+      "device": "unilabos_devices",
+      "devices": "unilabos_devices"
+    }
+  },
+  "goal_default": {},
+  "placeholder_keys": {
+    "resource": "unilabos_resources",
+    "resources": "unilabos_resources",
+    "device": "unilabos_devices",
+    "devices": "unilabos_devices"
+  }
+}
--- a/.cursor/skills/submit-agent-result/SKILL.md
+++ b/.cursor/skills/submit-agent-result/SKILL.md
@@ -0,0 +1,284 @@
+---
+name: submit-agent-result
+description: Submit historical experiment results (agent_result) to Uni-Lab cloud platform (leap-lab) notebook — read data files, assemble JSON payload, PUT to cloud API. Use when the user wants to submit experiment results, upload agent results, report experiment data, or mentions agent_result/实验结果/历史记录/notebook结果.
+---
+
+# Uni-Lab 提交历史实验记录指南
+
+通过 Uni-Lab 云端 API 向已创建的 notebook 提交实验结果数据（agent_result）。支持从 JSON / CSV 文件读取数据，整合后提交。
+
+> **重要**：本指南中的 `Authorization: Lab <token>` 是 **Uni-Lab 平台专用的认证方式**，`Lab` 是 Uni-Lab 的 auth scheme 关键字，**不是** HTTP Basic 认证。请勿将其替换为 `Basic`。
+
+## 前置条件（缺一不可）
+
+使用本指南前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
+
+### 1. ak / sk → AUTH
+
+询问用户的启动参数，从 `--ak` `--sk` 或 config.py 中获取。
+
+生成 AUTH token：
+
+```bash
+# ⚠️ 注意：scheme 是 "Lab"（Uni-Lab 专用），不是 "Basic"
+python -c "import base64,sys; print(base64.b64encode(f'{sys.argv[1]}:{sys.argv[2]}'.encode()).decode())" <ak> <sk>
+```
+
+输出即为 token 值，拼接为 `Authorization: Lab <token>`（`Lab` 是 Uni-Lab 平台 auth scheme，不可替换为 `Basic`）。
+
+### 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 scheme 必须是 "Lab"（Uni-Lab 专用），不是 "Basic"
+AUTH="Authorization: Lab <上面命令输出的 token>"
+```
+
+### 3. notebook_uuid（**必须询问用户**）
+
+**必须主动询问用户**：「请提供要提交结果的 notebook UUID。」
+
+notebook_uuid 来自之前通过「批量提交实验」创建的实验批次，即 `POST /api/v1/lab/notebook` 返回的 `data.uuid`。
+
+如果用户不记得，可提示：
+
+- 查看之前的对话记录中创建 notebook 时返回的 UUID
+- 或通过平台页面查找对应的 notebook
+
+**绝不能跳过此步骤，没有 notebook_uuid 无法提交。**
+
+### 4. 实验结果数据
+
+用户需要提供实验结果数据，支持以下方式：
+
+| 方式      | 说明                                            |
+| --------- | ----------------------------------------------- |
+| JSON 文件 | 直接作为 `agent_result` 的内容合并              |
+| CSV 文件  | 转为 `{"文件名": [行数据...]}` 格式             |
+| 手动指定  | 用户直接告知 key-value 数据，由 agent 构建 JSON |
+
+**四项全部就绪后才可开始。**
+
+## Session State
+
+在整个对话过程中，agent 需要记住以下状态：
+
+- `lab_uuid` — 实验室 UUID（通过 API #1 自动获取，**不需要问用户**）
+- `notebook_uuid` — 目标 notebook UUID（**必须询问用户**）
+
+## 请求约定
+
+所有请求使用 `curl -s`，PUT 需加 `Content-Type: application/json`。
+
+> **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名），示例中的 `curl` 均指 `curl.exe`。
+>
+> **PowerShell JSON 传参**：PowerShell 中 `-d '{"key":"value"}'` 会因引号转义失败。请将 JSON 写入临时文件，用 `-d '@tmp_body.json'`（单引号包裹 `@`，否则 `@` 会被 PowerShell 解析为 splatting 运算符导致报错）。
+
+---
+
+## API Endpoints
+
+### 1. 获取实验室信息（自动获取 lab_uuid）
+
+```bash
+curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
+```
+
+返回：
+
+```json
+{ "code": 0, "data": { "uuid": "xxx", "name": "实验室名称" } }
+```
+
+记住 `data.uuid` 为 `lab_uuid`。
+
+### 2. 提交实验结果（agent_result）
+
+```bash
+curl -s -X PUT "$BASE/api/v1/lab/notebook/agent-result" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '<request_body>'
+```
+
+请求体结构：
+
+```json
+{
+    "notebook_uuid": "<notebook_uuid>",
+    "agent_result": {
+        "<key1>": "<value1>",
+        "<key2>": 123,
+        "<nested_key>": {"a": 1, "b": 2},
+        "<array_key>": [{"col1": "v1", "col2": "v2"}, ...]
+    }
+}
+```
+
+> **注意**：HTTP 方法是 **PUT**（不是 POST）。
+
+#### 必要字段
+
+| 字段            | 类型          | 说明                                        |
+| --------------- | ------------- | ------------------------------------------- |
+| `notebook_uuid` | string (UUID) | 目标 notebook 的 UUID，从批量提交实验时获取 |
+| `agent_result`  | object        | 实验结果数据，任意 JSON 对象                |
+
+#### agent_result 内容格式
+
+`agent_result` 接受**任意 JSON 对象**，常见格式：
+
+**简单键值对**：
+
+```json
+{
+  "avg_rtt_ms": 12.5,
+  "status": "success",
+  "test_count": 5
+}
+```
+
+**包含嵌套结构**：
+
+```json
+{
+  "summary": { "total": 100, "passed": 98, "failed": 2 },
+  "measurements": [
+    { "sample_id": "S001", "value": 3.14, "unit": "mg/mL" },
+    { "sample_id": "S002", "value": 2.71, "unit": "mg/mL" }
+  ]
+}
+```
+
+**从 CSV 文件导入**（脚本自动转换）：
+
+```json
+{
+  "experiment_data": [
+    { "温度": 25, "压力": 101.3, "产率": 0.85 },
+    { "温度": 30, "压力": 101.3, "产率": 0.91 }
+  ]
+}
+```
+
+---
+
+## 整合脚本
+
+本文档同级目录下的 `scripts/prepare_agent_result.py` 可自动读取文件并构建请求体。
+
+### 用法
+
+```bash
+python scripts/prepare_agent_result.py \
+    --notebook-uuid <uuid> \
+    --files data1.json data2.csv \
+    [--auth <token>] \
+    [--base <BASE_URL>] \
+    [--submit] \
+    [--output <output.json>]
+```
+
+| 参数              | 必选       | 说明                                            |
+| ----------------- | ---------- | ----------------------------------------------- |
+| `--notebook-uuid` | 是         | 目标 notebook UUID                              |
+| `--files`         | 是         | 输入文件路径（支持多个，JSON / CSV）            |
+| `--auth`          | 提交时必选 | Lab token（base64(ak:sk)）                      |
+| `--base`          | 提交时必选 | API base URL                                    |
+| `--submit`        | 否         | 加上此标志则直接提交到云端                      |
+| `--output`        | 否         | 输出 JSON 路径（默认 `agent_result_body.json`） |
+
+### 文件合并规则
+
+| 文件类型              | 合并方式                                     |
+| --------------------- | -------------------------------------------- |
+| `.json`（dict）       | 字段直接合并到 `agent_result` 顶层           |
+| `.json`（list/other） | 以文件名为 key 放入 `agent_result`           |
+| `.csv`                | 以文件名（不含扩展名）为 key，值为行对象数组 |
+
+多个文件的字段会合并。JSON dict 中的重复 key 后者覆盖前者。
+
+### 示例
+
+```bash
+# 仅生成请求体文件（不提交）
+python scripts/prepare_agent_result.py \
+    --notebook-uuid 73c67dca-c8cc-4936-85a0-329106aa7cca \
+    --files results.json measurements.csv
+
+# 生成并直接提交
+python scripts/prepare_agent_result.py \
+    --notebook-uuid 73c67dca-c8cc-4936-85a0-329106aa7cca \
+    --files results.json \
+    --auth YTFmZDlkNGUt... \
+    --base https://leap-lab.test.bohrium.com \
+    --submit
+```
+
+---
+
+## 手动构建方式
+
+如果不使用脚本，也可手动构建请求体：
+
+1. 将实验结果数据组装为 JSON 对象
+2. 写入临时文件：
+
+```json
+{
+    "notebook_uuid": "<uuid>",
+    "agent_result": { ... }
+}
+```
+
+3. 用 curl 提交：
+
+```bash
+curl -s -X PUT "$BASE/api/v1/lab/notebook/agent-result" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '@tmp_body.json'
+```
+
+---
+
+## 完整工作流 Checklist
+
+```
+Task Progress:
+- [ ] Step 1: 确认 ak/sk → 生成 AUTH token
+- [ ] Step 2: 确认 --addr → 设置 BASE URL
+- [ ] Step 3: GET /edge/lab/info → 获取 lab_uuid
+- [ ] Step 4: **询问用户** notebook_uuid（必须，不可跳过）
+- [ ] Step 5: 确认实验结果数据来源（文件路径或手动数据）
+- [ ] Step 6: 运行 prepare_agent_result.py 或手动构建请求体
+- [ ] Step 7: PUT /lab/notebook/agent-result 提交
+- [ ] Step 8: 检查返回结果，确认提交成功
+```
+
+---
+
+## 常见问题
+
+### Q: notebook_uuid 从哪里获取？
+
+从之前「批量提交实验」时 `POST /api/v1/lab/notebook` 的返回值 `data.uuid` 获取。也可以在平台 UI 中查找对应的 notebook。
+
+### Q: agent_result 有固定的 schema 吗？
+
+没有严格 schema，接受任意 JSON 对象。但建议包含有意义的字段名和结构化数据，方便后续分析。
+
+### Q: 可以多次提交同一个 notebook 的结果吗？
+
+可以，后续提交会覆盖之前的 agent_result。
+
+### Q: 认证方式是 Lab 还是 Api？
+
+本指南统一使用 `Authorization: Lab <base64(ak:sk)>` 方式（`Lab` 是 Uni-Lab 平台的 auth scheme，**绝不能用 `Basic` 替代**）。如果用户有独立的 API Key，也可用 `Authorization: Api <key>` 替代。
--- a/.cursor/skills/submit-agent-result/scripts/prepare_agent_result.py
+++ b/.cursor/skills/submit-agent-result/scripts/prepare_agent_result.py
@@ -0,0 +1,133 @@
+"""
+读取实验结果文件（JSON / CSV），整合为 agent_result 请求体并可选提交。
+
+用法:
+    python prepare_agent_result.py \
+        --notebook-uuid <uuid> \
+        --files data1.json data2.csv \
+        [--auth <Lab token>] \
+        [--base <BASE_URL>] \
+        [--submit] \
+        [--output <output.json>]
+
+支持的输入文件格式:
+    - .json  → 直接作为 dict 合并
+    - .csv   → 转为 {"filename": [row_dict, ...]} 格式
+"""
+
+import argparse
+import base64
+import csv
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+def read_json_file(filepath: str) -> Dict[str, Any]:
+    with open(filepath, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def read_csv_file(filepath: str) -> List[Dict[str, Any]]:
+    rows = []
+    with open(filepath, "r", encoding="utf-8-sig") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            converted = {}
+            for k, v in row.items():
+                try:
+                    converted[k] = int(v)
+                except (ValueError, TypeError):
+                    try:
+                        converted[k] = float(v)
+                    except (ValueError, TypeError):
+                        converted[k] = v
+            rows.append(converted)
+    return rows
+
+
+def merge_files(filepaths: List[str]) -> Dict[str, Any]:
+    """将多个文件合并为一个 agent_result dict"""
+    merged: Dict[str, Any] = {}
+    for fp in filepaths:
+        path = Path(fp)
+        ext = path.suffix.lower()
+        key = path.stem
+
+        if ext == ".json":
+            data = read_json_file(fp)
+            if isinstance(data, dict):
+                merged.update(data)
+            else:
+                merged[key] = data
+        elif ext == ".csv":
+            merged[key] = read_csv_file(fp)
+        else:
+            print(f"[警告] 不支持的文件格式: {fp}，跳过", file=sys.stderr)
+
+    return merged
+
+
+def build_request_body(notebook_uuid: str, agent_result: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "notebook_uuid": notebook_uuid,
+        "agent_result": agent_result,
+    }
+
+
+def submit(base: str, auth: str, body: Dict[str, Any]) -> Dict[str, Any]:
+    try:
+        import requests
+    except ImportError:
+        print("[错误] 提交需要 requests 库: pip install requests", file=sys.stderr)
+        sys.exit(1)
+
+    url = f"{base}/api/v1/lab/notebook/agent-result"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Lab {auth}",
+    }
+    resp = requests.put(url, json=body, headers=headers, timeout=30)
+    return {"status_code": resp.status_code, "body": resp.json() if resp.headers.get("content-type", "").startswith("application/json") else resp.text}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="整合实验结果文件并构建 agent_result 请求体")
+    parser.add_argument("--notebook-uuid", required=True, help="目标 notebook UUID")
+    parser.add_argument("--files", nargs="+", required=True, help="输入文件路径（JSON / CSV）")
+    parser.add_argument("--auth", help="Lab token（base64(ak:sk)）")
+    parser.add_argument("--base", help="API base URL")
+    parser.add_argument("--submit", action="store_true", help="直接提交到云端")
+    parser.add_argument("--output", default="agent_result_body.json", help="输出 JSON 文件路径")
+
+    args = parser.parse_args()
+
+    for fp in args.files:
+        if not os.path.exists(fp):
+            print(f"[错误] 文件不存在: {fp}", file=sys.stderr)
+            sys.exit(1)
+
+    agent_result = merge_files(args.files)
+    body = build_request_body(args.notebook_uuid, agent_result)
+
+    with open(args.output, "w", encoding="utf-8") as f:
+        json.dump(body, f, ensure_ascii=False, indent=2)
+    print(f"[完成] 请求体已保存: {args.output}")
+    print(f"  notebook_uuid: {args.notebook_uuid}")
+    print(f"  agent_result 字段数: {len(agent_result)}")
+    print(f"  合并文件数: {len(args.files)}")
+
+    if args.submit:
+        if not args.auth or not args.base:
+            print("[错误] 提交需要 --auth 和 --base 参数", file=sys.stderr)
+            sys.exit(1)
+        print(f"\n[提交] PUT {args.base}/api/v1/lab/notebook/agent-result ...")
+        result = submit(args.base, args.auth, body)
+        print(f"  HTTP {result['status_code']}")
+        print(f"  响应: {json.dumps(result['body'], ensure_ascii=False)}")
+
+
+if __name__ == "__main__":
+    main()
--- a/.cursor/skills/virtual-workbench/SKILL.md
+++ b/.cursor/skills/virtual-workbench/SKILL.md
@@ -0,0 +1,272 @@
+---
+name: virtual-workbench
+description: Operate Virtual Workbench via REST API — prepare materials, move to heating stations, start heating, move to output, transfer resources. Use when the user mentions virtual workbench, virtual_workbench, 虚拟工作台, heating stations, material processing, or workbench operations.
+---
+
+# Virtual Workbench API Skill
+
+## 设备信息
+
+- **device_id**: `virtual_workbench`
+- **Python 源码**: `unilabos/devices/virtual/workbench.py`
+- **设备类**: `VirtualWorkbench`
+- **动作数**: 6（`auto-prepare_materials`, `auto-move_to_heating_station`, `auto-start_heating`, `auto-move_to_output`, `transfer`, `manual_confirm`）
+- **设备描述**: 模拟工作台，包含 1 个机械臂（每次操作 2s，独占锁）和 3 个加热台（每次加热 60s，可并行）
+
+### 典型工作流程
+
+1. `prepare_materials` — 生成 A1-A5 物料（5 个 output handle）
+2. `move_to_heating_station` — 物料并发竞争机械臂，移动到空闲加热台
+3. `start_heating` — 启动加热（3 个加热台可并行）
+4. `move_to_output` — 加热完成后移到输出位置 Cn
+
+## 前置条件（缺一不可）
+
+使用本 skill 前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
+
+### 1. ak / sk → AUTH
+
+从启动参数 `--ak` `--sk` 或 config.py 中获取，生成 token：`base64(ak:sk)` → `Authorization: Lab <token>`
+
+### 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>"
+```
+
+**两项全部就绪后才可发起 API 请求。**
+
+## Session State
+
+- `lab_uuid` — 实验室 UUID（首次通过 API #1 自动获取，**不需要问用户**）
+- `device_name` — `virtual_workbench`
+
+## 请求约定
+
+所有请求使用 `curl -s`，POST/PATCH/DELETE 需加 `Content-Type: application/json`。
+
+> **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名）。
+
+---
+
+## API Endpoints
+
+### 1. 获取实验室信息（自动获取 lab_uuid）
+
+```bash
+curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
+```
+
+返回 `data.uuid` 为 `lab_uuid`，`data.name` 为 `lab_name`。
+
+### 2. 创建工作流
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/workflow/owner" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"name":"<名称>","lab_uuid":"<lab_uuid>","description":"<描述>"}'
+```
+
+返回 `data.uuid` 为 `workflow_uuid`。创建成功后告知用户链接：`$BASE/laboratory/$lab_uuid/workflow/$workflow_uuid`
+
+### 3. 创建节点
+
+```bash
+curl -s -X POST "$BASE/api/v1/edge/workflow/node" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"workflow_uuid":"<workflow_uuid>","resource_template_name":"virtual_workbench","node_template_name":"<action_name>"}'
+```
+
+- `resource_template_name` 固定为 `virtual_workbench`
+- `node_template_name` — action 名称（如 `auto-prepare_materials`, `auto-move_to_heating_station`）
+
+### 4. 删除节点
+
+```bash
+curl -s -X DELETE "$BASE/api/v1/lab/workflow/nodes" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"node_uuids":["<uuid1>"],"workflow_uuid":"<workflow_uuid>"}'
+```
+
+### 5. 更新节点参数
+
+```bash
+curl -s -X PATCH "$BASE/api/v1/lab/workflow/node" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"workflow_uuid":"<wf_uuid>","uuid":"<node_uuid>","param":{...}}'
+```
+
+参考 [action-index.md](action-index.md) 确定哪些字段是 Slot。
+
+### 6. 查询节点 handles
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/workflow/node-handles" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"node_uuids":["<node_uuid_1>","<node_uuid_2>"]}'
+```
+
+### 7. 批量创建边
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/workflow/edges" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"edges":[{"source_node_uuid":"<uuid>","target_node_uuid":"<uuid>","source_handle_uuid":"<uuid>","target_handle_uuid":"<uuid>"}]}'
+```
+
+### 8. 启动工作流
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/workflow/<workflow_uuid>/run" -H "$AUTH"
+```
+
+### 9. 运行设备单动作
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/mcp/run/action" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"lab_uuid":"<lab_uuid>","device_id":"virtual_workbench","action":"<action_name>","action_type":"<type>","param":{...}}'
+```
+
+`param` 直接放 goal 里的属性，**不要**再包一层 `{"goal": {...}}`。
+
+> **WARNING: `action_type` 必须正确，传错会导致任务永远卡住无法完成。** 从下表或 `actions/<name>.json` 的 `type` 字段获取。
+
+#### action_type 速查表
+
+| action | action_type |
+|--------|-------------|
+| `auto-prepare_materials` | `UniLabJsonCommand` |
+| `auto-move_to_heating_station` | `UniLabJsonCommand` |
+| `auto-start_heating` | `UniLabJsonCommand` |
+| `auto-move_to_output` | `UniLabJsonCommand` |
+| `transfer` | `UniLabJsonCommandAsync` |
+| `manual_confirm` | `UniLabJsonCommand` |
+
+### 10. 查询任务状态
+
+```bash
+curl -s -X GET "$BASE/api/v1/lab/mcp/task/<task_uuid>" -H "$AUTH"
+```
+
+### 11. 运行工作流单节点
+
+```bash
+curl -s -X POST "$BASE/api/v1/lab/mcp/run/workflow/action" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"node_uuid":"<node_uuid>"}'
+```
+
+### 12. 获取资源树（物料信息）
+
+```bash
+curl -s -X GET "$BASE/api/v1/lab/material/download/$lab_uuid" -H "$AUTH"
+```
+
+注意 `lab_uuid` 在路径中。返回 `data.nodes[]` 含所有节点（设备 + 物料），每个节点含 `name`、`uuid`、`type`、`parent`。
+
+### 13. 获取工作流模板详情
+
+```bash
+curl -s -X GET "$BASE/api/v1/lab/workflow/template/detail/$workflow_uuid" -H "$AUTH"
+```
+
+> 必须使用 `/lab/workflow/template/detail/{uuid}`，其他路径会返回 404。
+
+### 14. 按名称查询物料模板
+
+```bash
+curl -s -X GET "$BASE/api/v1/lab/material/template/by-name?lab_uuid=$lab_uuid&name=<template_name>" -H "$AUTH"
+```
+
+返回 `data.uuid` 为 `res_template_uuid`，用于 API #15。
+
+### 15. 创建物料节点
+
+```bash
+curl -s -X POST "$BASE/api/v1/edge/material/node" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"res_template_uuid":"<uuid>","name":"<名称>","display_name":"<显示名>","parent_uuid":"<父节点uuid>","data":{...}}'
+```
+
+### 16. 更新物料节点
+
+```bash
+curl -s -X PUT "$BASE/api/v1/edge/material/node" \
+  -H "$AUTH" -H "Content-Type: application/json" \
+  -d '{"uuid":"<节点uuid>","display_name":"<新名称>","data":{...}}'
+```
+
+---
+
+## Placeholder Slot 填写规则
+
+| `placeholder_keys` 值 | Slot 类型    | 填写格式                                              | 选取范围               |
+| --------------------- | ------------ | ----------------------------------------------------- | ---------------------- |
+| `unilabos_resources`  | ResourceSlot | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` | 仅物料节点（非设备）   |
+| `unilabos_devices`    | DeviceSlot   | `"/parent/device_name"`                               | 仅设备节点（type=device） |
+| `unilabos_nodes`      | NodeSlot     | `"/parent/node_name"`                                 | 所有节点（设备 + 物料）   |
+| `unilabos_class`      | ClassSlot    | `"class_name"`                                        | 注册表中已注册的资源类    |
+
+### virtual_workbench 设备的 Slot 字段表
+
+| Action            | 字段             | Slot 类型    | 说明                 |
+| ----------------- | ---------------- | ------------ | -------------------- |
+| `transfer`        | `resource`       | ResourceSlot | 待转移物料数组       |
+| `transfer`        | `target_device`  | DeviceSlot   | 目标设备路径         |
+| `transfer`        | `mount_resource` | ResourceSlot | 目标孔位数组         |
+| `manual_confirm`  | `resource`       | ResourceSlot | 确认用物料数组       |
+| `manual_confirm`  | `target_device`  | DeviceSlot   | 确认用目标设备       |
+| `manual_confirm`  | `mount_resource` | ResourceSlot | 确认用目标孔位数组   |
+
+> `prepare_materials`、`move_to_heating_station`、`start_heating`、`move_to_output` 这 4 个动作**无 Slot 字段**，参数为纯数值/整数。
+
+---
+
+## 渐进加载策略
+
+1. **SKILL.md**（本文件）— API 端点 + session state 管理 + 设备工作流概览
+2. **[action-index.md](action-index.md)** — 按分类浏览 6 个动作的描述和核心参数
+3. **[actions/\<name\>.json](actions/)** — 仅在需要构建具体请求时，加载对应 action 的完整 JSON Schema
+
+---
+
+## 完整工作流 Checklist
+
+```
+Task Progress:
+- [ ] Step 1: GET /edge/lab/info 获取 lab_uuid
+- [ ] Step 2: 获取资源树 (GET #12) → 记住可用物料
+- [ ] Step 3: 读 action-index.md 确定要用的 action 名
+- [ ] Step 4: 创建工作流 (POST #2) → 记住 workflow_uuid，告知用户链接
+- [ ] Step 5: 创建节点 (POST #3, resource_template_name=virtual_workbench) → 记住 node_uuid + data.param
+- [ ] Step 6: 根据 _unilabos_placeholder_info 和资源树，填写 data.param 中的 Slot 字段
+- [ ] Step 7: 更新节点参数 (PATCH #5)
+- [ ] Step 8: 查询节点 handles (POST #6) → 获取各节点的 handle_uuid
+- [ ] Step 9: 批量创建边 (POST #7) → 用 handle_uuid 连接节点
+- [ ] Step 10: 启动工作流 (POST #8) 或运行单节点 (POST #11)
+- [ ] Step 11: 查询任务状态 (GET #10) 确认完成
+```
+
+### 典型 5 物料并发加热工作流示例
+
+```
+prepare_materials (count=5)
+  ├─ channel_1 → move_to_heating_station (material_number=1) → start_heating → move_to_output
+  ├─ channel_2 → move_to_heating_station (material_number=2) → start_heating → move_to_output
+  ├─ channel_3 → move_to_heating_station (material_number=3) → start_heating → move_to_output
+  ├─ channel_4 → move_to_heating_station (material_number=4) → start_heating → move_to_output
+  └─ channel_5 → move_to_heating_station (material_number=5) → start_heating → move_to_output
+```
+
+创建节点时，`prepare_materials` 的 5 个 output handle（`channel_1` ~ `channel_5`）分别连接到 5 个 `move_to_heating_station` 节点的 `material_input` handle。每个 `move_to_heating_station` 的 `heating_station_output` 和 `material_number_output` 连接到对应 `start_heating` 的 `station_id_input` 和 `material_number_input`。
--- a/.cursor/skills/virtual-workbench/action-index.md
+++ b/.cursor/skills/virtual-workbench/action-index.md
@@ -0,0 +1,76 @@
+# Action Index — virtual_workbench
+
+6 个动作，按功能分类。每个动作的完整 JSON Schema 在 `actions/<name>.json`。
+
+---
+
+## 物料准备
+
+### `auto-prepare_materials`
+
+批量准备物料（虚拟起始节点），生成 A1-A5 物料编号，输出 5 个 handle 供后续节点使用
+
+- **action_type**: `UniLabJsonCommand`
+- **Schema**: [`actions/prepare_materials.json`](actions/prepare_materials.json)
+- **可选参数**: `count`（物料数量，默认 5）
+
+---
+
+## 机械臂 & 加热台操作
+
+### `auto-move_to_heating_station`
+
+将物料从 An 位置移动到空闲加热台（竞争机械臂，自动查找空闲加热台）
+
+- **action_type**: `UniLabJsonCommand`
+- **Schema**: [`actions/move_to_heating_station.json`](actions/move_to_heating_station.json)
+- **核心参数**: `material_number`（物料编号，integer）
+
+### `auto-start_heating`
+
+启动指定加热台的加热程序（可并行，3 个加热台同时工作）
+
+- **action_type**: `UniLabJsonCommand`
+- **Schema**: [`actions/start_heating.json`](actions/start_heating.json)
+- **核心参数**: `station_id`（加热台 ID），`material_number`（物料编号）
+
+### `auto-move_to_output`
+
+将加热完成的物料从加热台移动到输出位置 Cn
+
+- **action_type**: `UniLabJsonCommand`
+- **Schema**: [`actions/move_to_output.json`](actions/move_to_output.json)
+- **核心参数**: `station_id`（加热台 ID），`material_number`（物料编号）
+
+---
+
+## 物料转移
+
+### `transfer`
+
+异步转移物料到目标设备（通过 ROS 资源转移）
+
+- **action_type**: `UniLabJsonCommandAsync`
+- **Schema**: [`actions/transfer.json`](actions/transfer.json)
+- **核心参数**: `resource`, `target_device`, `mount_resource`
+- **占位符字段**:
+  - `resource` — **ResourceSlot**，待转移的物料数组 `[{id, name, uuid}, ...]`
+  - `target_device` — **DeviceSlot**，目标设备路径字符串
+  - `mount_resource` — **ResourceSlot**，目标孔位数组 `[{id, name, uuid}, ...]`
+
+---
+
+## 人工确认
+
+### `manual_confirm`
+
+创建人工确认节点，等待用户手动确认后继续（含物料转移上下文）
+
+- **action_type**: `UniLabJsonCommand`
+- **Schema**: [`actions/manual_confirm.json`](actions/manual_confirm.json)
+- **核心参数**: `resource`, `target_device`, `mount_resource`, `timeout_seconds`, `assignee_user_ids`
+- **占位符字段**:
+  - `resource` — **ResourceSlot**，物料数组
+  - `target_device` — **DeviceSlot**，目标设备路径
+  - `mount_resource` — **ResourceSlot**，目标孔位数组
+  - `assignee_user_ids` — `unilabos_manual_confirm` 类型
--- a/.cursor/skills/virtual-workbench/actions/manual_confirm.json
+++ b/.cursor/skills/virtual-workbench/actions/manual_confirm.json
@@ -0,0 +1,270 @@
+{
+  "type": "UniLabJsonCommand",
+  "goal": {
+    "resource": "resource",
+    "target_device": "target_device",
+    "mount_resource": "mount_resource",
+    "timeout_seconds": "timeout_seconds",
+    "assignee_user_ids": "assignee_user_ids"
+  },
+  "schema": {
+    "type": "object",
+    "properties": {
+      "resource": {
+        "items": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "name": {
+              "type": "string"
+            },
+            "sample_id": {
+              "type": "string"
+            },
+            "children": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "parent": {
+              "type": "string"
+            },
+            "type": {
+              "type": "string"
+            },
+            "category": {
+              "type": "string"
+            },
+            "pose": {
+              "type": "object",
+              "properties": {
+                "position": {
+                  "type": "object",
+                  "properties": {
+                    "x": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "y": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "z": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    }
+                  },
+                  "required": [
+                    "x",
+                    "y",
+                    "z"
+                  ],
+                  "title": "position",
+                  "additionalProperties": false
+                },
+                "orientation": {
+                  "type": "object",
+                  "properties": {
+                    "x": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "y": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "z": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "w": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    }
+                  },
+                  "required": [
+                    "x",
+                    "y",
+                    "z",
+                    "w"
+                  ],
+                  "title": "orientation",
+                  "additionalProperties": false
+                }
+              },
+              "required": [
+                "position",
+                "orientation"
+              ],
+              "title": "pose",
+              "additionalProperties": false
+            },
+            "config": {
+              "type": "string"
+            },
+            "data": {
+              "type": "string"
+            }
+          },
+          "title": "resource"
+        },
+        "type": "array"
+      },
+      "target_device": {
+        "type": "string",
+        "description": "device reference"
+      },
+      "mount_resource": {
+        "items": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "name": {
+              "type": "string"
+            },
+            "sample_id": {
+              "type": "string"
+            },
+            "children": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "parent": {
+              "type": "string"
+            },
+            "type": {
+              "type": "string"
+            },
+            "category": {
+              "type": "string"
+            },
+            "pose": {
+              "type": "object",
+              "properties": {
+                "position": {
+                  "type": "object",
+                  "properties": {
+                    "x": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "y": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "z": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    }
+                  },
+                  "required": [
+                    "x",
+                    "y",
+                    "z"
+                  ],
+                  "title": "position",
+                  "additionalProperties": false
+                },
+                "orientation": {
+                  "type": "object",
+                  "properties": {
+                    "x": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "y": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "z": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "w": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    }
+                  },
+                  "required": [
+                    "x",
+                    "y",
+                    "z",
+                    "w"
+                  ],
+                  "title": "orientation",
+                  "additionalProperties": false
+                }
+              },
+              "required": [
+                "position",
+                "orientation"
+              ],
+              "title": "pose",
+              "additionalProperties": false
+            },
+            "config": {
+              "type": "string"
+            },
+            "data": {
+              "type": "string"
+            }
+          },
+          "title": "mount_resource"
+        },
+        "type": "array"
+      },
+      "timeout_seconds": {
+        "type": "integer"
+      },
+      "assignee_user_ids": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
+    "required": [
+      "resource",
+      "target_device",
+      "mount_resource",
+      "timeout_seconds",
+      "assignee_user_ids"
+    ],
+    "_unilabos_placeholder_info": {
+      "resource": "unilabos_resources",
+      "target_device": "unilabos_devices",
+      "mount_resource": "unilabos_resources",
+      "assignee_user_ids": "unilabos_manual_confirm"
+    }
+  },
+  "goal_default": {},
+  "placeholder_keys": {
+    "resource": "unilabos_resources",
+    "target_device": "unilabos_devices",
+    "mount_resource": "unilabos_resources",
+    "assignee_user_ids": "unilabos_manual_confirm"
+  }
+}
--- a/.cursor/skills/virtual-workbench/actions/move_to_heating_station.json
+++ b/.cursor/skills/virtual-workbench/actions/move_to_heating_station.json
@@ -0,0 +1,19 @@
+{
+  "type": "UniLabJsonCommand",
+  "goal": {
+    "material_number": "material_number"
+  },
+  "schema": {
+    "type": "object",
+    "properties": {
+      "material_number": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "material_number"
+    ]
+  },
+  "goal_default": {},
+  "placeholder_keys": {}
+}
--- a/.cursor/skills/virtual-workbench/actions/move_to_output.json
+++ b/.cursor/skills/virtual-workbench/actions/move_to_output.json
@@ -0,0 +1,24 @@
+{
+  "type": "UniLabJsonCommand",
+  "goal": {
+    "station_id": "station_id",
+    "material_number": "material_number"
+  },
+  "schema": {
+    "type": "object",
+    "properties": {
+      "station_id": {
+        "type": "integer"
+      },
+      "material_number": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "station_id",
+      "material_number"
+    ]
+  },
+  "goal_default": {},
+  "placeholder_keys": {}
+}
--- a/.cursor/skills/virtual-workbench/actions/prepare_materials.json
+++ b/.cursor/skills/virtual-workbench/actions/prepare_materials.json
@@ -0,0 +1,20 @@
+{
+  "type": "UniLabJsonCommand",
+  "goal": {
+    "count": "count"
+  },
+  "schema": {
+    "type": "object",
+    "properties": {
+      "count": {
+        "type": "integer",
+        "default": 5
+      }
+    },
+    "required": []
+  },
+  "goal_default": {
+    "count": 5
+  },
+  "placeholder_keys": {}
+}
--- a/.cursor/skills/virtual-workbench/actions/start_heating.json
+++ b/.cursor/skills/virtual-workbench/actions/start_heating.json
@@ -0,0 +1,24 @@
+{
+  "type": "UniLabJsonCommand",
+  "goal": {
+    "station_id": "station_id",
+    "material_number": "material_number"
+  },
+  "schema": {
+    "type": "object",
+    "properties": {
+      "station_id": {
+        "type": "integer"
+      },
+      "material_number": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "station_id",
+      "material_number"
+    ]
+  },
+  "goal_default": {},
+  "placeholder_keys": {}
+}
--- a/.cursor/skills/virtual-workbench/actions/transfer.json
+++ b/.cursor/skills/virtual-workbench/actions/transfer.json
@@ -0,0 +1,255 @@
+{
+  "type": "UniLabJsonCommandAsync",
+  "goal": {
+    "resource": "resource",
+    "target_device": "target_device",
+    "mount_resource": "mount_resource"
+  },
+  "schema": {
+    "type": "object",
+    "properties": {
+      "resource": {
+        "items": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "name": {
+              "type": "string"
+            },
+            "sample_id": {
+              "type": "string"
+            },
+            "children": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "parent": {
+              "type": "string"
+            },
+            "type": {
+              "type": "string"
+            },
+            "category": {
+              "type": "string"
+            },
+            "pose": {
+              "type": "object",
+              "properties": {
+                "position": {
+                  "type": "object",
+                  "properties": {
+                    "x": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "y": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "z": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    }
+                  },
+                  "required": [
+                    "x",
+                    "y",
+                    "z"
+                  ],
+                  "title": "position",
+                  "additionalProperties": false
+                },
+                "orientation": {
+                  "type": "object",
+                  "properties": {
+                    "x": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "y": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "z": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "w": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    }
+                  },
+                  "required": [
+                    "x",
+                    "y",
+                    "z",
+                    "w"
+                  ],
+                  "title": "orientation",
+                  "additionalProperties": false
+                }
+              },
+              "required": [
+                "position",
+                "orientation"
+              ],
+              "title": "pose",
+              "additionalProperties": false
+            },
+            "config": {
+              "type": "string"
+            },
+            "data": {
+              "type": "string"
+            }
+          },
+          "title": "resource"
+        },
+        "type": "array"
+      },
+      "target_device": {
+        "type": "string",
+        "description": "device reference"
+      },
+      "mount_resource": {
+        "items": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "name": {
+              "type": "string"
+            },
+            "sample_id": {
+              "type": "string"
+            },
+            "children": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "parent": {
+              "type": "string"
+            },
+            "type": {
+              "type": "string"
+            },
+            "category": {
+              "type": "string"
+            },
+            "pose": {
+              "type": "object",
+              "properties": {
+                "position": {
+                  "type": "object",
+                  "properties": {
+                    "x": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "y": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "z": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    }
+                  },
+                  "required": [
+                    "x",
+                    "y",
+                    "z"
+                  ],
+                  "title": "position",
+                  "additionalProperties": false
+                },
+                "orientation": {
+                  "type": "object",
+                  "properties": {
+                    "x": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "y": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "z": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    },
+                    "w": {
+                      "type": "number",
+                      "minimum": -1.7976931348623157e+308,
+                      "maximum": 1.7976931348623157e+308
+                    }
+                  },
+                  "required": [
+                    "x",
+                    "y",
+                    "z",
+                    "w"
+                  ],
+                  "title": "orientation",
+                  "additionalProperties": false
+                }
+              },
+              "required": [
+                "position",
+                "orientation"
+              ],
+              "title": "pose",
+              "additionalProperties": false
+            },
+            "config": {
+              "type": "string"
+            },
+            "data": {
+              "type": "string"
+            }
+          },
+          "title": "mount_resource"
+        },
+        "type": "array"
+      }
+    },
+    "required": [
+      "resource",
+      "target_device",
+      "mount_resource"
+    ],
+    "_unilabos_placeholder_info": {
+      "resource": "unilabos_resources",
+      "target_device": "unilabos_devices",
+      "mount_resource": "unilabos_resources"
+    }
+  },
+  "goal_default": {},
+  "placeholder_keys": {
+    "resource": "unilabos_resources",
+    "target_device": "unilabos_devices",
+    "mount_resource": "unilabos_resources"
+  }
+}
--- a/docs/advanced_usage/configuration.md
+++ b/docs/advanced_usage/configuration.md
@@ -12,7 +12,7 @@ Uni-Lab 使用 Python 格式的配置文件（`.py`），默认为 `unilabos_dat

 **获取方式：**

-进入 [Uni-Lab 实验室](https://uni-lab.bohrium.com)，点击左下角的头像，在实验室详情中获取所在实验室的 ak 和 sk：
+进入 [Uni-Lab 实验室](https://leap-lab.bohrium.com)，点击左下角的头像，在实验室详情中获取所在实验室的 ak 和 sk：

 ![copy_aksk.gif](image/copy_aksk.gif)

@@ -69,7 +69,7 @@ class WSConfig:

 # HTTP配置
 class HTTPConfig:
-    remote_addr = "https://uni-lab.bohrium.com/api/v1"  # 远程服务器地址
+    remote_addr = "https://leap-lab.bohrium.com/api/v1"  # 远程服务器地址

 # ROS配置
 class ROSConfig:
@@ -209,8 +209,8 @@ unilab --ak "key" --sk "secret" --addr "test" --upload_registry --2d_vis -g grap

 `--addr` 参数支持以下预设值，会自动转换为对应的完整 URL：

- `test` → `https://uni-lab.test.bohrium.com/api/v1`
- `uat` → `https://uni-lab.uat.bohrium.com/api/v1`
+- `test` → `https://leap-lab.test.bohrium.com/api/v1`
+- `uat` → `https://leap-lab.uat.bohrium.com/api/v1`
 - `local` → `http://127.0.0.1:48197/api/v1`
 - 其他值 → 直接使用作为完整 URL

@@ -248,7 +248,7 @@ unilab --ak "key" --sk "secret" --addr "test" --upload_registry --2d_vis -g grap

 `ak` 和 `sk` 是必需的认证参数：

-1. **获取方式**：在 [Uni-Lab 官网](https://uni-lab.bohrium.com) 注册实验室后获得
+1. **获取方式**：在 [Uni-Lab 官网](https://leap-lab.bohrium.com) 注册实验室后获得
 2. **配置方式**：
   - **命令行参数**：`--ak "your_key" --sk "your_secret"`（最高优先级，推荐）
   - **环境变量**：`UNILABOS_BASICCONFIG_AK` 和 `UNILABOS_BASICCONFIG_SK`
@@ -275,15 +275,15 @@ WebSocket 是 Uni-Lab 的主要通信方式：

 HTTP 客户端配置用于与云端服务通信：

-| 参数          | 类型 | 默认值                                 | 说明         |
-| ------------- | ---- | -------------------------------------- | ------------ |
-| `remote_addr` | str  | `"https://uni-lab.bohrium.com/api/v1"` | 远程服务地址 |
+| 参数          | 类型 | 默认值                                  | 说明         |
+| ------------- | ---- | --------------------------------------- | ------------ |
+| `remote_addr` | str  | `"https://leap-lab.bohrium.com/api/v1"` | 远程服务地址 |

 **预设环境地址**：

- 生产环境：`https://uni-lab.bohrium.com/api/v1`（默认）
- 测试环境：`https://uni-lab.test.bohrium.com/api/v1`
- UAT 环境：`https://uni-lab.uat.bohrium.com/api/v1`
+- 生产环境：`https://leap-lab.bohrium.com/api/v1`（默认）
+- 测试环境：`https://leap-lab.test.bohrium.com/api/v1`
+- UAT 环境：`https://leap-lab.uat.bohrium.com/api/v1`
 - 本地环境：`http://127.0.0.1:48197/api/v1`

 ### 4. ROSConfig - ROS 配置
@@ -401,7 +401,7 @@ export UNILABOS_WSCONFIG_RECONNECT_INTERVAL="10"
 export UNILABOS_WSCONFIG_MAX_RECONNECT_ATTEMPTS="500"

 # 设置HTTP配置
-export UNILABOS_HTTPCONFIG_REMOTE_ADDR="https://uni-lab.test.bohrium.com/api/v1"
+export UNILABOS_HTTPCONFIG_REMOTE_ADDR="https://leap-lab.test.bohrium.com/api/v1"
 ```

 ## 配置文件使用方法
@@ -484,13 +484,13 @@ export UNILABOS_WSCONFIG_MAX_RECONNECT_ATTEMPTS=100

 ```python
 class HTTPConfig:
-    remote_addr = "https://uni-lab.test.bohrium.com/api/v1"
+    remote_addr = "https://leap-lab.test.bohrium.com/api/v1"
 ```

 **环境变量方式：**

 ```bash
-export UNILABOS_HTTPCONFIG_REMOTE_ADDR=https://uni-lab.test.bohrium.com/api/v1
+export UNILABOS_HTTPCONFIG_REMOTE_ADDR=https://leap-lab.test.bohrium.com/api/v1
 ```

 **命令行方式（推荐）：**
--- a/docs/developer_guide/networking_overview.md
+++ b/docs/developer_guide/networking_overview.md
@@ -23,7 +23,7 @@ Uni-Lab-OS 支持多种部署模式：
 ```
 ┌──────────────────────────────────────────────┐
 │      Cloud Platform/Self-hosted Platform     │
-│           uni-lab.bohrium.com                │
+│           leap-lab.bohrium.com                │
 │  (Resource Management, Task Scheduling,      │
 │              Monitoring)                     │
 └────────────────────┬─────────────────────────┘
@@ -444,7 +444,7 @@ ros2 daemon stop && ros2 daemon start

 ```bash
 # 测试云端连接
-curl https://uni-lab.bohrium.com/api/v1/health
+curl https://leap-lab.bohrium.com/api/v1/health

 # 测试WebSocket
 # 启动Uni-Lab后查看日志
--- a/docs/user_guide/best_practice.md
+++ b/docs/user_guide/best_practice.md
@@ -33,11 +33,11 @@

 **选择合适的安装包：**

-| 安装包 | 适用场景 | 包含组件 |
-|--------|----------|----------|
-| `unilabos` | **推荐大多数用户**，生产部署 | 完整安装包，开箱即用 |
-| `unilabos-env` | 开发者（可编辑安装） | 仅环境依赖，通过 pip 安装 unilabos |
-| `unilabos-full` | 仿真/可视化 | unilabos + 完整 ROS2 桌面版 + Gazebo + MoveIt |
+| 安装包          | 适用场景                     | 包含组件                                      |
+| --------------- | ---------------------------- | --------------------------------------------- |
+| `unilabos`      | **推荐大多数用户**，生产部署 | 完整安装包，开箱即用                          |
+| `unilabos-env`  | 开发者（可编辑安装）         | 仅环境依赖，通过 pip 安装 unilabos            |
+| `unilabos-full` | 仿真/可视化                  | unilabos + 完整 ROS2 桌面版 + Gazebo + MoveIt |

 **关键步骤：**

@@ -66,6 +66,7 @@ mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
 ```

 **选择建议：**
+
 - **日常使用/生产部署**：使用 `unilabos`（推荐），完整功能，开箱即用
 - **开发者**：使用 `unilabos-env` + `pip install -e .` + `uv pip install -r unilabos/utils/requirements.txt`，代码修改立即生效
 - **仿真/可视化**：使用 `unilabos-full`，含 Gazebo、rviz2、MoveIt
@@ -88,7 +89,7 @@ python -c "from unilabos_msgs.msg import Resource; print('ROS msgs OK')"

 #### 2.1 注册实验室账号

-1. 访问 [https://uni-lab.bohrium.com](https://uni-lab.bohrium.com)
+1. 访问 [https://leap-lab.bohrium.com](https://leap-lab.bohrium.com)
 2. 注册账号并登录
 3. 创建新实验室

@@ -297,7 +298,7 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json

 #### 5.2 访问 Web 界面

-启动系统后，访问[https://uni-lab.bohrium.com](https://uni-lab.bohrium.com)
+启动系统后，访问[https://leap-lab.bohrium.com](https://leap-lab.bohrium.com)

 #### 5.3 添加设备和物料

@@ -306,12 +307,10 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 **示例场景：** 创建一个简单的液体转移实验

 1. **添加工作站（必需）：**
-
   - 在"仪器设备"中找到 `work_station`
   - 添加 `workstation` x1

 2. **添加虚拟转移泵：**
-
   - 在"仪器设备"中找到 `virtual_device`
   - 添加 `virtual_transfer_pump` x1

@@ -818,6 +817,7 @@ uv pip install -r unilabos/utils/requirements.txt
 ```

 **为什么使用这种方式？**
+
 - `unilabos-env` 提供 ROS2 核心组件和 uv（通过 conda 安装，避免编译）
 - `unilabos/utils/requirements.txt` 包含所有运行时需要的 pip 依赖
 - `dev_install.py` 自动检测中文环境，中文系统自动使用清华镜像
@@ -1796,32 +1796,27 @@ unilab --ak your_ak --sk your_sk -g graph.json \
 **详细步骤：**

 1. **需求分析**：
-
   - 明确实验流程
   - 列出所需设备和物料
   - 设计工作流程图

 2. **环境搭建**：
-
   - 安装 Uni-Lab-OS
   - 创建实验室账号
   - 准备开发工具（IDE、Git）

 3. **原型验证**：
-
   - 使用虚拟设备测试流程
   - 验证工作流逻辑
   - 调整参数

 4. **迭代开发**：
-
   - 实现自定义设备驱动（同时撰写单点函数测试）
   - 编写注册表
   - 单元测试
   - 集成测试

 5. **测试部署**：
-
   - 连接真实硬件
   - 空跑测试
   - 小规模试验
@@ -1871,7 +1866,7 @@ unilab --ak your_ak --sk your_sk -g graph.json \
 #### 14.5 社区支持

 - **GitHub Issues**：[https://github.com/deepmodeling/Uni-Lab-OS/issues](https://github.com/deepmodeling/Uni-Lab-OS/issues)
- **官方网站**：[https://uni-lab.bohrium.com](https://uni-lab.bohrium.com)
+- **官方网站**：[https://leap-lab.bohrium.com](https://leap-lab.bohrium.com)

 ---

--- a/docs/user_guide/graph_files.md
+++ b/docs/user_guide/graph_files.md
@@ -626,7 +626,7 @@ unilab

 **云端图文件管理**:

-1. 登录 https://uni-lab.bohrium.com
+1. 登录 https://leap-lab.bohrium.com
 2. 进入"设备配置"
 3. 创建或编辑配置
 4. 保存到云端
--- a/docs/user_guide/launch.md
+++ b/docs/user_guide/launch.md
@@ -54,7 +54,6 @@ Uni-Lab 的启动过程分为以下几个阶段：
 您可以直接跟随 unilabos 的提示进行，无需查阅本节

 - **工作目录设置**：
-
  - 如果当前目录以 `unilabos_data` 结尾，则使用当前目录
  - 否则使用 `当前目录/unilabos_data` 作为工作目录
  - 可通过 `--working_dir` 指定自定义工作目录
@@ -68,8 +67,8 @@ Uni-Lab 的启动过程分为以下几个阶段：

 支持多种后端环境：

- `--addr test`：测试环境 (`https://uni-lab.test.bohrium.com/api/v1`)
- `--addr uat`：UAT 环境 (`https://uni-lab.uat.bohrium.com/api/v1`)
+- `--addr test`：测试环境 (`https://leap-lab.test.bohrium.com/api/v1`)
+- `--addr uat`：UAT 环境 (`https://leap-lab.uat.bohrium.com/api/v1`)
 - `--addr local`：本地环境 (`http://127.0.0.1:48197/api/v1`)
 - 自定义地址：直接指定完整 URL

@@ -176,7 +175,7 @@ unilab --config path/to/your/config.py

 如果是首次使用，系统会：

-1. 提示前往 https://uni-lab.bohrium.com 注册实验室
+1. 提示前往 https://leap-lab.bohrium.com 注册实验室
 2. 引导创建配置文件
 3. 设置工作目录

@@ -216,7 +215,7 @@ unilab --ak your_ak --sk your_sk --port 8080 --disable_browser

 如果提示 "后续运行必须拥有一个实验室"，请确保：

- 已在 https://uni-lab.bohrium.com 注册实验室
+- 已在 https://leap-lab.bohrium.com 注册实验室
 - 正确设置了 `--ak` 和 `--sk` 参数
 - 配置文件中包含正确的认证信息

--- a/recipes/msgs/recipe.yaml
+++ b/recipes/msgs/recipe.yaml
@@ -1,6 +1,6 @@
 package:
  name: ros-humble-unilabos-msgs
-  version: 0.10.19
+  version: 0.11.0
 source:
  path: ../../unilabos_msgs
  target_directory: src
--- a/recipes/unilabos/recipe.yaml
+++ b/recipes/unilabos/recipe.yaml
@@ -1,6 +1,6 @@
 package:
  name: unilabos
-  version: "0.10.19"
+  version: "0.11.0"

 source:
  path: ../..
--- a/scripts/workflow.py
+++ b/scripts/workflow.py
@@ -2,6 +2,7 @@ import json
 import logging
 import traceback
 import uuid
+import xml.etree.ElementTree as ET
 from typing import Any, Dict, List

 import networkx as nx
@@ -24,15 +25,7 @@ class SimpleGraph:

    def add_edge(self, source, target, **attrs):
        """添加边"""
-        # edge = {"source": source, "target": target, **attrs}
-        edge = {
-            "source": source, "target": target,
-            "source_node_uuid": source,
-            "target_node_uuid": target,
-            "source_handle_io": "source",
-            "target_handle_io": "target",
-            **attrs
-        }
+        edge = {"source": source, "target": target, **attrs}
        self.edges.append(edge)

    def to_dict(self):
@@ -49,7 +42,6 @@ class SimpleGraph:
            "multigraph": False,
            "graph": {},
            "nodes": nodes_list,
-            "edges": self.edges,
            "links": self.edges,
        }

@@ -66,8 +58,495 @@ def extract_json_from_markdown(text: str) -> str:
    return text


+def convert_to_type(val: str) -> Any:
+    """将字符串值转换为适当的数据类型"""
+    if val == "True":
+        return True
+    if val == "False":
+        return False
+    if val == "?":
+        return None
+    if val.endswith(" g"):
+        return float(val.split(" ")[0])
+    if val.endswith("mg"):
+        return float(val.split("mg")[0])
+    elif val.endswith("mmol"):
+        return float(val.split("mmol")[0]) / 1000
+    elif val.endswith("mol"):
+        return float(val.split("mol")[0])
+    elif val.endswith("ml"):
+        return float(val.split("ml")[0])
+    elif val.endswith("RPM"):
+        return float(val.split("RPM")[0])
+    elif val.endswith(" °C"):
+        return float(val.split(" ")[0])
+    elif val.endswith(" %"):
+        return float(val.split(" ")[0])
+    return val


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


 def create_workflow(
--- a/setup.py
+++ b/setup.py
@@ -4,7 +4,7 @@ package_name = 'unilabos'

 setup(
    name=package_name,
-    version='0.10.19',
+    version='0.11.0',
    packages=find_packages(),
    include_package_data=True,
    install_requires=['setuptools'],
--- a/tests/compile/init.py
+++ b/tests/compile/init.py
--- a/tests/compile/test_batch_transfer_protocol.py
+++ b/tests/compile/test_batch_transfer_protocol.py
@@ -1,296 +0,0 @@
-"""
-批量转运编译器测试
-
-覆盖：单物料退化、刚好一批、多批次、空操作、AGV 配置发现、children dict 状态。
-"""
-
-import pytest
-import networkx as nx
-
-from unilabos.compile.batch_transfer_protocol import generate_batch_transfer_protocol
-from unilabos.compile.agv_transfer_protocol import generate_agv_transfer_protocol
-from unilabos.compile._agv_utils import find_agv_config, get_agv_capacity, split_batches
-
-
-# ============ 构建测试用设备图 ============
-
-def _make_graph(capacity_x=2, capacity_y=1, capacity_z=1):
-    """构建包含 AGV 节点的测试设备图"""
-    G = nx.DiGraph()
-
-    # AGV 节点
-    G.add_node("AGV", **{
-        "type": "device",
-        "class_": "agv_transport_station",
-        "config": {
-            "protocol_type": ["AGVTransferProtocol", "BatchTransferProtocol"],
-            "device_roles": {
-                "navigator": "zhixing_agv",
-                "arm": "zhixing_ur_arm"
-            },
-            "route_table": {
-                "StationA->StationB": {
-                    "nav_command": '{"target": "LM1"}',
-                    "arm_pick": '{"task_name": "pick.urp"}',
-                    "arm_place": '{"task_name": "place.urp"}'
-                },
-                "AGV->StationA": {
-                    "nav_command": '{"target": "LM1"}',
-                    "arm_pick": '{"task_name": "pick.urp"}',
-                    "arm_place": '{"task_name": "place.urp"}'
-                },
-                "StationA->StationA": {
-                    "nav_command": '{"target": "LM1"}',
-                    "arm_pick": '{"task_name": "pick.urp"}',
-                    "arm_place": '{"task_name": "place.urp"}'
-                },
-            }
-        }
-    })
-
-    # AGV 子设备
-    G.add_node("zhixing_agv", type="device", class_="zhixing_agv")
-    G.add_node("zhixing_ur_arm", type="device", class_="zhixing_ur_arm")
-    G.add_edge("AGV", "zhixing_agv")
-    G.add_edge("AGV", "zhixing_ur_arm")
-
-    # AGV Warehouse 子资源
-    G.add_node("agv_platform", **{
-        "type": "warehouse",
-        "config": {
-            "name": "agv_platform",
-            "num_items_x": capacity_x,
-            "num_items_y": capacity_y,
-            "num_items_z": capacity_z,
-        }
-    })
-    G.add_edge("AGV", "agv_platform")
-
-    # 来源/目标工站
-    G.add_node("StationA", type="device", class_="workstation")
-    G.add_node("StationB", type="device", class_="workstation")
-
-    return G
-
-
-def _make_repos(items_count=2):
-    """构建测试用的 from_repo 和 to_repo dict"""
-    children = {}
-    for i in range(items_count):
-        pos = f"A{i + 1:02d}"
-        children[pos] = {
-            "id": f"resource_{i + 1}",
-            "name": f"R{i + 1}",
-            "parent": "StationA",
-            "type": "resource",
-        }
-
-    from_repo = {
-        "StationA": {
-            "id": "StationA",
-            "name": "StationA",
-            "children": children,
-        }
-    }
-    to_repo = {
-        "StationB": {
-            "id": "StationB",
-            "name": "StationB",
-            "children": {},
-        }
-    }
-    return from_repo, to_repo
-
-
-def _make_items(count=2):
-    """构建 transfer_resources / from_positions / to_positions"""
-    resources = [
-        {
-            "id": f"resource_{i + 1}",
-            "name": f"R{i + 1}",
-            "sample_id": f"uuid-{i + 1}",
-            "parent": "StationA",
-            "type": "resource",
-        }
-        for i in range(count)
-    ]
-    from_positions = [f"A{i + 1:02d}" for i in range(count)]
-    to_positions = [f"A{i + 1:02d}" for i in range(count)]
-    return resources, from_positions, to_positions
-
-
-# ============ _agv_utils 测试 ============
-
-class TestAGVUtils:
-    def test_find_agv_config(self):
-        G = _make_graph()
-        cfg = find_agv_config(G)
-        assert cfg["agv_id"] == "AGV"
-        assert cfg["device_roles"]["navigator"] == "zhixing_agv"
-        assert cfg["device_roles"]["arm"] == "zhixing_ur_arm"
-        assert "StationA->StationB" in cfg["route_table"]
-
-    def test_find_agv_config_by_id(self):
-        G = _make_graph()
-        cfg = find_agv_config(G, agv_id="AGV")
-        assert cfg["agv_id"] == "AGV"
-
-    def test_find_agv_config_not_found(self):
-        G = nx.DiGraph()
-        G.add_node("SomeDevice", type="device", class_="pump")
-        with pytest.raises(ValueError, match="未找到 AGV"):
-            find_agv_config(G)
-
-    def test_get_agv_capacity(self):
-        G = _make_graph(capacity_x=2, capacity_y=1, capacity_z=1)
-        assert get_agv_capacity(G, "AGV") == 2
-
-    def test_get_agv_capacity_multi_layer(self):
-        G = _make_graph(capacity_x=1, capacity_y=2, capacity_z=3)
-        assert get_agv_capacity(G, "AGV") == 6
-
-    def test_split_batches_exact(self):
-        assert split_batches([1, 2], 2) == [[1, 2]]
-
-    def test_split_batches_overflow(self):
-        assert split_batches([1, 2, 3], 2) == [[1, 2], [3]]
-
-    def test_split_batches_single(self):
-        assert split_batches([1], 4) == [[1]]
-
-    def test_split_batches_zero_capacity(self):
-        with pytest.raises(ValueError):
-            split_batches([1], 0)
-
-
-# ============ 批量转运编译器测试 ============
-
-class TestBatchTransferProtocol:
-    def test_empty_items(self):
-        """空物料列表返回空 steps"""
-        G = _make_graph()
-        from_repo, to_repo = _make_repos(0)
-        steps = generate_batch_transfer_protocol(G, from_repo, to_repo, [], [], [])
-        assert steps == []
-
-    def test_single_item(self):
-        """单物料转运（BatchTransfer 退化为单物料）"""
-        G = _make_graph(capacity_x=2)
-        from_repo, to_repo = _make_repos(1)
-        resources, from_pos, to_pos = _make_items(1)
-        steps = generate_batch_transfer_protocol(G, from_repo, to_repo, resources, from_pos, to_pos)
-
-        # 应该有: nav到来源 + 1个pick + nav到目标 + 1个place = 4 steps
-        assert len(steps) == 4
-        assert steps[0]["action_name"] == "send_nav_task"
-        assert steps[1]["action_name"] == "move_pos_task"
-        assert steps[1]["_transfer_meta"]["phase"] == "pick"
-        assert steps[2]["action_name"] == "send_nav_task"
-        assert steps[3]["action_name"] == "move_pos_task"
-        assert steps[3]["_transfer_meta"]["phase"] == "place"
-
-    def test_exact_capacity(self):
-        """物料数 = AGV 容量，刚好一批"""
-        G = _make_graph(capacity_x=2)
-        from_repo, to_repo = _make_repos(2)
-        resources, from_pos, to_pos = _make_items(2)
-        steps = generate_batch_transfer_protocol(G, from_repo, to_repo, resources, from_pos, to_pos)
-
-        # nav + 2 pick + nav + 2 place = 6 steps
-        assert len(steps) == 6
-        pick_steps = [s for s in steps if s.get("_transfer_meta", {}).get("phase") == "pick"]
-        place_steps = [s for s in steps if s.get("_transfer_meta", {}).get("phase") == "place"]
-        assert len(pick_steps) == 2
-        assert len(place_steps) == 2
-
-    def test_multi_batch(self):
-        """物料数 > AGV 容量，自动分批"""
-        G = _make_graph(capacity_x=2)
-        from_repo, to_repo = _make_repos(3)
-        resources, from_pos, to_pos = _make_items(3)
-        steps = generate_batch_transfer_protocol(G, from_repo, to_repo, resources, from_pos, to_pos)
-
-        # 批次1: nav + 2 pick + nav + 2 place + nav(返回) = 7
-        # 批次2: nav + 1 pick + nav + 1 place = 4
-        # 总计 11 steps
-        assert len(steps) == 11
-
-        nav_steps = [s for s in steps if s["action_name"] == "send_nav_task"]
-        # 批次1: 2 nav(去来源+去目标) + 1 nav(返回) + 批次2: 2 nav = 5 nav
-        assert len(nav_steps) == 5
-
-    def test_children_dict_updated(self):
-        """compile 阶段三方 children dict 状态正确"""
-        G = _make_graph(capacity_x=2)
-        from_repo, to_repo = _make_repos(2)
-        resources, from_pos, to_pos = _make_items(2)
-
-        assert "A01" in from_repo["StationA"]["children"]
-        assert "A02" in from_repo["StationA"]["children"]
-        assert len(to_repo["StationB"]["children"]) == 0
-
-        generate_batch_transfer_protocol(G, from_repo, to_repo, resources, from_pos, to_pos)
-
-        # compile 后 from_repo 的 children 应该被 pop 掉
-        assert "A01" not in from_repo["StationA"]["children"]
-        assert "A02" not in from_repo["StationA"]["children"]
-        # to_repo 应该有新物料
-        assert "A01" in to_repo["StationB"]["children"]
-        assert "A02" in to_repo["StationB"]["children"]
-        assert to_repo["StationB"]["children"]["A01"]["id"] == "resource_1"
-
-    def test_device_ids_from_config(self):
-        """设备 ID 全部从配置读取，不硬编码"""
-        G = _make_graph()
-        from_repo, to_repo = _make_repos(1)
-        resources, from_pos, to_pos = _make_items(1)
-        steps = generate_batch_transfer_protocol(G, from_repo, to_repo, resources, from_pos, to_pos)
-
-        device_ids = {s["device_id"] for s in steps}
-        assert "zhixing_agv" in device_ids
-        assert "zhixing_ur_arm" in device_ids
-
-    def test_route_not_found(self):
-        """路由表中无对应路线时报错"""
-        G = _make_graph()
-        from_repo = {"Unknown": {"id": "Unknown", "children": {"A01": {"id": "R1", "parent": "Unknown"}}}}
-        to_repo = {"Other": {"id": "Other", "children": {}}}
-        resources = [{"id": "R1", "name": "R1"}]
-        with pytest.raises(KeyError, match="路由表"):
-            generate_batch_transfer_protocol(G, from_repo, to_repo, resources, ["A01"], ["B01"])
-
-    def test_length_mismatch(self):
-        """三个数组长度不一致时报错"""
-        G = _make_graph()
-        from_repo, to_repo = _make_repos(2)
-        resources = [{"id": "R1"}]
-        with pytest.raises(ValueError, match="长度不一致"):
-            generate_batch_transfer_protocol(G, from_repo, to_repo, resources, ["A01", "A02"], ["B01"])
-
-
-# ============ 改造后的 AGV 单物料编译器测试 ============
-
-class TestAGVTransferProtocol:
-    def test_single_transfer_from_config(self):
-        """改造后的单物料编译器从 G 读取配置"""
-        G = _make_graph()
-        from_repo = {"StationA": {"id": "StationA", "children": {"A01": {"id": "R1", "parent": "StationA"}}}}
-        to_repo = {"StationB": {"id": "StationB", "children": {}}}
-        steps = generate_agv_transfer_protocol(G, from_repo, "A01", to_repo, "B01")
-
-        assert len(steps) == 2
-        assert steps[0]["device_id"] == "zhixing_agv"
-        assert steps[0]["action_name"] == "send_nav_task"
-        assert steps[1]["device_id"] == "zhixing_ur_arm"
-        assert steps[1]["action_name"] == "move_pos_task"
-
-    def test_children_updated(self):
-        """单物料编译后 children dict 正确更新"""
-        G = _make_graph()
-        from_repo = {"StationA": {"id": "StationA", "children": {"A01": {"id": "R1", "parent": "StationA"}}}}
-        to_repo = {"StationB": {"id": "StationB", "children": {}}}
-        generate_agv_transfer_protocol(G, from_repo, "A01", to_repo, "B01")
-
-        assert "A01" not in from_repo["StationA"]["children"]
-        assert "B01" in to_repo["StationB"]["children"]
-        assert to_repo["StationB"]["children"]["B01"]["parent"] == "StationB"
--- a/tests/compile/test_full_chain_conversion_to_compile.py
+++ b/tests/compile/test_full_chain_conversion_to_compile.py
@@ -1,706 +0,0 @@
-"""
-全链路集成测试：ROS Goal 转换 → ResourceTreeSet → get_plr_nested_dict → 编译器 → 动作列表
-
-模拟 workstation.py 中的完整路径：
-1. host 返回 raw_data（模拟 resource_get 响应）
-2. ResourceTreeSet.from_raw_dict_list(raw_data) 构建资源树
-3. tree.root_node.get_plr_nested_dict() 生成嵌套 dict
-4. protocol_kwargs 传给编译器
-5. 编译器返回 action_list，验证结构和关键字段
-"""
-
-import copy
-import json
-import pytest
-import networkx as nx
-
-from unilabos.resources.resource_tracker import (
-    ResourceDictInstance,
-    ResourceTreeSet,
-)
-from unilabos.compile.utils.resource_helper import (
-    ensure_resource_instance,
-    resource_to_dict,
-    get_resource_id,
-    get_resource_data,
-)
-from unilabos.compile.utils.vessel_parser import get_vessel
-
-# ============ 构建模拟设备图 ============
-
-def _build_test_graph():
-    """构建一个包含常用设备节点的测试图"""
-    G = nx.DiGraph()
-
-    # 容器
-    G.add_node("reactor_01", **{
-        "id": "reactor_01",
-        "name": "reactor_01",
-        "type": "device",
-        "class": "virtual_stirrer",
-        "data": {},
-        "config": {},
-    })
-
-    # 搅拌设备
-    G.add_node("stirrer_1", **{
-        "id": "stirrer_1",
-        "name": "stirrer_1",
-        "type": "device",
-        "class": "virtual_stirrer",
-        "data": {},
-        "config": {},
-    })
-    G.add_edge("stirrer_1", "reactor_01")
-
-    # 加热设备
-    G.add_node("heatchill_1", **{
-        "id": "heatchill_1",
-        "name": "heatchill_1",
-        "type": "device",
-        "class": "virtual_heatchill",
-        "data": {},
-        "config": {},
-    })
-    G.add_edge("heatchill_1", "reactor_01")
-
-    # 试剂容器（液体）
-    G.add_node("flask_water", **{
-        "id": "flask_water",
-        "name": "flask_water",
-        "type": "container",
-        "class": "",
-        "data": {"reagent_name": "water", "liquid": [{"liquid_type": "water", "volume": 500.0}]},
-        "config": {"reagent": "water"},
-    })
-
-    # 固体加样器
-    G.add_node("solid_dispenser_1", **{
-        "id": "solid_dispenser_1",
-        "name": "solid_dispenser_1",
-        "type": "device",
-        "class": "solid_dispenser",
-        "data": {},
-        "config": {},
-    })
-
-    # 泵
-    G.add_node("pump_1", **{
-        "id": "pump_1",
-        "name": "pump_1",
-        "type": "device",
-        "class": "virtual_pump",
-        "data": {},
-        "config": {},
-    })
-    G.add_edge("flask_water", "pump_1")
-    G.add_edge("pump_1", "reactor_01")
-
-    return G
-
-
-# ============ 构建模拟 host 返回数据 ============
-
-def _make_raw_resource(
-    id="reactor_01",
-    uuid="uuid-reactor-01",
-    name="reactor_01",
-    klass="virtual_stirrer",
-    type_="device",
-    parent=None,
-    parent_uuid=None,
-    data=None,
-    config=None,
-    extra=None,
-):
-    """模拟 host 返回的单个资源 dict（与 resource_get 服务响应一致）"""
-    return {
-        "id": id,
-        "uuid": uuid,
-        "name": name,
-        "class": klass,
-        "type": type_,
-        "parent": parent,
-        "parent_uuid": parent_uuid or "",
-        "description": "",
-        "config": config or {},
-        "data": data or {},
-        "extra": extra or {},
-        "position": {"x": 0.0, "y": 0.0, "z": 0.0},
-    }
-
-
-def _simulate_workstation_resource_enrichment(raw_data_list, field_type="unilabos_msgs/Resource"):
-    """
-    模拟 workstation.py 中 resource enrichment 的核心逻辑：
-    raw_data → ResourceTreeSet.from_raw_dict_list → get_plr_nested_dict → protocol_kwargs[k]
-    """
-    tree_set = ResourceTreeSet.from_raw_dict_list(raw_data_list)
-
-    if field_type == "unilabos_msgs/Resource":
-        # 单个 Resource：取第一棵树的根节点
-        root_instance = tree_set.trees[0].root_node if tree_set.trees else None
-        return root_instance.get_plr_nested_dict() if root_instance else {}
-    else:
-        # sequence<Resource>：返回列表
-        return [tree.root_node.get_plr_nested_dict() for tree in tree_set.trees]
-
-
-# ============ 全链路测试：Stir 协议 ============
-
-class TestStirProtocolFullChain:
-    """Stir 协议全链路：host raw_data → enriched dict → compiler → action_list"""
-
-    def test_stir_with_enriched_resource_dict(self):
-        """单个 Resource 经过 enrichment 后传给 stir compiler"""
-        from unilabos.compile.stir_protocol import generate_stir_protocol
-
-        raw_data = [_make_raw_resource(
-            id="reactor_01", uuid="uuid-reactor-01",
-            klass="virtual_stirrer", type_="device",
-        )]
-
-        # 模拟 workstation enrichment
-        enriched_vessel = _simulate_workstation_resource_enrichment(raw_data)
-
-        assert enriched_vessel["id"] == "reactor_01"
-        assert enriched_vessel["uuid"] == "uuid-reactor-01"
-        assert enriched_vessel["class"] == "virtual_stirrer"
-
-        # 传给编译器
-        G = _build_test_graph()
-        actions = generate_stir_protocol(
-            G=G,
-            vessel=enriched_vessel,
-            time="60",
-            stir_speed=300.0,
-        )
-
-        assert isinstance(actions, list)
-        assert len(actions) >= 1
-        action = actions[0]
-        assert action["device_id"] == "stirrer_1"
-        assert action["action_name"] == "stir"
-        assert "vessel" in action["action_kwargs"]
-        assert action["action_kwargs"]["vessel"]["id"] == "reactor_01"
-
-    def test_stir_with_resource_dict_instance(self):
-        """直接用 ResourceDictInstance 传给 stir compiler（通过 get_plr_nested_dict 转换）"""
-        from unilabos.compile.stir_protocol import generate_stir_protocol
-
-        raw_data = [_make_raw_resource(id="reactor_01")]
-        tree_set = ResourceTreeSet.from_raw_dict_list(raw_data)
-        inst = tree_set.trees[0].root_node
-
-        # 通过 resource_to_dict 转换（resource_helper 兼容层）
-        vessel_dict = resource_to_dict(inst)
-        assert isinstance(vessel_dict, dict)
-        assert vessel_dict["id"] == "reactor_01"
-
-        G = _build_test_graph()
-        actions = generate_stir_protocol(G=G, vessel=vessel_dict, time="30")
-
-        assert len(actions) >= 1
-        assert actions[0]["action_name"] == "stir"
-
-    def test_stir_with_string_vessel(self):
-        """兼容旧模式：直接传 vessel 字符串"""
-        from unilabos.compile.stir_protocol import generate_stir_protocol
-
-        G = _build_test_graph()
-        actions = generate_stir_protocol(G=G, vessel="reactor_01", time="30")
-
-        assert len(actions) >= 1
-        assert actions[0]["device_id"] == "stirrer_1"
-        assert actions[0]["action_kwargs"]["vessel"]["id"] == "reactor_01"
-
-
-# ============ 全链路测试：HeatChill 协议 ============
-
-class TestHeatChillProtocolFullChain:
-    """HeatChill 协议全链路"""
-
-    def test_heatchill_with_enriched_resource(self):
-        from unilabos.compile.heatchill_protocol import generate_heat_chill_protocol
-
-        raw_data = [_make_raw_resource(id="reactor_01", klass="virtual_stirrer")]
-        enriched_vessel = _simulate_workstation_resource_enrichment(raw_data)
-
-        G = _build_test_graph()
-        actions = generate_heat_chill_protocol(
-            G=G,
-            vessel=enriched_vessel,
-            temp=80.0,
-            time="300",
-        )
-
-        assert isinstance(actions, list)
-        assert len(actions) >= 1
-        action = actions[0]
-        assert action["device_id"] == "heatchill_1"
-        assert action["action_name"] == "heat_chill"
-        assert action["action_kwargs"]["temp"] == 80.0
-
-    def test_heatchill_start_with_enriched_resource(self):
-        from unilabos.compile.heatchill_protocol import generate_heat_chill_start_protocol
-
-        raw_data = [_make_raw_resource(id="reactor_01")]
-        enriched_vessel = _simulate_workstation_resource_enrichment(raw_data)
-
-        G = _build_test_graph()
-        actions = generate_heat_chill_start_protocol(
-            G=G,
-            vessel=enriched_vessel,
-            temp=60.0,
-        )
-
-        assert len(actions) >= 1
-        assert actions[0]["action_name"] == "heat_chill_start"
-        assert actions[0]["action_kwargs"]["temp"] == 60.0
-
-    def test_heatchill_stop_with_enriched_resource(self):
-        from unilabos.compile.heatchill_protocol import generate_heat_chill_stop_protocol
-
-        raw_data = [_make_raw_resource(id="reactor_01")]
-        enriched_vessel = _simulate_workstation_resource_enrichment(raw_data)
-
-        G = _build_test_graph()
-        actions = generate_heat_chill_stop_protocol(G=G, vessel=enriched_vessel)
-
-        assert len(actions) >= 1
-        assert actions[0]["action_name"] == "heat_chill_stop"
-
-
-# ============ 全链路测试：Add 协议 ============
-
-class TestAddProtocolFullChain:
-    """Add 协议全链路：vessel enrichment + reagent 查找 + 泵传输"""
-
-    def test_add_solid_with_enriched_resource(self):
-        from unilabos.compile.add_protocol import generate_add_protocol
-
-        raw_data = [_make_raw_resource(id="reactor_01")]
-        enriched_vessel = _simulate_workstation_resource_enrichment(raw_data)
-
-        G = _build_test_graph()
-        actions = generate_add_protocol(
-            G=G,
-            vessel=enriched_vessel,
-            reagent="NaCl",
-            mass="5 g",
-        )
-
-        assert isinstance(actions, list)
-        assert len(actions) >= 1
-        # 应该包含至少一个 add_solid 或 log_message 动作
-        action_names = [a.get("action_name", "") for a in actions]
-        assert any(name in ["add_solid", "log_message"] for name in action_names)
-
-    def test_add_liquid_with_enriched_resource(self):
-        from unilabos.compile.add_protocol import generate_add_protocol
-
-        raw_data = [_make_raw_resource(id="reactor_01")]
-        enriched_vessel = _simulate_workstation_resource_enrichment(raw_data)
-
-        G = _build_test_graph()
-        actions = generate_add_protocol(
-            G=G,
-            vessel=enriched_vessel,
-            reagent="water",
-            volume="10 mL",
-        )
-
-        assert isinstance(actions, list)
-        assert len(actions) >= 1
-
-
-# ============ 全链路测试：ResourceDictInstance 兼容层 ============
-
-class TestResourceDictInstanceCompatibility:
-    """验证编译器兼容层对 ResourceDictInstance 的处理"""
-
-    def test_get_vessel_from_enriched_dict(self):
-        """get_vessel 对 enriched dict 的处理"""
-        raw_data = [_make_raw_resource(
-            id="reactor_01",
-            data={"temperature": 25.0, "liquid": [{"liquid_type": "water", "volume": 10.0}]},
-        )]
-        enriched = _simulate_workstation_resource_enrichment(raw_data)
-
-        vessel_id, vessel_data = get_vessel(enriched)
-        assert vessel_id == "reactor_01"
-        assert vessel_data["temperature"] == 25.0
-        assert len(vessel_data["liquid"]) == 1
-
-    def test_get_vessel_from_resource_instance(self):
-        """get_vessel 直接对 ResourceDictInstance 的处理"""
-        raw_data = [_make_raw_resource(
-            id="reactor_01",
-            data={"temperature": 25.0},
-        )]
-        tree_set = ResourceTreeSet.from_raw_dict_list(raw_data)
-        inst = tree_set.trees[0].root_node
-
-        vessel_id, vessel_data = get_vessel(inst)
-        assert vessel_id == "reactor_01"
-        assert vessel_data["temperature"] == 25.0
-
-    def test_ensure_resource_instance_round_trip(self):
-        """ensure_resource_instance → resource_to_dict 无损往返"""
-        raw_data = [_make_raw_resource(
-            id="reactor_01", uuid="uuid-r01", klass="virtual_stirrer",
-            data={"temp": 25.0},
-        )]
-        enriched = _simulate_workstation_resource_enrichment(raw_data)
-
-        # dict → ResourceDictInstance
-        inst = ensure_resource_instance(enriched)
-        assert isinstance(inst, ResourceDictInstance)
-        assert inst.res_content.id == "reactor_01"
-        assert inst.res_content.uuid == "uuid-r01"
-
-        # ResourceDictInstance → dict
-        d = resource_to_dict(inst)
-        assert isinstance(d, dict)
-        assert d["id"] == "reactor_01"
-        assert d["uuid"] == "uuid-r01"
-        assert d["class"] == "virtual_stirrer"
-
-
-# ============ 全链路测试：带 children 的资源树 ============
-
-class TestResourceTreeWithChildren:
-    """测试带 children 结构的资源树通过编译器的路径"""
-
-    def _make_tree_with_children(self):
-        """构建 StationA -> [Flask1, Flask2] 的资源树"""
-        return [
-            _make_raw_resource(
-                id="StationA", uuid="uuid-station-a",
-                name="StationA", klass="workstation", type_="device",
-            ),
-            _make_raw_resource(
-                id="Flask1", uuid="uuid-flask-1",
-                name="Flask1", klass="", type_="resource",
-                parent="StationA", parent_uuid="uuid-station-a",
-                data={"liquid": [{"liquid_type": "water", "volume": 10.0}]},
-            ),
-            _make_raw_resource(
-                id="Flask2", uuid="uuid-flask-2",
-                name="Flask2", klass="", type_="resource",
-                parent="StationA", parent_uuid="uuid-station-a",
-                data={"liquid": [{"liquid_type": "ethanol", "volume": 5.0}]},
-            ),
-        ]
-
-    def test_enrichment_preserves_children_structure(self):
-        """验证 enrichment 后 children 为嵌套 dict"""
-        raw_data = self._make_tree_with_children()
-        enriched = _simulate_workstation_resource_enrichment(raw_data)
-
-        assert enriched["id"] == "StationA"
-        assert "children" in enriched
-        assert isinstance(enriched["children"], dict)
-        assert "Flask1" in enriched["children"]
-        assert "Flask2" in enriched["children"]
-
-    def test_children_preserve_uuid_and_data(self):
-        """验证 children 中的 uuid 和 data 被正确保留"""
-        raw_data = self._make_tree_with_children()
-        enriched = _simulate_workstation_resource_enrichment(raw_data)
-
-        flask1 = enriched["children"]["Flask1"]
-        assert flask1["uuid"] == "uuid-flask-1"
-        assert flask1["data"]["liquid"][0]["liquid_type"] == "water"
-        assert flask1["data"]["liquid"][0]["volume"] == 10.0
-
-        flask2 = enriched["children"]["Flask2"]
-        assert flask2["uuid"] == "uuid-flask-2"
-        assert flask2["data"]["liquid"][0]["liquid_type"] == "ethanol"
-
-    def test_children_dict_can_be_popped(self):
-        """模拟 batch_transfer_protocol 中 pop children 的操作"""
-        raw_data = self._make_tree_with_children()
-        enriched = _simulate_workstation_resource_enrichment(raw_data)
-
-        # batch_transfer_protocol 中会 pop children
-        children = enriched["children"]
-        popped = children.pop("Flask1")
-        assert popped["id"] == "Flask1"
-        assert "Flask1" not in enriched["children"]
-        assert "Flask2" in enriched["children"]
-
-    def test_children_dict_usable_as_from_repo(self):
-        """模拟 batch_transfer_protocol 中 from_repo 参数"""
-        raw_data = self._make_tree_with_children()
-        enriched = _simulate_workstation_resource_enrichment(raw_data)
-
-        # 模拟编译器接收的 from_repo 格式
-        from_repo = {"StationA": enriched}
-        from_repo_ = list(from_repo.values())[0]
-
-        assert from_repo_["id"] == "StationA"
-        assert "Flask1" in from_repo_["children"]
-        assert from_repo_["children"]["Flask1"]["uuid"] == "uuid-flask-1"
-
-    def test_sequence_resource_enrichment(self):
-        """sequence<Resource> 情况：多个独立资源树"""
-        raw_data1 = [_make_raw_resource(id="R1", uuid="uuid-r1")]
-        raw_data2 = [_make_raw_resource(id="R2", uuid="uuid-r2")]
-
-        tree_set1 = ResourceTreeSet.from_raw_dict_list(raw_data1)
-        tree_set2 = ResourceTreeSet.from_raw_dict_list(raw_data2)
-
-        results = [
-            tree.root_node.get_plr_nested_dict()
-            for ts in [tree_set1, tree_set2]
-            for tree in ts.trees
-        ]
-
-        assert len(results) == 2
-        assert results[0]["id"] == "R1"
-        assert results[1]["id"] == "R2"
-
-
-# ============ 全链路测试：动作列表结构验证 ============
-
-class TestActionListStructure:
-    """验证编译器返回的 action_list 结构符合 workstation 预期"""
-
-    def _validate_action(self, action):
-        """验证单个 action dict 的结构"""
-        if action.get("action_name") == "wait":
-            # wait 伪动作不需要 device_id
-            assert "action_kwargs" in action
-            assert "time" in action["action_kwargs"]
-            return
-
-        if action.get("action_name") == "log_message":
-            # log 伪动作
-            assert "action_kwargs" in action
-            return
-
-        # 正常设备动作
-        assert "device_id" in action, f"action 缺少 device_id: {action}"
-        assert "action_name" in action, f"action 缺少 action_name: {action}"
-        assert "action_kwargs" in action, f"action 缺少 action_kwargs: {action}"
-        assert isinstance(action["action_kwargs"], dict)
-
-    def test_stir_action_list_structure(self):
-        from unilabos.compile.stir_protocol import generate_stir_protocol
-
-        raw_data = [_make_raw_resource(id="reactor_01")]
-        enriched = _simulate_workstation_resource_enrichment(raw_data)
-
-        G = _build_test_graph()
-        actions = generate_stir_protocol(G=G, vessel=enriched, time="60")
-
-        for action in actions:
-            if isinstance(action, list):
-                # 并行动作
-                for sub_action in action:
-                    self._validate_action(sub_action)
-            else:
-                self._validate_action(action)
-
-    def test_heatchill_action_list_structure(self):
-        from unilabos.compile.heatchill_protocol import generate_heat_chill_protocol
-
-        raw_data = [_make_raw_resource(id="reactor_01")]
-        enriched = _simulate_workstation_resource_enrichment(raw_data)
-
-        G = _build_test_graph()
-        actions = generate_heat_chill_protocol(G=G, vessel=enriched, temp=80.0, time="60")
-
-        for action in actions:
-            if isinstance(action, list):
-                for sub_action in action:
-                    self._validate_action(sub_action)
-            else:
-                self._validate_action(action)
-
-    def test_add_action_list_structure(self):
-        from unilabos.compile.add_protocol import generate_add_protocol
-
-        raw_data = [_make_raw_resource(id="reactor_01")]
-        enriched = _simulate_workstation_resource_enrichment(raw_data)
-
-        G = _build_test_graph()
-        actions = generate_add_protocol(G=G, vessel=enriched, reagent="NaCl", mass="5 g")
-
-        for action in actions:
-            if isinstance(action, list):
-                for sub_action in action:
-                    self._validate_action(sub_action)
-            else:
-                self._validate_action(action)
-
-
-# ============ 全链路测试：message_converter 到 enrichment ============
-
-class TestMessageConverterToEnrichment:
-    """模拟从 ROS 消息转换后的 dict 到 enrichment 的完整链路"""
-
-    def test_ros_goal_conversion_simulation(self):
-        """
-        模拟 workstation.py 中的完整流程：
-        1. ROS goal 中的 vessel 字段被 convert_from_ros_msg 转换为浅层 dict
-        2. workstation 用 resource_id 请求 host 获取完整资源数据
-        3. ResourceTreeSet.from_raw_dict_list 构建资源树
-        4. get_plr_nested_dict 生成嵌套 dict 替换 protocol_kwargs[k]
-        """
-        # 步骤1: 模拟 convert_from_ros_msg 的输出（浅层 dict，只有 id 等基本字段）
-        shallow_vessel = {
-            "id": "reactor_01",
-            "uuid": "uuid-reactor-01",
-            "name": "reactor_01",
-            "type": "device",
-            "category": "virtual_stirrer",
-            "children": [],
-            "parent": "",
-            "parent_uuid": "",
-            "config": {},
-            "data": {},
-            "extra": {},
-            "position": {"x": 0.0, "y": 0.0, "z": 0.0},
-        }
-
-        protocol_kwargs = {
-            "vessel": shallow_vessel,
-            "time": "300",
-            "stir_speed": 300.0,
-        }
-
-        # 步骤2: 提取 resource_id
-        resource_id = protocol_kwargs["vessel"]["id"]
-        assert resource_id == "reactor_01"
-
-        # 步骤3: 模拟 host 返回完整数据（带 children）
-        host_response = [
-            _make_raw_resource(
-                id="reactor_01", uuid="uuid-reactor-01",
-                klass="virtual_stirrer", type_="device",
-                data={"temperature": 25.0, "pressure": 1.0},
-                config={"max_temp": 300.0},
-            ),
-        ]
-
-        # 步骤4: enrichment
-        enriched = _simulate_workstation_resource_enrichment(host_response)
-        protocol_kwargs["vessel"] = enriched
-
-        # 验证 enrichment 后的 protocol_kwargs
-        assert protocol_kwargs["vessel"]["id"] == "reactor_01"
-        assert protocol_kwargs["vessel"]["uuid"] == "uuid-reactor-01"
-        assert protocol_kwargs["vessel"]["class"] == "virtual_stirrer"
-        assert protocol_kwargs["vessel"]["data"]["temperature"] == 25.0
-        assert protocol_kwargs["vessel"]["config"]["max_temp"] == 300.0
-
-        # 步骤5: 传给编译器
-        from unilabos.compile.stir_protocol import generate_stir_protocol
-        G = _build_test_graph()
-        actions = generate_stir_protocol(G=G, **protocol_kwargs)
-
-        assert len(actions) >= 1
-        assert actions[0]["device_id"] == "stirrer_1"
-        assert actions[0]["action_name"] == "stir"
-
-    def test_ros_goal_with_children_enrichment(self):
-        """ROS goal → enrichment 带 children 的场景（batch transfer）"""
-        # 模拟 host 返回带 children 的数据
-        host_response = [
-            _make_raw_resource(
-                id="StationA", uuid="uuid-sa", klass="workstation", type_="device",
-                config={"num_items_x": 4, "num_items_y": 2},
-            ),
-            _make_raw_resource(
-                id="Plate1", uuid="uuid-p1", type_="resource",
-                parent="StationA", parent_uuid="uuid-sa",
-                data={"sample": "sample_A"},
-            ),
-            _make_raw_resource(
-                id="Plate2", uuid="uuid-p2", type_="resource",
-                parent="StationA", parent_uuid="uuid-sa",
-                data={"sample": "sample_B"},
-            ),
-        ]
-
-        enriched = _simulate_workstation_resource_enrichment(host_response)
-
-        assert enriched["id"] == "StationA"
-        assert enriched["class"] == "workstation"
-        assert len(enriched["children"]) == 2
-        assert enriched["children"]["Plate1"]["data"]["sample"] == "sample_A"
-        assert enriched["children"]["Plate2"]["uuid"] == "uuid-p2"
-
-        # 模拟 batch_transfer 的 from_repo 格式
-        from_repo = {"StationA": enriched}
-        from_repo_ = list(from_repo.values())[0]
-        assert "Plate1" in from_repo_["children"]
-        assert from_repo_["children"]["Plate1"]["uuid"] == "uuid-p1"
-
-
-# ============ 全链路测试：多协议连续调用 ============
-
-class TestMultiProtocolChain:
-    """模拟连续执行多个协议（如 add → stir → heatchill）"""
-
-    def test_sequential_protocol_execution(self):
-        """模拟典型合成路径：add → stir → heatchill"""
-        from unilabos.compile.stir_protocol import generate_stir_protocol
-        from unilabos.compile.heatchill_protocol import generate_heat_chill_protocol
-        from unilabos.compile.add_protocol import generate_add_protocol
-
-        raw_data = [_make_raw_resource(
-            id="reactor_01", uuid="uuid-reactor-01",
-            klass="virtual_stirrer", type_="device",
-        )]
-        enriched = _simulate_workstation_resource_enrichment(raw_data)
-        G = _build_test_graph()
-
-        # 每次调用用 enriched 的副本，避免编译器修改原数据
-        all_actions = []
-
-        # 步骤1: 添加试剂
-        add_actions = generate_add_protocol(
-            G=G, vessel=copy.deepcopy(enriched),
-            reagent="NaCl", mass="5 g",
-        )
-        all_actions.extend(add_actions)
-
-        # 步骤2: 搅拌
-        stir_actions = generate_stir_protocol(
-            G=G, vessel=copy.deepcopy(enriched),
-            time="60", stir_speed=300.0,
-        )
-        all_actions.extend(stir_actions)
-
-        # 步骤3: 加热
-        heat_actions = generate_heat_chill_protocol(
-            G=G, vessel=copy.deepcopy(enriched),
-            temp=80.0, time="300",
-        )
-        all_actions.extend(heat_actions)
-
-        # 验证总动作列表
-        assert len(all_actions) >= 3
-        # 每个协议至少产生一个核心动作
-        action_names = [a.get("action_name", "") for a in all_actions if isinstance(a, dict)]
-        assert "stir" in action_names
-        assert "heat_chill" in action_names
-
-    def test_enriched_resource_not_mutated(self):
-        """验证编译器不应修改传入的 enriched dict（如果需要修改应 deepcopy）"""
-        from unilabos.compile.stir_protocol import generate_stir_protocol
-
-        raw_data = [_make_raw_resource(id="reactor_01")]
-        enriched = _simulate_workstation_resource_enrichment(raw_data)
-        original_id = enriched["id"]
-        original_uuid = enriched["uuid"]
-
-        G = _build_test_graph()
-        generate_stir_protocol(G=G, vessel=enriched, time="60")
-
-        # 验证 enriched dict 核心字段未被修改
-        assert enriched["id"] == original_id
-        assert enriched["uuid"] == original_uuid
--- a/tests/compile/test_pump_separate_full_chain.py
+++ b/tests/compile/test_pump_separate_full_chain.py
@@ -1,538 +0,0 @@
-"""
-PumpTransfer 和 Separate 全链路测试
-
-构建包含泵/阀门/分液漏斗的完整设备图，
-输出完整的中间数据（最短路径、泵骨架、动作列表等）。
-"""
-
-import copy
-import json
-import pprint
-import pytest
-import networkx as nx
-
-from unilabos.resources.resource_tracker import ResourceTreeSet
-from unilabos.compile.utils.resource_helper import get_resource_id, get_resource_data
-from unilabos.compile.utils.vessel_parser import get_vessel
-
-
-def _make_raw_resource(id, uuid=None, name=None, klass="", type_="device",
-                       parent=None, parent_uuid=None, data=None, config=None, extra=None):
-    return {
-        "id": id,
-        "uuid": uuid or f"uuid-{id}",
-        "name": name or id,
-        "class": klass,
-        "type": type_,
-        "parent": parent,
-        "parent_uuid": parent_uuid or "",
-        "description": "",
-        "config": config or {},
-        "data": data or {},
-        "extra": extra or {},
-        "position": {"x": 0.0, "y": 0.0, "z": 0.0},
-    }
-
-
-def _simulate_enrichment(raw_data_list):
-    tree_set = ResourceTreeSet.from_raw_dict_list(raw_data_list)
-    root = tree_set.trees[0].root_node if tree_set.trees else None
-    return root.get_plr_nested_dict() if root else {}
-
-
-def _build_pump_transfer_graph():
-    """
-    构建带泵/阀门的设备图，用于测试 PumpTransfer:
-
-    flask_water (container)
-        ↓
-    valve_1 (multiway_valve, pump_1 连接)
-        ↓
-    reactor_01 (device)
-
-    同时有: stirrer_1, heatchill_1, separator_1
-    """
-    G = nx.DiGraph()
-
-    # 源容器
-    G.add_node("flask_water", **{
-        "id": "flask_water", "name": "flask_water",
-        "type": "container", "class": "",
-        "data": {"reagent_name": "water", "liquid": [{"liquid_type": "water", "volume": 200.0}]},
-        "config": {"reagent": "water"},
-    })
-
-    # 多通阀
-    G.add_node("valve_1", **{
-        "id": "valve_1", "name": "valve_1",
-        "type": "device", "class": "multiway_valve",
-        "data": {}, "config": {},
-    })
-
-    # 注射泵（连接到阀门）
-    G.add_node("pump_1", **{
-        "id": "pump_1", "name": "pump_1",
-        "type": "device", "class": "virtual_pump",
-        "data": {}, "config": {"max_volume": 25.0},
-    })
-
-    # 目标容器
-    G.add_node("reactor_01", **{
-        "id": "reactor_01", "name": "reactor_01",
-        "type": "device", "class": "virtual_stirrer",
-        "data": {"liquid": [{"liquid_type": "water", "volume": 50.0}]},
-        "config": {},
-    })
-
-    # 搅拌器
-    G.add_node("stirrer_1", **{
-        "id": "stirrer_1", "name": "stirrer_1",
-        "type": "device", "class": "virtual_stirrer",
-        "data": {}, "config": {},
-    })
-
-    # 加热器
-    G.add_node("heatchill_1", **{
-        "id": "heatchill_1", "name": "heatchill_1",
-        "type": "device", "class": "virtual_heatchill",
-        "data": {}, "config": {},
-    })
-
-    # 分离器
-    G.add_node("separator_1", **{
-        "id": "separator_1", "name": "separator_1",
-        "type": "device", "class": "separator_controller",
-        "data": {}, "config": {},
-    })
-
-    # 废液容器
-    G.add_node("waste_workup", **{
-        "id": "waste_workup", "name": "waste_workup",
-        "type": "container", "class": "",
-        "data": {}, "config": {},
-    })
-
-    # 产物收集瓶
-    G.add_node("product_flask", **{
-        "id": "product_flask", "name": "product_flask",
-        "type": "container", "class": "",
-        "data": {}, "config": {},
-    })
-
-    # DCM溶剂瓶
-    G.add_node("flask_dcm", **{
-        "id": "flask_dcm", "name": "flask_dcm",
-        "type": "container", "class": "",
-        "data": {"reagent_name": "dcm", "liquid": [{"liquid_type": "dcm", "volume": 500.0}]},
-        "config": {"reagent": "dcm"},
-    })
-
-    # 边连接 —— flask_water → valve_1 → reactor_01
-    G.add_edge("flask_water", "valve_1", port={"valve_1": "port_1"})
-    G.add_edge("valve_1", "reactor_01", port={"valve_1": "port_2"})
-    # 阀门 → 泵
-    G.add_edge("valve_1", "pump_1")
-    G.add_edge("pump_1", "valve_1")
-    # 搅拌器 ↔ reactor
-    G.add_edge("stirrer_1", "reactor_01")
-    # 加热器 ↔ reactor
-    G.add_edge("heatchill_1", "reactor_01")
-    # 分离器 ↔ reactor
-    G.add_edge("separator_1", "reactor_01")
-    G.add_edge("reactor_01", "separator_1")
-    # DCM → valve → reactor (同一泵路)
-    G.add_edge("flask_dcm", "valve_1", port={"valve_1": "port_3"})
-    # reactor → valve → product/waste
-    G.add_edge("valve_1", "product_flask", port={"valve_1": "port_4"})
-    G.add_edge("valve_1", "waste_workup", port={"valve_1": "port_5"})
-
-    return G
-
-
-def _format_action(action, indent=0):
-    """格式化单个 action 为可读字符串"""
-    prefix = "  " * indent
-    if isinstance(action, list):
-        # 并行动作
-        lines = [f"{prefix}[PARALLEL]"]
-        for sub in action:
-            lines.append(_format_action(sub, indent + 1))
-        return "\n".join(lines)
-
-    name = action.get("action_name", "?")
-    device = action.get("device_id", "")
-    kwargs = action.get("action_kwargs", {})
-    comment = action.get("_comment", "")
-    meta = action.get("_transfer_meta", "")
-
-    parts = [f"{prefix}→ {device}::{name}"]
-    if kwargs:
-        # 精简输出
-        kw_str = ", ".join(f"{k}={v}" for k, v in kwargs.items()
-                           if k not in ("progress_message",))
-        if kw_str:
-            parts.append(f"  kwargs: {{{kw_str}}}")
-    if comment:
-        parts.append(f"  # {comment}")
-    if meta:
-        parts.append(f"  meta: {meta}")
-    return "\n".join(f"{prefix}{p}" if i > 0 else p for i, p in enumerate(parts))
-
-
-def _dump_actions(actions, title=""):
-    """打印完整动作列表"""
-    print(f"\n{'='*70}")
-    print(f"  {title}")
-    print(f"  总动作数: {len(actions)}")
-    print(f"{'='*70}")
-    for i, action in enumerate(actions):
-        print(f"\n  [{i:02d}] {_format_action(action, indent=2)}")
-    print(f"\n{'='*70}\n")
-
-
-# ==================== PumpTransfer 全链路 ====================
-
-class TestPumpTransferFullChain:
-    """PumpTransfer: 包含图路径查找、泵骨架构建、动作序列生成"""
-
-    def test_pump_transfer_basic(self):
-        """基础泵转移：flask_water → valve_1 → reactor_01"""
-        from unilabos.compile.pump_protocol import generate_pump_protocol
-
-        G = _build_pump_transfer_graph()
-
-        # 检查最短路径
-        path = nx.shortest_path(G, "flask_water", "reactor_01")
-        print(f"\n最短路径: {path}")
-        assert "valve_1" in path
-
-        # 调用编译器
-        actions = generate_pump_protocol(
-            G=G,
-            from_vessel_id="flask_water",
-            to_vessel_id="reactor_01",
-            volume=10.0,
-            flowrate=2.5,
-            transfer_flowrate=0.5,
-        )
-
-        _dump_actions(actions, "PumpTransfer: flask_water → reactor_01, 10mL")
-
-        # 验证
-        assert isinstance(actions, list)
-        assert len(actions) > 0
-        # 应该有 set_valve_position 和 set_position 动作
-        flat = [a for a in actions if isinstance(a, dict)]
-        action_names = [a.get("action_name") for a in flat]
-        print(f"动作名称列表: {action_names}")
-        assert "set_valve_position" in action_names
-        assert "set_position" in action_names
-
-    def test_pump_transfer_with_rinsing_enriched_vessel(self):
-        """pump_with_rinsing 接收 enriched vessel dict"""
-        from unilabos.compile.pump_protocol import generate_pump_protocol_with_rinsing
-
-        G = _build_pump_transfer_graph()
-
-        # 模拟 enrichment
-        from_raw = [_make_raw_resource(
-            id="flask_water", klass="", type_="container",
-            data={"reagent_name": "water", "liquid": [{"liquid_type": "water", "volume": 200.0}]},
-        )]
-        to_raw = [_make_raw_resource(
-            id="reactor_01", klass="virtual_stirrer", type_="device",
-        )]
-
-        from_enriched = _simulate_enrichment(from_raw)
-        to_enriched = _simulate_enrichment(to_raw)
-
-        print(f"\nfrom_vessel enriched: {json.dumps(from_enriched, indent=2, ensure_ascii=False)[:300]}...")
-        print(f"to_vessel enriched: {json.dumps(to_enriched, indent=2, ensure_ascii=False)[:300]}...")
-
-        # get_vessel 兼容
-        fid, fdata = get_vessel(from_enriched)
-        tid, tdata = get_vessel(to_enriched)
-        print(f"from_vessel_id={fid}, to_vessel_id={tid}")
-        assert fid == "flask_water"
-        assert tid == "reactor_01"
-
-        actions = generate_pump_protocol_with_rinsing(
-            G=G,
-            from_vessel=from_enriched,
-            to_vessel=to_enriched,
-            volume=15.0,
-            flowrate=2.5,
-            transfer_flowrate=0.5,
-        )
-
-        _dump_actions(actions, "PumpTransferWithRinsing: flask_water → reactor_01, 15mL (enriched)")
-
-        assert isinstance(actions, list)
-        assert len(actions) > 0
-
-    def test_pump_transfer_multi_batch(self):
-        """体积 > max_volume 时自动分批"""
-        from unilabos.compile.pump_protocol import generate_pump_protocol
-
-        G = _build_pump_transfer_graph()
-
-        # pump_1 的 max_volume = 25mL，转 60mL 应该分 3 批
-        actions = generate_pump_protocol(
-            G=G,
-            from_vessel_id="flask_water",
-            to_vessel_id="reactor_01",
-            volume=60.0,
-            flowrate=2.5,
-            transfer_flowrate=0.5,
-        )
-
-        _dump_actions(actions, "PumpTransfer 分批: 60mL (max_volume=25mL, 预期 3 批)")
-
-        assert len(actions) > 0
-        # 应该有多轮 set_position
-        flat = [a for a in actions if isinstance(a, dict)]
-        set_position_count = sum(1 for a in flat if a.get("action_name") == "set_position")
-        print(f"set_position 动作数: {set_position_count}")
-        # 3批 × 2次 (吸液 + 排液) = 6 次 set_position
-        assert set_position_count >= 6
-
-    def test_pump_transfer_no_path(self):
-        """无路径时返回空"""
-        from unilabos.compile.pump_protocol import generate_pump_protocol
-
-        G = _build_pump_transfer_graph()
-        G.add_node("isolated_flask", type="container")
-
-        actions = generate_pump_protocol(
-            G=G,
-            from_vessel_id="isolated_flask",
-            to_vessel_id="reactor_01",
-            volume=10.0,
-        )
-
-        print(f"\n无路径时的动作列表: {actions}")
-        assert actions == []
-
-    def test_pump_backbone_filtering(self):
-        """验证泵骨架过滤逻辑（电磁阀被跳过）"""
-        from unilabos.compile.pump_protocol import generate_pump_protocol
-
-        G = _build_pump_transfer_graph()
-        # 添加电磁阀到路径中
-        G.add_node("solenoid_valve_1", **{
-            "type": "device", "class": "solenoid_valve",
-            "data": {}, "config": {},
-        })
-        # flask_water → solenoid_valve_1 → valve_1 → reactor_01
-        G.remove_edge("flask_water", "valve_1")
-        G.add_edge("flask_water", "solenoid_valve_1")
-        G.add_edge("solenoid_valve_1", "valve_1")
-
-        path = nx.shortest_path(G, "flask_water", "reactor_01")
-        print(f"\n含电磁阀的路径: {path}")
-        assert "solenoid_valve_1" in path
-
-        actions = generate_pump_protocol(
-            G=G,
-            from_vessel_id="flask_water",
-            to_vessel_id="reactor_01",
-            volume=10.0,
-        )
-
-        _dump_actions(actions, "PumpTransfer 含电磁阀: flask_water → solenoid → valve_1 → reactor_01")
-        # 电磁阀应被跳过，泵骨架只有 valve_1
-        assert len(actions) > 0
-
-
-# ==================== Separate 全链路 ====================
-
-class TestSeparateProtocolFullChain:
-    """Separate: 包含 bug 确认和正常路径测试"""
-
-    def test_separate_bug_line_128_fixed(self):
-        """验证 separate_protocol.py:128 的 bug 已修复（不再 crash）"""
-        from unilabos.compile.separate_protocol import generate_separate_protocol
-
-        G = _build_pump_transfer_graph()
-
-        raw_data = [_make_raw_resource(
-            id="reactor_01", klass="virtual_stirrer",
-            data={"liquid": [{"liquid_type": "water", "volume": 100.0}]},
-        )]
-        enriched = _simulate_enrichment(raw_data)
-
-        # 修复前：final_vessel_id, _ = vessel_id 会 crash（字符串解包）
-        # 修复后：final_vessel_id = vessel_id，正常返回 action 列表
-        result = generate_separate_protocol(
-            G=G,
-            vessel=enriched,
-            purpose="extract",
-            product_phase="top",
-            product_vessel="product_flask",
-            waste_vessel="waste_workup",
-            solvent="dcm",
-            volume="100 mL",
-        )
-        assert isinstance(result, list)
-        assert len(result) > 0
-
-    def test_separate_manual_workaround(self):
-        """
-        绕过 line 128 bug，手动测试分离编译器中可以工作的子函数
-        """
-        from unilabos.compile.separate_protocol import (
-            find_separator_device,
-            find_separation_vessel_bottom,
-        )
-        from unilabos.compile.utils.vessel_parser import (
-            find_connected_stirrer,
-            find_solvent_vessel,
-        )
-        from unilabos.compile.utils.unit_parser import parse_volume_input
-        from unilabos.compile.utils.resource_helper import get_resource_liquid_volume as get_vessel_liquid_volume
-
-        G = _build_pump_transfer_graph()
-
-        # 1. get_vessel 解析 enriched dict
-        raw_data = [_make_raw_resource(
-            id="reactor_01", klass="virtual_stirrer",
-            data={"liquid": [{"liquid_type": "water", "volume": 100.0}]},
-        )]
-        enriched = _simulate_enrichment(raw_data)
-        vessel_id, vessel_data = get_vessel(enriched)
-        print(f"\nvessel_id: {vessel_id}")
-        print(f"vessel_data: {vessel_data}")
-        assert vessel_id == "reactor_01"
-        assert vessel_data["liquid"][0]["volume"] == 100.0
-
-        # 2. find_separator_device
-        sep = find_separator_device(G, vessel_id)
-        print(f"分离器设备: {sep}")
-        assert sep == "separator_1"
-
-        # 3. find_connected_stirrer
-        stirrer = find_connected_stirrer(G, vessel_id)
-        print(f"搅拌器设备: {stirrer}")
-        assert stirrer == "stirrer_1"
-
-        # 4. find_solvent_vessel
-        solvent_v = find_solvent_vessel(G, "dcm")
-        print(f"DCM溶剂容器: {solvent_v}")
-        assert solvent_v == "flask_dcm"
-
-        # 5. parse_volume_input
-        vol = parse_volume_input("200 mL")
-        print(f"体积解析: '200 mL' → {vol}")
-        assert vol == 200.0
-
-        vol2 = parse_volume_input("1.5 L")
-        print(f"体积解析: '1.5 L' → {vol2}")
-        assert vol2 == 1500.0
-
-        # 6. get_vessel_liquid_volume
-        liq_vol = get_vessel_liquid_volume(enriched)
-        print(f"液体体积 (enriched dict): {liq_vol}")
-        assert liq_vol == 100.0
-
-        # 7. find_separation_vessel_bottom
-        bottom = find_separation_vessel_bottom(G, vessel_id)
-        print(f"分离容器底部: {bottom}")
-        # 当前图中没有命名匹配的底部容器
-
-    def test_pump_transfer_for_separate_subflow(self):
-        """测试 separate 中调用的 pump 子流程（溶剂添加 → 分液漏斗）"""
-        from unilabos.compile.pump_protocol import generate_pump_protocol_with_rinsing
-
-        G = _build_pump_transfer_graph()
-
-        # 模拟分离前的溶剂添加步骤
-        actions = generate_pump_protocol_with_rinsing(
-            G=G,
-            from_vessel="flask_dcm",
-            to_vessel="reactor_01",
-            volume=100.0,
-            flowrate=2.5,
-            transfer_flowrate=0.5,
-        )
-
-        _dump_actions(actions, "Separate 子流程: flask_dcm → reactor_01, 100mL DCM")
-
-        assert isinstance(actions, list)
-        assert len(actions) > 0
-
-        # 模拟分离后产物转移
-        actions2 = generate_pump_protocol_with_rinsing(
-            G=G,
-            from_vessel="reactor_01",
-            to_vessel="product_flask",
-            volume=50.0,
-            flowrate=2.5,
-            transfer_flowrate=0.5,
-        )
-
-        _dump_actions(actions2, "Separate 子流程: reactor_01 → product_flask, 50mL 产物")
-
-        assert len(actions2) > 0
-
-        # 废液转移
-        actions3 = generate_pump_protocol_with_rinsing(
-            G=G,
-            from_vessel="reactor_01",
-            to_vessel="waste_workup",
-            volume=50.0,
-            flowrate=2.5,
-            transfer_flowrate=0.5,
-        )
-
-        _dump_actions(actions3, "Separate 子流程: reactor_01 → waste_workup, 50mL 废液")
-
-        assert len(actions3) > 0
-
-
-# ==================== 图路径可视化 ====================
-
-class TestGraphPathVisualization:
-    """输出图中关键路径信息"""
-
-    def test_all_shortest_paths(self):
-        """输出所有容器之间的最短路径"""
-        G = _build_pump_transfer_graph()
-
-        containers = [n for n in G.nodes() if G.nodes[n].get("type") == "container"]
-        devices = [n for n in G.nodes() if G.nodes[n].get("type") == "device"]
-
-        print(f"\n{'='*70}")
-        print(f"  设备图概览")
-        print(f"{'='*70}")
-        print(f"  容器节点 ({len(containers)}): {containers}")
-        print(f"  设备节点 ({len(devices)}): {devices}")
-        print(f"  边数: {G.number_of_edges()}")
-        print(f"  边列表:")
-        for u, v, data in G.edges(data=True):
-            port_info = data.get("port", "")
-            print(f"    {u} → {v}  {port_info if port_info else ''}")
-
-        print(f"\n  关键路径:")
-        pairs = [
-            ("flask_water", "reactor_01"),
-            ("flask_dcm", "reactor_01"),
-            ("reactor_01", "product_flask"),
-            ("reactor_01", "waste_workup"),
-            ("flask_water", "product_flask"),
-        ]
-        for src, dst in pairs:
-            try:
-                path = nx.shortest_path(G, src, dst)
-                length = len(path) - 1
-                # 标注路径上的节点类型
-                annotated = []
-                for n in path:
-                    ntype = G.nodes[n].get("type", "?")
-                    nclass = G.nodes[n].get("class", "")
-                    annotated.append(f"{n}({ntype}{'/' + nclass if nclass else ''})")
-                print(f"    {src} → {dst}: 距离={length}")
-                print(f"      路径: {' → '.join(annotated)}")
-            except nx.NetworkXNoPath:
-                print(f"    {src} → {dst}: 无路径!")
-
-        print(f"{'='*70}\n")
--- a/tests/compile/test_resource_conversion_path.py
+++ b/tests/compile/test_resource_conversion_path.py
@@ -1,324 +0,0 @@
-"""
-ROS Goal → Resource 转换 → 编译器路径的集成测试
-
-覆盖：
-1. Resource.msg 新字段(uuid, klass, extra)的往返转换
-2. dict → ROS Resource → dict 往返无损
-3. ResourceTreeSet → get_plr_nested_dict 保留 children 结构
-4. resource_helper 兼容 dict / ResourceDictInstance
-5. vessel_parser.get_vessel 兼容 ResourceDictInstance
-"""
-
-import json
-import pytest
-
-# 不依赖 ROS 的测试 —— 直接测试 resource 处理路径
-from unilabos.resources.resource_tracker import (
-    ResourceDict,
-    ResourceDictInstance,
-    ResourceTreeInstance,
-    ResourceTreeSet,
-)
-from unilabos.compile.utils.resource_helper import (
-    ensure_resource_instance,
-    resource_to_dict,
-    get_resource_id,
-    get_resource_data,
-    get_resource_display_info,
-    get_resource_liquid_volume,
-)
-from unilabos.compile.utils.vessel_parser import get_vessel
-
-
-# ============ 构建测试数据 ============
-
-
-def _make_resource_dict(
-    id="reactor_01",
-    uuid="uuid-reactor-01",
-    name="reactor_01",
-    klass="virtual_stirrer",
-    type_="device",
-    parent=None,
-    parent_uuid=None,
-    data=None,
-    config=None,
-    extra=None,
-):
-    return {
-        "id": id,
-        "uuid": uuid,
-        "name": name,
-        "class": klass,
-        "type": type_,
-        "parent": parent,
-        "parent_uuid": parent_uuid or "",
-        "description": "",
-        "config": config or {},
-        "data": data or {},
-        "extra": extra or {},
-        "position": {"x": 1.0, "y": 2.0, "z": 3.0},
-    }
-
-
-def _make_resource_instance(id="reactor_01", **kwargs):
-    d = _make_resource_dict(id=id, **kwargs)
-    return ResourceDictInstance.get_resource_instance_from_dict(d)
-
-
-def _make_tree_with_children():
-    """构建 StationA -> [R1, R2] 的资源树"""
-    raw_data = [
-        _make_resource_dict(
-            id="StationA",
-            uuid="uuid-station-a",
-            name="StationA",
-            klass="workstation",
-            type_="device",
-        ),
-        _make_resource_dict(
-            id="R1",
-            uuid="uuid-r1",
-            name="R1",
-            klass="",
-            type_="resource",
-            parent="StationA",
-            parent_uuid="uuid-station-a",
-            data={"liquid": [{"liquid_type": "water", "volume": 10.0}]},
-        ),
-        _make_resource_dict(
-            id="R2",
-            uuid="uuid-r2",
-            name="R2",
-            klass="",
-            type_="resource",
-            parent="StationA",
-            parent_uuid="uuid-station-a",
-            data={"liquid": [{"liquid_type": "ethanol", "volume": 5.0}]},
-        ),
-    ]
-    tree_set = ResourceTreeSet.from_raw_dict_list(raw_data)
-    return tree_set
-
-
-# ============ resource_helper 测试 ============
-
-
-class TestResourceHelper:
-    """测试 resource_helper 对 dict / ResourceDictInstance 的兼容性"""
-
-    def test_ensure_resource_instance_from_dict(self):
-        d = _make_resource_dict()
-        inst = ensure_resource_instance(d)
-        assert isinstance(inst, ResourceDictInstance)
-        assert inst.res_content.id == "reactor_01"
-        assert inst.res_content.uuid == "uuid-reactor-01"
-
-    def test_ensure_resource_instance_passthrough(self):
-        inst = _make_resource_instance()
-        result = ensure_resource_instance(inst)
-        assert result is inst  # 同一个对象，不复制
-
-    def test_ensure_resource_instance_none(self):
-        assert ensure_resource_instance(None) is None
-
-    def test_get_resource_id_from_dict(self):
-        d = _make_resource_dict(id="my_device")
-        assert get_resource_id(d) == "my_device"
-
-    def test_get_resource_id_from_instance(self):
-        inst = _make_resource_instance(id="my_device")
-        assert get_resource_id(inst) == "my_device"
-
-    def test_get_resource_id_from_string(self):
-        assert get_resource_id("my_device") == "my_device"
-
-    def test_get_resource_id_from_wrapped_dict(self):
-        """兼容 {station_id: {...}} 格式"""
-        d = {"StationA": {"id": "StationA", "name": "StationA"}}
-        assert get_resource_id(d) == "StationA"
-
-    def test_get_resource_data_from_dict(self):
-        d = _make_resource_dict(data={"temperature": 25.0})
-        assert get_resource_data(d) == {"temperature": 25.0}
-
-    def test_get_resource_data_from_instance(self):
-        inst = _make_resource_instance(data={"temperature": 25.0})
-        data = get_resource_data(inst)
-        assert data["temperature"] == 25.0
-
-    def test_get_resource_display_info_from_dict(self):
-        d = _make_resource_dict(id="reactor_01", name="Reactor #1")
-        info = get_resource_display_info(d)
-        assert "reactor_01" in info
-        assert "Reactor #1" in info
-
-    def test_get_resource_display_info_from_instance(self):
-        inst = _make_resource_instance(id="reactor_01", name="Reactor #1")
-        info = get_resource_display_info(inst)
-        assert "reactor_01" in info
-
-    def test_get_resource_display_info_from_string(self):
-        assert get_resource_display_info("reactor_01") == "reactor_01"
-
-    def test_get_resource_liquid_volume(self):
-        d = _make_resource_dict(data={"liquid": [{"liquid_type": "water", "volume": 15.5}]})
-        assert get_resource_liquid_volume(d) == pytest.approx(15.5)
-
-    def test_resource_to_dict_from_instance(self):
-        inst = _make_resource_instance(id="reactor_01", klass="virtual_stirrer")
-        d = resource_to_dict(inst)
-        assert isinstance(d, dict)
-        assert d["id"] == "reactor_01"
-        assert d["class"] == "virtual_stirrer"
-
-    def test_resource_to_dict_passthrough(self):
-        d = _make_resource_dict()
-        result = resource_to_dict(d)
-        assert result is d  # 同一个 dict
-
-
-# ============ vessel_parser 兼容性测试 ============
-
-
-class TestVesselParser:
-    """测试 vessel_parser.get_vessel 对 ResourceDictInstance 的兼容"""
-
-    def test_get_vessel_from_dict(self):
-        d = _make_resource_dict(id="reactor_01", data={"temperature": 25.0})
-        vessel_id, vessel_data = get_vessel(d)
-        assert vessel_id == "reactor_01"
-        assert vessel_data["temperature"] == 25.0
-
-    def test_get_vessel_from_string(self):
-        vessel_id, vessel_data = get_vessel("reactor_01")
-        assert vessel_id == "reactor_01"
-        assert vessel_data == {}
-
-    def test_get_vessel_from_resource_instance(self):
-        inst = _make_resource_instance(id="reactor_01", data={"temperature": 25.0})
-        vessel_id, vessel_data = get_vessel(inst)
-        assert vessel_id == "reactor_01"
-        assert vessel_data["temperature"] == 25.0
-
-    def test_get_vessel_from_wrapped_dict(self):
-        """兼容 {station_id: {id: ..., data: {...}}} 格式"""
-        d = {"StationA": {"id": "StationA", "data": {"vol": 100}}}
-        vessel_id, vessel_data = get_vessel(d)
-        assert vessel_id == "StationA"
-
-
-# ============ ResourceTreeSet → get_plr_nested_dict 测试 ============
-
-
-class TestResourceTreeRoundTrip:
-    """测试 ResourceTreeSet → get_plr_nested_dict 保留树结构和关键字段"""
-
-    def test_tree_preserves_children(self):
-        tree_set = _make_tree_with_children()
-        assert len(tree_set.trees) == 1
-        root = tree_set.trees[0].root_node
-        assert root.res_content.id == "StationA"
-        assert len(root.children) == 2
-
-    def test_plr_nested_dict_has_children(self):
-        tree_set = _make_tree_with_children()
-        root = tree_set.trees[0].root_node
-        nested = root.get_plr_nested_dict()
-        assert isinstance(nested, dict)
-        assert "children" in nested
-        assert isinstance(nested["children"], dict)
-        assert "R1" in nested["children"]
-        assert "R2" in nested["children"]
-
-    def test_plr_nested_dict_preserves_uuid(self):
-        tree_set = _make_tree_with_children()
-        root = tree_set.trees[0].root_node
-        nested = root.get_plr_nested_dict()
-        assert nested["uuid"] == "uuid-station-a"
-        assert nested["children"]["R1"]["uuid"] == "uuid-r1"
-
-    def test_plr_nested_dict_preserves_klass(self):
-        tree_set = _make_tree_with_children()
-        root = tree_set.trees[0].root_node
-        nested = root.get_plr_nested_dict()
-        assert nested["class"] == "workstation"
-
-    def test_plr_nested_dict_preserves_data(self):
-        tree_set = _make_tree_with_children()
-        root = tree_set.trees[0].root_node
-        nested = root.get_plr_nested_dict()
-        r1_data = nested["children"]["R1"]["data"]
-        assert "liquid" in r1_data
-        assert r1_data["liquid"][0]["volume"] == 10.0
-
-    def test_plr_nested_dict_usable_by_get_vessel(self):
-        """get_plr_nested_dict 的结果可以直接传给 get_vessel"""
-        tree_set = _make_tree_with_children()
-        root = tree_set.trees[0].root_node
-        nested = root.get_plr_nested_dict()
-        vessel_id, vessel_data = get_vessel(nested)
-        assert vessel_id == "StationA"
-
-    def test_dump_vs_plr_nested_dict(self):
-        """dump() 是扁平化的，get_plr_nested_dict 保留树结构"""
-        tree_set = _make_tree_with_children()
-        # dump 返回扁平列表
-        dumped = tree_set.dump()
-        assert isinstance(dumped[0], list)
-        assert len(dumped[0]) == 3  # StationA + R1 + R2，全部扁平
-
-        # get_plr_nested_dict 保留嵌套
-        root = tree_set.trees[0].root_node
-        nested = root.get_plr_nested_dict()
-        assert isinstance(nested["children"], dict)
-        assert len(nested["children"]) == 2  # 嵌套的 children
-
-
-# ============ 模拟 workstation 路径测试 ============
-
-
-class TestWorkstationPath:
-    """模拟 workstation.py 中的关键路径:
-    raw_data → ResourceTreeSet.from_raw_dict_list → get_plr_nested_dict → compiler
-    """
-
-    def test_single_resource_path(self):
-        """单个 Resource: 取第一棵树的根节点"""
-        raw_data = [
-            _make_resource_dict(id="reactor_01", uuid="uuid-r01", klass="virtual_stirrer"),
-        ]
-        tree_set = ResourceTreeSet.from_raw_dict_list(raw_data)
-        root = tree_set.trees[0].root_node
-        result = root.get_plr_nested_dict()
-        assert result["id"] == "reactor_01"
-        assert result["uuid"] == "uuid-r01"
-        assert result["class"] == "virtual_stirrer"
-
-    def test_resource_with_children_path(self):
-        """Resource 带 children: AGV/batch transfer 场景"""
-        tree_set = _make_tree_with_children()
-        root = tree_set.trees[0].root_node
-        nested = root.get_plr_nested_dict()
-
-        # 模拟编译器接收到的参数
-        from_repo = {"StationA": nested}
-        assert "A01" not in from_repo["StationA"]["children"]  # children 按 id 索引
-        assert "R1" in from_repo["StationA"]["children"]
-        assert from_repo["StationA"]["children"]["R1"]["uuid"] == "uuid-r1"
-
-    def test_multiple_resource_path(self):
-        """多个 Resource: 每棵树取根节点"""
-        raw_data1 = [_make_resource_dict(id="R1", uuid="uuid-r1")]
-        raw_data2 = [_make_resource_dict(id="R2", uuid="uuid-r2")]
-        # 模拟 host 返回多棵树
-        tree_set1 = ResourceTreeSet.from_raw_dict_list(raw_data1)
-        tree_set2 = ResourceTreeSet.from_raw_dict_list(raw_data2)
-        results = [
-            tree.root_node.get_plr_nested_dict()
-            for ts in [tree_set1, tree_set2]
-            for tree in ts.trees
-        ]
-        assert len(results) == 2
-        assert results[0]["id"] == "R1"
-        assert results[1]["id"] == "R2"
--- a/tests/devices/test_agv_transport_station.py
+++ b/tests/devices/test_agv_transport_station.py
@@ -1,137 +0,0 @@
-"""
-AGVTransportStation driver 测试
-
-覆盖：初始化、carrier property、slot 查询、路由查询、capacity 计算。
-"""
-
-import pytest
-from unittest.mock import MagicMock, patch
-
-from unilabos.devices.transport.agv_workstation import AGVTransportStation
-from unilabos.resources.warehouse import WareHouse, warehouse_factory
-
-
-class TestAGVTransportStation:
-    def _make_driver(self, route_table=None, device_roles=None):
-        """创建一个 AGVTransportStation 实例"""
-        return AGVTransportStation(
-            deck=None,
-            route_table=route_table or {
-                "A->B": {"nav_command": '{"target":"LM1"}', "arm_pick": "pick.urp", "arm_place": "place.urp"}
-            },
-            device_roles=device_roles or {"navigator": "agv_nav", "arm": "agv_arm"},
-        )
-
-    def _make_warehouse(self, name="agv_platform", nx=2, ny=1, nz=1):
-        """创建一个测试用 Warehouse"""
-        return warehouse_factory(name=name, num_items_x=nx, num_items_y=ny, num_items_z=nz)
-
-    def test_init_deck_none(self):
-        """AGVTransportStation 初始化时 deck=None"""
-        driver = self._make_driver()
-        assert driver.deck is None
-
-    def test_init_route_table(self):
-        """路由表正确存储"""
-        driver = self._make_driver()
-        assert "A->B" in driver.route_table
-
-    def test_init_device_roles(self):
-        """设备角色正确存储"""
-        driver = self._make_driver()
-        assert driver.device_roles["navigator"] == "agv_nav"
-        assert driver.device_roles["arm"] == "agv_arm"
-
-    def test_carrier_without_ros_node(self):
-        """未 post_init 时 carrier 返回 None"""
-        driver = self._make_driver()
-        assert driver.carrier is None
-
-    def test_carrier_with_warehouse(self):
-        """post_init 后 carrier 返回正确的 WareHouse"""
-        driver = self._make_driver()
-        wh = self._make_warehouse()
-
-        # 模拟 ros_node 和 resource_tracker
-        mock_ros_node = MagicMock()
-        mock_ros_node.resource_tracker.resources = [wh]
-        mock_ros_node.device_id = "AGV"
-        driver.post_init(mock_ros_node)
-
-        assert driver.carrier is wh
-        assert isinstance(driver.carrier, WareHouse)
-
-    def test_capacity(self):
-        """容量计算正确"""
-        driver = self._make_driver()
-        wh = self._make_warehouse(nx=2, ny=1, nz=1)
-        mock_ros_node = MagicMock()
-        mock_ros_node.resource_tracker.resources = [wh]
-        mock_ros_node.device_id = "AGV"
-        driver.post_init(mock_ros_node)
-
-        assert driver.capacity == 2
-
-    def test_capacity_multi_layer(self):
-        """多层 Warehouse 容量"""
-        driver = self._make_driver()
-        wh = self._make_warehouse(nx=1, ny=2, nz=3)
-        mock_ros_node = MagicMock()
-        mock_ros_node.resource_tracker.resources = [wh]
-        mock_ros_node.device_id = "AGV"
-        driver.post_init(mock_ros_node)
-
-        assert driver.capacity == 6
-
-    def test_capacity_no_carrier(self):
-        """无 carrier 时容量为 0"""
-        driver = self._make_driver()
-        assert driver.capacity == 0
-
-    def test_free_slots(self):
-        """空载时所有 slot 为空闲"""
-        driver = self._make_driver()
-        wh = self._make_warehouse(nx=2, ny=1, nz=1)
-        mock_ros_node = MagicMock()
-        mock_ros_node.resource_tracker.resources = [wh]
-        mock_ros_node.device_id = "AGV"
-        driver.post_init(mock_ros_node)
-
-        free = driver.free_slots
-        assert len(free) == 2
-
-    def test_occupied_slots_empty(self):
-        """空载时 occupied_slots 为空"""
-        driver = self._make_driver()
-        wh = self._make_warehouse(nx=2, ny=1, nz=1)
-        mock_ros_node = MagicMock()
-        mock_ros_node.resource_tracker.resources = [wh]
-        mock_ros_node.device_id = "AGV"
-        driver.post_init(mock_ros_node)
-
-        assert len(driver.occupied_slots) == 0
-
-    def test_resolve_route(self):
-        """路由查询返回正确的指令"""
-        driver = self._make_driver()
-        route = driver.resolve_route("A", "B")
-        assert route["nav_command"] == '{"target":"LM1"}'
-        assert route["arm_pick"] == "pick.urp"
-
-    def test_resolve_route_not_found(self):
-        """查询不存在的路线时抛出 KeyError"""
-        driver = self._make_driver()
-        with pytest.raises(KeyError, match="路由表"):
-            driver.resolve_route("X", "Y")
-
-    def test_get_device_id(self):
-        """获取子设备 ID"""
-        driver = self._make_driver()
-        assert driver.get_device_id("navigator") == "agv_nav"
-        assert driver.get_device_id("arm") == "agv_arm"
-
-    def test_get_device_id_not_found(self):
-        """获取不存在的角色时抛出 KeyError"""
-        driver = self._make_driver()
-        with pytest.raises(KeyError, match="未配置设备角色"):
-            driver.get_device_id("gripper")
--- a/unilabos/init.py
+++ b/unilabos/init.py
@@ -1 +1 @@
-__version__ = "0.10.19"
+__version__ = "0.11.0"
--- a/unilabos/app/main.py
+++ b/unilabos/app/main.py
@@ -233,7 +233,7 @@ def parse_args():
    parser.add_argument(
        "--addr",
        type=str,
-        default="https://uni-lab.bohrium.com/api/v1",
+        default="https://leap-lab.bohrium.com/api/v1",
        help="Laboratory backend address",
    )
    parser.add_argument(
@@ -438,10 +438,10 @@ def main():
    if args.addr != parser.get_default("addr"):
        if args.addr == "test":
            print_status("使用测试环境地址", "info")
-            HTTPConfig.remote_addr = "https://uni-lab.test.bohrium.com/api/v1"
+            HTTPConfig.remote_addr = "https://leap-lab.test.bohrium.com/api/v1"
        elif args.addr == "uat":
            print_status("使用uat环境地址", "info")
-            HTTPConfig.remote_addr = "https://uni-lab.uat.bohrium.com/api/v1"
+            HTTPConfig.remote_addr = "https://leap-lab.uat.bohrium.com/api/v1"
        elif args.addr == "local":
            print_status("使用本地环境地址", "info")
            HTTPConfig.remote_addr = "http://127.0.0.1:48197/api/v1"
@@ -553,13 +553,8 @@ def main():
        os._exit(0)

    if not BasicConfig.ak or not BasicConfig.sk:
-        if BasicConfig.test_mode:
-            print_status("测试模式：跳过 ak/sk 检查，使用占位凭据", "warning")
-            BasicConfig.ak = BasicConfig.ak or "test_ak"
-            BasicConfig.sk = BasicConfig.sk or "test_sk"
-        else:
-            print_status("后续运行必须拥有一个实验室，请前往 https://uni-lab.bohrium.com 注册实验室！", "warning")
-            os._exit(1)
+        print_status("后续运行必须拥有一个实验室，请前往 https://leap-lab.bohrium.com 注册实验室！", "warning")
+        os._exit(1)
    graph: nx.Graph
    resource_tree_set: ResourceTreeSet
    resource_links: List[Dict[str, Any]]
--- a/unilabos/app/web/client.py
+++ b/unilabos/app/web/client.py
@@ -36,6 +36,9 @@ class HTTPClient:
            auth_secret = BasicConfig.auth_secret()
            self.auth = auth_secret
            info(f"正在使用ak sk作为授权信息：[{auth_secret}]")
+        # 复用 TCP/TLS 连接，避免每次请求重新握手
+        self._session = requests.Session()
+        self._session.headers.update({"Authorization": f"Lab {self.auth}"})
        info(f"HTTPClient 初始化完成: remote_addr={self.remote_addr}")

    def resource_edge_add(self, resources: List[Dict[str, Any]]) -> requests.Response:
@@ -48,7 +51,7 @@ class HTTPClient:
        Returns:
            Response: API响应对象
        """
-        response = requests.post(
+        response = self._session.post(
            f"{self.remote_addr}/edge/material/edge",
            json={
                "edges": resources,
@@ -75,25 +78,28 @@ class HTTPClient:
        Returns:
            Dict[str, str]: 旧UUID到新UUID的映射关系 {old_uuid: new_uuid}
        """
-        with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_add.json"), "w", encoding="utf-8") as f:
-            payload = {"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid}
-            f.write(json.dumps(payload, indent=4))
-        # 从序列化数据中提取所有节点的UUID（保存旧UUID）
+        # dump() 只调用一次，复用给文件保存和 HTTP 请求
+        nodes_info = [x for xs in resources.dump() for x in xs]
        old_uuids = {n.res_content.uuid: n for n in resources.all_nodes}
+        payload = {"nodes": nodes_info, "mount_uuid": mount_uuid}
+        body_bytes = _fast_dumps(payload)
+        with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_add.json"), "wb") as f:
+            f.write(_fast_dumps_pretty(payload))
+        http_headers = {"Content-Type": "application/json"}
        if not self.initialized or first_add:
            self.initialized = True
            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = requests.post(
+            response = self._session.post(
                f"{self.remote_addr}/edge/material",
-                json={"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid},
-                headers={"Authorization": f"Lab {self.auth}"},
+                data=body_bytes,
+                headers=http_headers,
                timeout=60,
            )
        else:
-            response = requests.put(
+            response = self._session.put(
                f"{self.remote_addr}/edge/material",
-                json={"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid},
-                headers={"Authorization": f"Lab {self.auth}"},
+                data=body_bytes,
+                headers=http_headers,
                timeout=10,
            )

@@ -111,6 +117,7 @@ class HTTPClient:
                    uuid_mapping[i["uuid"]] = i["cloud_uuid"]
        else:
            logger.error(f"添加物料失败: {response.text}")
+            logger.trace(f"添加物料失败: {nodes_info}")
        for u, n in old_uuids.items():
            if u in uuid_mapping:
                n.res_content.uuid = uuid_mapping[u]
@@ -131,7 +138,7 @@ class HTTPClient:
        """
        with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_get.json"), "w", encoding="utf-8") as f:
            f.write(json.dumps({"uuids": uuid_list, "with_children": with_children}, indent=4))
-        response = requests.post(
+        response = self._session.post(
            f"{self.remote_addr}/edge/material/query",
            json={"uuids": uuid_list, "with_children": with_children},
            headers={"Authorization": f"Lab {self.auth}"},
@@ -145,6 +152,7 @@ class HTTPClient:
                logger.error(f"查询物料失败: {response.text}")
            else:
                data = res["data"]["nodes"]
+                logger.trace(f"resource_tree_get查询到物料: {data}")
                return data
        else:
            logger.error(f"查询物料失败: {response.text}")
@@ -162,14 +170,14 @@ class HTTPClient:
        if not self.initialized:
            self.initialized = True
            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = requests.post(
+            response = self._session.post(
                f"{self.remote_addr}/lab/material",
                json={"nodes": resources},
                headers={"Authorization": f"Lab {self.auth}"},
                timeout=100,
            )
        else:
-            response = requests.put(
+            response = self._session.put(
                f"{self.remote_addr}/lab/material",
                json={"nodes": resources},
                headers={"Authorization": f"Lab {self.auth}"},
@@ -196,7 +204,7 @@ class HTTPClient:
        """
        with open(os.path.join(BasicConfig.working_dir, "req_resource_get.json"), "w", encoding="utf-8") as f:
            f.write(json.dumps({"id": id, "with_children": with_children}, indent=4))
-        response = requests.get(
+        response = self._session.get(
            f"{self.remote_addr}/lab/material",
            params={"id": id, "with_children": with_children},
            headers={"Authorization": f"Lab {self.auth}"},
@@ -237,14 +245,14 @@ class HTTPClient:
        if not self.initialized:
            self.initialized = True
            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = requests.post(
+            response = self._session.post(
                f"{self.remote_addr}/lab/material",
                json={"nodes": resources},
                headers={"Authorization": f"Lab {self.auth}"},
                timeout=100,
            )
        else:
-            response = requests.put(
+            response = self._session.put(
                f"{self.remote_addr}/lab/material",
                json={"nodes": resources},
                headers={"Authorization": f"Lab {self.auth}"},
@@ -274,7 +282,7 @@ class HTTPClient:
        with open(file_path, "rb") as file:
            files = {"files": file}
            logger.info(f"上传文件: {file_path} 到 {scene}")
-            response = requests.post(
+            response = self._session.post(
                f"{self.remote_addr}/api/account/file_upload/{scene}",
                files=files,
                headers={"Authorization": f"Lab {self.auth}"},
@@ -314,7 +322,7 @@ class HTTPClient:
            "Content-Type": "application/json",
            "Content-Encoding": "gzip",
        }
-        response = requests.post(
+        response = self._session.post(
            f"{self.remote_addr}/lab/resource",
            data=compressed_body,
            headers=headers,
@@ -348,7 +356,7 @@ class HTTPClient:
        Returns:
            Response: API响应对象
        """
-        response = requests.get(
+        response = self._session.get(
            f"{self.remote_addr}/edge/material/download",
            headers={"Authorization": f"Lab {self.auth}"},
            timeout=(3, 30),
@@ -409,7 +417,7 @@ class HTTPClient:
        with open(os.path.join(BasicConfig.working_dir, "req_workflow_upload.json"), "w", encoding="utf-8") as f:
            f.write(json.dumps(payload, indent=4, ensure_ascii=False))

-        response = requests.post(
+        response = self._session.post(
            f"{self.remote_addr}/lab/workflow/owner/import",
            json=payload,
            headers={"Authorization": f"Lab {self.auth}"},
--- a/unilabos/app/ws_client.py
+++ b/unilabos/app/ws_client.py
@@ -1113,7 +1113,7 @@ class MessageProcessor:
                "task_id": task_id,
                "job_id": job_id,
                "free": free,
-                "need_more": need_more,
+                "need_more": need_more + 1,
            },
        }

@@ -1253,7 +1253,7 @@ class QueueProcessor:
                    "task_id": job_info.task_id,
                    "job_id": job_info.job_id,
                    "free": False,
-                    "need_more": 10,
+                    "need_more": 10 + 1,
                },
            }
            self.message_processor.send_message(message)
@@ -1269,7 +1269,13 @@ class QueueProcessor:
        if not queued_jobs:
            return

-        logger.debug(f"[QueueProcessor] Sending busy status for {len(queued_jobs)} queued jobs")
+        queue_summary = {}
+        for j in queued_jobs:
+            key = f"{j.device_id}/{j.action_name}"
+            queue_summary[key] = queue_summary.get(key, 0) + 1
+        logger.debug(
+            f"[QueueProcessor] Sending busy status for {len(queued_jobs)} queued jobs: {queue_summary}"
+        )

        for job_info in queued_jobs:
            # 快照可能已过期：在遍历过程中 end_job() 可能已将此 job 移至 READY，
@@ -1286,7 +1292,7 @@ class QueueProcessor:
                    "task_id": job_info.task_id,
                    "job_id": job_info.job_id,
                    "free": False,
-                    "need_more": 10,
+                    "need_more": 10 + 1,
                },
            }
            success = self.message_processor.send_message(message)
@@ -1369,6 +1375,10 @@ class WebSocketClient(BaseCommunicationClient):
        self.message_processor = MessageProcessor(self.websocket_url, self.send_queue, self.device_manager)
        self.queue_processor = QueueProcessor(self.device_manager, self.message_processor)

+        # running状态debounce缓存: {job_id: (last_send_timestamp, last_feedback_data)}
+        self._job_running_last_sent: Dict[str, tuple] = {}
+        self._job_running_debounce_interval: float = 10.0  # 秒
+
        # 设置相互引用
        self.message_processor.set_queue_processor(self.queue_processor)
        self.message_processor.set_websocket_client(self)
@@ -1468,22 +1478,32 @@ class WebSocketClient(BaseCommunicationClient):
            logger.debug(f"[WebSocketClient] Not connected, cannot publish job status for job_id: {item.job_id}")
            return

+        job_log = format_job_log(item.job_id, item.task_id, item.device_id, item.action_name)
+
        # 拦截最终结果状态，与原版本逻辑一致
        if status in ["success", "failed"]:
+            self._job_running_last_sent.pop(item.job_id, None)
+
            host_node = HostNode.get_instance(0)
            if host_node:
-                # 从HostNode的device_action_status中移除job_id
                try:
                    host_node._device_action_status[item.device_action_key].job_ids.pop(item.job_id, None)
                except (KeyError, AttributeError):
                    logger.warning(f"[WebSocketClient] Failed to remove job {item.job_id} from HostNode status")

-            # logger.debug(f"[WebSocketClient] Intercepting final status for job_id: {item.job_id} - {status}")
-
-            # 通知队列处理器job完成（包括timeout的job）
            self.queue_processor.handle_job_completed(item.job_id, status)

-        # 发送job状态消息
+        # running状态按job_id做debounce，内容变化时仍然上报
+        if status == "running":
+            now = time.time()
+            cached = self._job_running_last_sent.get(item.job_id)
+            if cached is not None:
+                last_ts, last_data = cached
+                if now - last_ts < self._job_running_debounce_interval and last_data == feedback_data:
+                    logger.trace(f"[WebSocketClient] Job status debounced (skip): {job_log} - {status}")
+                    return
+            self._job_running_last_sent[item.job_id] = (now, feedback_data)
+
        message = {
            "action": "job_status",
            "data": {
@@ -1499,7 +1519,6 @@ class WebSocketClient(BaseCommunicationClient):
        }
        self.message_processor.send_message(message)

-        job_log = format_job_log(item.job_id, item.task_id, item.device_id, item.action_name)
        logger.trace(f"[WebSocketClient] Job status published: {job_log} - {status}")

    def send_ping(self, ping_id: str, timestamp: float) -> None:
--- a/unilabos/compile/init.py
+++ b/unilabos/compile/init.py
@@ -5,7 +5,6 @@ from .separate_protocol import generate_separate_protocol
 from .evaporate_protocol import generate_evaporate_protocol
 from .evacuateandrefill_protocol import generate_evacuateandrefill_protocol
 from .agv_transfer_protocol import generate_agv_transfer_protocol
-from .batch_transfer_protocol import generate_batch_transfer_protocol
 from .add_protocol import generate_add_protocol
 from .centrifuge_protocol import generate_centrifuge_protocol
 from .filter_protocol import generate_filter_protocol
@@ -32,7 +31,6 @@ from .hydrogenate_protocol import generate_hydrogenate_protocol
 action_protocol_generators = {
    AddProtocol: generate_add_protocol,
    AGVTransferProtocol: generate_agv_transfer_protocol,
-    BatchTransferProtocol: generate_batch_transfer_protocol,
    AdjustPHProtocol: generate_adjust_ph_protocol,
    CentrifugeProtocol: generate_centrifuge_protocol,
    CleanProtocol: generate_clean_protocol,
--- a/unilabos/compile/_agv_utils.py
+++ b/unilabos/compile/_agv_utils.py
@@ -1,127 +0,0 @@
-"""
-AGV 编译器共用工具函数
-
-从 physical_setup_graph 中发现 AGV 节点配置，
-供 agv_transfer_protocol 和 batch_transfer_protocol 复用。
-"""
-
-from typing import Any, Dict, List, Optional
-
-import networkx as nx
-
-
-def find_agv_config(G: nx.Graph, agv_id: Optional[str] = None) -> Dict[str, Any]:
-    """从设备图中发现 AGV 节点，返回其配置
-
-    查找策略：
-    1. 如果指定 agv_id，直接读取该节点
-    2. 否则查找 class 为 "agv_transport_station" 的节点
-    3. 兜底查找 config 中包含 device_roles 的 workstation 节点
-
-    Returns:
-        {
-            "agv_id": str,
-            "device_roles": {"navigator": "...", "arm": "..."},
-            "route_table": {"A->B": {"nav_command": ..., "arm_pick": ..., "arm_place": ...}},
-            "capacity": int,
-        }
-    """
-    if agv_id and agv_id in G.nodes:
-        node_data = G.nodes[agv_id]
-        config = _extract_config(node_data)
-        if config and "device_roles" in config:
-            return _build_agv_cfg(agv_id, config, G)
-
-    # 查找 agv_transport_station 类型
-    for nid, ndata in G.nodes(data=True):
-        node_class = _get_node_class(ndata)
-        if node_class == "agv_transport_station":
-            config = _extract_config(ndata)
-            return _build_agv_cfg(nid, config or {}, G)
-
-    # 兜底：查找带有 device_roles 的 workstation
-    for nid, ndata in G.nodes(data=True):
-        node_class = _get_node_class(ndata)
-        if node_class == "workstation":
-            config = _extract_config(ndata)
-            if config and "device_roles" in config:
-                return _build_agv_cfg(nid, config, G)
-
-    raise ValueError("设备图中未找到 AGV 节点（需 class=agv_transport_station 或 config.device_roles）")
-
-
-def get_agv_capacity(G: nx.Graph, agv_id: str) -> int:
-    """从 AGV 的 Warehouse 子节点计算载具容量"""
-    for neighbor in G.successors(agv_id) if G.is_directed() else G.neighbors(agv_id):
-        ndata = G.nodes[neighbor]
-        node_type = _get_node_type(ndata)
-        if node_type == "warehouse":
-            config = _extract_config(ndata)
-            if config:
-                x = config.get("num_items_x", 1)
-                y = config.get("num_items_y", 1)
-                z = config.get("num_items_z", 1)
-                return x * y * z
-    # 如果没有 warehouse 子节点，尝试从配置中读取
-    return 0
-
-
-def split_batches(items: list, capacity: int) -> List[list]:
-    """按 AGV 容量分批
-
-    Args:
-        items: 待转运的物料列表
-        capacity: AGV 单批次容量
-
-    Returns:
-        分批后的列表的列表
-    """
-    if capacity <= 0:
-        raise ValueError(f"AGV 容量必须 > 0，当前: {capacity}")
-    return [items[i:i + capacity] for i in range(0, len(items), capacity)]
-
-
-def _extract_config(node_data: dict) -> Optional[dict]:
-    """从节点数据中提取 config 字段，兼容多种格式"""
-    # 直接 config 字段
-    config = node_data.get("config")
-    if isinstance(config, dict):
-        return config
-    # res_content 嵌套格式
-    res_content = node_data.get("res_content")
-    if hasattr(res_content, "config"):
-        return res_content.config if isinstance(res_content.config, dict) else None
-    if isinstance(res_content, dict):
-        return res_content.get("config")
-    return None
-
-
-def _get_node_class(node_data: dict) -> str:
-    """获取节点的 class 字段"""
-    res_content = node_data.get("res_content")
-    if hasattr(res_content, "model_dump"):
-        d = res_content.model_dump()
-        return d.get("class_", d.get("class", ""))
-    if isinstance(res_content, dict):
-        return res_content.get("class_", res_content.get("class", ""))
-    return node_data.get("class_", node_data.get("class", ""))
-
-
-def _get_node_type(node_data: dict) -> str:
-    """获取节点的 type 字段"""
-    res_content = node_data.get("res_content")
-    if hasattr(res_content, "type"):
-        return res_content.type or ""
-    if isinstance(res_content, dict):
-        return res_content.get("type", "")
-    return node_data.get("type", "")
-
-
-def _build_agv_cfg(agv_id: str, config: dict, G: nx.Graph) -> Dict[str, Any]:
-    """构建标准化的 AGV 配置"""
-    return {
-        "agv_id": agv_id,
-        "device_roles": config.get("device_roles", {}),
-        "route_table": config.get("route_table", {}),
-        "capacity": get_agv_capacity(G, agv_id),
-    }
--- a/unilabos/compile/add_protocol.py
+++ b/unilabos/compile/add_protocol.py
@@ -2,13 +2,20 @@ from functools import partial

 import networkx as nx
 import re
+import logging
 from typing import List, Dict, Any, Union

 from .utils.unit_parser import parse_volume_input, parse_mass_input, parse_time_input
 from .utils.vessel_parser import get_vessel, find_solid_dispenser, find_connected_stirrer, find_reagent_vessel
-from .utils.logger_util import action_log, debug_print
+from .utils.logger_util import action_log
 from .pump_protocol import generate_pump_protocol_with_rinsing

+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[ADD] {message}")
+

 # 🆕 创建进度日志动作
 create_action_log = partial(action_log, prefix="[ADD]")
--- a/unilabos/compile/adjustph_protocol.py
+++ b/unilabos/compile/adjustph_protocol.py
@@ -1,12 +1,14 @@
-from functools import partial
-
 import networkx as nx
+import logging
 from typing import List, Dict, Any, Union
-from .utils.vessel_parser import get_vessel, find_connected_stirrer
-from .utils.logger_util import action_log, debug_print
+from .utils.vessel_parser import get_vessel
 from .pump_protocol import generate_pump_protocol_with_rinsing

-create_action_log = partial(action_log, prefix="[ADJUST_PH]")
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[ADJUST_PH] {message}")

 def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
    """
@@ -19,6 +21,8 @@ def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
    Returns:
        str: 试剂容器ID
    """
+    debug_print(f"🔍 正在查找试剂 '{reagent}' 的容器...")
+    
    # 常见酸碱试剂的别名映射
    reagent_aliases = {
        "hydrochloric acid": ["HCl", "hydrochloric_acid", "hcl", "muriatic_acid"],
@@ -32,13 +36,17 @@ def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
    
    # 构建搜索名称列表
    search_names = [reagent.lower()]
-
+    debug_print(f"📋 基础搜索名称: {reagent.lower()}")
+    
    # 添加别名
    for base_name, aliases in reagent_aliases.items():
        if reagent.lower() in base_name.lower() or base_name.lower() in reagent.lower():
            search_names.extend([alias.lower() for alias in aliases])
+            debug_print(f"🔗 添加别名: {aliases}")
            break
    
+    debug_print(f"📝 完整搜索列表: {search_names}")
+    
    # 构建可能的容器名称
    possible_names = []
    for name in search_names:
@@ -53,15 +61,17 @@ def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
            name_clean
        ])
    
-    debug_print(f"搜索容器: {len(possible_names)} 个候选名称")
-
+    debug_print(f"🎯 可能的容器名称 (前5个): {possible_names[:5]}... (共{len(possible_names)}个)")
+    
    # 第一步：通过容器名称匹配
+    debug_print(f"📋 方法1: 精确名称匹配...")
    for vessel_name in possible_names:
        if vessel_name in G.nodes():
-            debug_print(f"通过名称匹配找到容器: {vessel_name}")
+            debug_print(f"✅ 通过名称匹配找到容器: {vessel_name} 🎯")
            return vessel_name
-
+    
    # 第二步：通过模糊匹配
+    debug_print(f"📋 方法2: 模糊名称匹配...")
    for node_id in G.nodes():
        if G.nodes[node_id].get('type') == 'container':
            node_name = G.nodes[node_id].get('name', '').lower()
@@ -69,10 +79,11 @@ def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
            # 检查是否包含任何搜索名称
            for search_name in search_names:
                if search_name in node_id.lower() or search_name in node_name:
-                    debug_print(f"通过模糊匹配找到容器: {node_id}")
+                    debug_print(f"✅ 通过模糊匹配找到容器: {node_id} 🔍")
                    return node_id
-
+    
    # 第三步：通过液体类型匹配
+    debug_print(f"📋 方法3: 液体类型匹配...")
    for node_id in G.nodes():
        if G.nodes[node_id].get('type') == 'container':
            vessel_data = G.nodes[node_id].get('data', {})
@@ -85,15 +96,56 @@ def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
                    
                    for search_name in search_names:
                        if search_name in liquid_type or search_name in reagent_name:
-                            debug_print(f"通过液体类型匹配找到容器: {node_id}")
+                            debug_print(f"✅ 通过液体类型匹配找到容器: {node_id} 💧")
                            return node_id
    
    # 列出可用容器帮助调试
-    available_containers = [node_id for node_id in G.nodes()
-                           if G.nodes[node_id].get('type') == 'container']
-    debug_print(f"所有匹配方法失败，可用容器: {available_containers}")
+    debug_print(f"📊 列出可用容器帮助调试...")
+    available_containers = []
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            vessel_data = G.nodes[node_id].get('data', {})
+            liquids = vessel_data.get('liquid', [])
+            liquid_types = [liquid.get('liquid_type', '') or liquid.get('name', '') 
+                           for liquid in liquids if isinstance(liquid, dict)]
+            
+            available_containers.append({
+                'id': node_id,
+                'name': G.nodes[node_id].get('name', ''),
+                'liquids': liquid_types,
+                'reagent_name': vessel_data.get('reagent_name', '')
+            })
+    
+    debug_print(f"📋 可用容器列表:")
+    for container in available_containers:
+        debug_print(f"  - 🧪 {container['id']}: {container['name']}")
+        debug_print(f"    💧 液体: {container['liquids']}")
+        debug_print(f"    🏷️ 试剂: {container['reagent_name']}")
+    
+    debug_print(f"❌ 所有匹配方法都失败了")
    raise ValueError(f"找不到试剂 '{reagent}' 对应的容器。尝试了: {possible_names[:10]}...")

+def find_connected_stirrer(G: nx.DiGraph, vessel: str) -> str:
+    """查找与容器相连的搅拌器"""
+    debug_print(f"🔍 查找连接到容器 '{vessel}' 的搅拌器...")
+    
+    stirrer_nodes = [node for node in G.nodes() 
+                    if (G.nodes[node].get('class') or '') == 'virtual_stirrer']
+    
+    debug_print(f"📊 发现 {len(stirrer_nodes)} 个搅拌器: {stirrer_nodes}")
+    
+    for stirrer in stirrer_nodes:
+        if G.has_edge(stirrer, vessel) or G.has_edge(vessel, stirrer):
+            debug_print(f"✅ 找到连接的搅拌器: {stirrer} 🔗")
+            return stirrer
+    
+    if stirrer_nodes:
+        debug_print(f"⚠️ 未找到直接连接的搅拌器，使用第一个: {stirrer_nodes[0]} 🔄")
+        return stirrer_nodes[0]
+    
+    debug_print(f"❌ 未找到任何搅拌器")
+    return None
+
 def calculate_reagent_volume(target_ph_value: float, reagent: str, vessel_volume: float = 100.0) -> float:
    """
    估算需要的试剂体积来调节pH
@@ -106,30 +158,44 @@ def calculate_reagent_volume(target_ph_value: float, reagent: str, vessel_volume
    Returns:
        float: 估算的试剂体积 (mL)
    """
-    debug_print(f"计算试剂体积: pH={target_ph_value}, reagent={reagent}, vessel={vessel_volume}mL")
-
-    # 简化的pH调节体积估算
+    debug_print(f"🧮 计算试剂体积...")
+    debug_print(f"  📍 目标pH: {target_ph_value}")
+    debug_print(f"  🧪 试剂: {reagent}")
+    debug_print(f"  📏 容器体积: {vessel_volume}mL")
+    
+    # 简化的pH调节体积估算（实际应用中需要更精确的计算）
    if "acid" in reagent.lower() or "hcl" in reagent.lower():
+        debug_print(f"🍋 检测到酸性试剂")
+        # 酸性试剂：pH越低需要的体积越大
        if target_ph_value < 3:
-            volume = vessel_volume * 0.05
+            volume = vessel_volume * 0.05  # 5%
+            debug_print(f"  💪 强酸性 (pH<3): 使用 5% 体积")
        elif target_ph_value < 5:
-            volume = vessel_volume * 0.02
+            volume = vessel_volume * 0.02  # 2%
+            debug_print(f"  🔸 中酸性 (pH<5): 使用 2% 体积")
        else:
-            volume = vessel_volume * 0.01
-
+            volume = vessel_volume * 0.01  # 1%
+            debug_print(f"  🔹 弱酸性 (pH≥5): 使用 1% 体积")
+    
    elif "hydroxide" in reagent.lower() or "naoh" in reagent.lower():
+        debug_print(f"🧂 检测到碱性试剂")
+        # 碱性试剂：pH越高需要的体积越大
        if target_ph_value > 11:
-            volume = vessel_volume * 0.05
+            volume = vessel_volume * 0.05  # 5%
+            debug_print(f"  💪 强碱性 (pH>11): 使用 5% 体积")
        elif target_ph_value > 9:
-            volume = vessel_volume * 0.02
+            volume = vessel_volume * 0.02  # 2%
+            debug_print(f"  🔸 中碱性 (pH>9): 使用 2% 体积")
        else:
-            volume = vessel_volume * 0.01
-
+            volume = vessel_volume * 0.01  # 1%
+            debug_print(f"  🔹 弱碱性 (pH≤9): 使用 1% 体积")
+    
    else:
        # 未知试剂，使用默认值
        volume = vessel_volume * 0.01
-
-    debug_print(f"估算试剂体积: {volume:.2f}mL")
+        debug_print(f"❓ 未知试剂类型，使用默认 1% 体积")
+    
+    debug_print(f"📊 计算结果: {volume:.2f}mL")
    return volume

 def generate_adjust_ph_protocol(
@@ -154,67 +220,96 @@ def generate_adjust_ph_protocol(
    """
    
    vessel_id, vessel_data = get_vessel(vessel)
-
+    
    if not vessel_id:
+        debug_print(f"❌ vessel 参数无效，必须包含id字段或直接提供容器ID. vessel: {vessel}")
        raise ValueError("vessel 参数无效，必须包含id字段或直接提供容器ID")
-
-    debug_print(f"pH调节协议: vessel={vessel_id}, ph={ph_value}, reagent='{reagent}'")
-
+    
+    debug_print("=" * 60)
+    debug_print("🧪 开始生成pH调节协议")
+    debug_print(f"📋 原始参数:")
+    debug_print(f"  🥼 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  📊 ph_value: {ph_value}")
+    debug_print(f"  🧪 reagent: '{reagent}'")
+    debug_print(f"  📦 kwargs: {kwargs}")
+    debug_print("=" * 60)
+    
    action_sequence = []
-
-    # 从kwargs中获取可选参数
-    volume = kwargs.get('volume', 0.0)
-    stir = kwargs.get('stir', True)
-    stir_speed = kwargs.get('stir_speed', 300.0)
-    stir_time = kwargs.get('stir_time', 60.0)
-    settling_time = kwargs.get('settling_time', 30.0)
-
+    
+    # 从kwargs中获取可选参数，如果没有则使用默认值
+    volume = kwargs.get('volume', 0.0)           # 自动估算体积
+    stir = kwargs.get('stir', True)              # 默认搅拌
+    stir_speed = kwargs.get('stir_speed', 300.0) # 默认搅拌速度
+    stir_time = kwargs.get('stir_time', 60.0)    # 默认搅拌时间
+    settling_time = kwargs.get('settling_time', 30.0)  # 默认平衡时间
+    
+    debug_print(f"🔧 处理后的参数:")
+    debug_print(f"  📏 volume: {volume}mL (0.0表示自动估算)")
+    debug_print(f"  🌪️ stir: {stir}")
+    debug_print(f"  🔄 stir_speed: {stir_speed}rpm")
+    debug_print(f"  ⏱️ stir_time: {stir_time}s")
+    debug_print(f"  ⏳ settling_time: {settling_time}s")
+    
    # 开始处理
    action_sequence.append(create_action_log(f"开始调节pH至 {ph_value}", "🧪"))
    action_sequence.append(create_action_log(f"目标容器: {vessel_id}", "🥼"))
    action_sequence.append(create_action_log(f"使用试剂: {reagent}", "⚗️"))
-
+    
    # 1. 验证目标容器存在
+    debug_print(f"🔍 步骤1: 验证目标容器...")
    if vessel_id not in G.nodes():
+        debug_print(f"❌ 目标容器 '{vessel_id}' 不存在于系统中")
        raise ValueError(f"目标容器 '{vessel_id}' 不存在于系统中")
-
+    
+    debug_print(f"✅ 目标容器验证通过")
    action_sequence.append(create_action_log("目标容器验证通过", "✅"))
-
+    
    # 2. 查找酸碱试剂容器
+    debug_print(f"🔍 步骤2: 查找试剂容器...")
    action_sequence.append(create_action_log("正在查找试剂容器...", "🔍"))
    
    try:
        reagent_vessel = find_acid_base_vessel(G, reagent)
+        debug_print(f"✅ 找到试剂容器: {reagent_vessel}")
        action_sequence.append(create_action_log(f"找到试剂容器: {reagent_vessel}", "🧪"))
    except ValueError as e:
+        debug_print(f"❌ 无法找到试剂容器: {str(e)}")
        action_sequence.append(create_action_log(f"试剂容器查找失败: {str(e)}", "❌"))
        raise ValueError(f"无法找到试剂 '{reagent}': {str(e)}")
-
+    
    # 3. 体积估算
+    debug_print(f"🔍 步骤3: 体积处理...")
    if volume <= 0:
        action_sequence.append(create_action_log("开始自动估算试剂体积", "🧮"))
        
        # 获取目标容器的体积信息
        vessel_data = G.nodes[vessel_id].get('data', {})
-        vessel_volume = vessel_data.get('max_volume', 100.0)
-
+        vessel_volume = vessel_data.get('max_volume', 100.0)  # 默认100mL
+        debug_print(f"📏 容器最大体积: {vessel_volume}mL")
+        
        estimated_volume = calculate_reagent_volume(ph_value, reagent, vessel_volume)
        volume = estimated_volume
+        debug_print(f"✅ 自动估算试剂体积: {volume:.2f} mL")
        action_sequence.append(create_action_log(f"估算试剂体积: {volume:.2f}mL", "📊"))
    else:
+        debug_print(f"📏 使用指定体积: {volume}mL")
        action_sequence.append(create_action_log(f"使用指定体积: {volume}mL", "📏"))
-
+    
    # 4. 验证路径存在
+    debug_print(f"🔍 步骤4: 路径验证...")
    action_sequence.append(create_action_log("验证转移路径...", "🛤️"))
    
    try:
        path = nx.shortest_path(G, source=reagent_vessel, target=vessel_id)
-        action_sequence.append(create_action_log(f"找到转移路径: {' -> '.join(path)}", "🛤️"))
+        debug_print(f"✅ 找到路径: {' → '.join(path)}")
+        action_sequence.append(create_action_log(f"找到转移路径: {' → '.join(path)}", "🛤️"))
    except nx.NetworkXNoPath:
+        debug_print(f"❌ 无法找到转移路径")
        action_sequence.append(create_action_log("转移路径不存在", "❌"))
        raise ValueError(f"从试剂容器 '{reagent_vessel}' 到目标容器 '{vessel_id}' 没有可用路径")
-
+    
    # 5. 搅拌器设置
+    debug_print(f"🔍 步骤5: 搅拌器设置...")
    stirrer_id = None
    if stir:
        action_sequence.append(create_action_log("准备启动搅拌器", "🌪️"))
@@ -223,6 +318,7 @@ def generate_adjust_ph_protocol(
            stirrer_id = find_connected_stirrer(G, vessel_id)
            
            if stirrer_id:
+                debug_print(f"✅ 找到搅拌器 {stirrer_id}，启动搅拌")
                action_sequence.append(create_action_log(f"启动搅拌器 {stirrer_id} (速度: {stir_speed}rpm)", "🔄"))
                
                action_sequence.append({
@@ -242,18 +338,23 @@ def generate_adjust_ph_protocol(
                    "action_kwargs": {"time": 5}
                })
            else:
+                debug_print(f"⚠️ 未找到搅拌器，继续执行")
                action_sequence.append(create_action_log("未找到搅拌器，跳过搅拌", "⚠️"))
-
+        
        except Exception as e:
+            debug_print(f"❌ 搅拌器配置出错: {str(e)}")
            action_sequence.append(create_action_log(f"搅拌器配置失败: {str(e)}", "❌"))
    else:
+        debug_print(f"📋 跳过搅拌设置")
        action_sequence.append(create_action_log("跳过搅拌设置", "⏭️"))
-
+    
    # 6. 试剂添加
+    debug_print(f"🔍 步骤6: 试剂添加...")
    action_sequence.append(create_action_log(f"开始添加试剂 {volume:.2f}mL", "🚰"))
    
    # 计算添加时间（pH调节需要缓慢添加）
-    addition_time = max(30.0, volume * 2.0)
+    addition_time = max(30.0, volume * 2.0)  # 至少30秒，每mL需要2秒
+    debug_print(f"⏱️ 计算添加时间: {addition_time}s (缓慢注入)")
    action_sequence.append(create_action_log(f"设置添加时间: {addition_time:.0f}s (缓慢注入)", "⏱️"))
    
    try:
@@ -276,28 +377,35 @@ def generate_adjust_ph_protocol(
        )
        
        action_sequence.extend(pump_actions)
+        debug_print(f"✅ 泵协议生成完成，添加了 {len(pump_actions)} 个动作")
        action_sequence.append(create_action_log(f"试剂转移完成 ({len(pump_actions)} 个操作)", "✅"))
-
-        # 体积运算 - 试剂添加成功后更新容器液体体积
+        
+        # 🔧 修复体积运算 - 试剂添加成功后更新容器液体体积
+        debug_print(f"🔧 更新容器液体体积...")
        if "data" in vessel and "liquid_volume" in vessel["data"]:
            current_volume = vessel["data"]["liquid_volume"]
-
+            debug_print(f"📊 添加前容器体积: {current_volume}")
+            
            # 处理不同的体积数据格式
            if isinstance(current_volume, list):
                if len(current_volume) > 0:
                    # 增加体积（添加试剂）
                    vessel["data"]["liquid_volume"][0] += volume
+                    debug_print(f"📊 添加后容器体积: {vessel['data']['liquid_volume'][0]:.2f}mL (+{volume:.2f}mL)")
                else:
                    # 如果列表为空，创建新的体积记录
                    vessel["data"]["liquid_volume"] = [volume]
+                    debug_print(f"📊 初始化容器体积: {volume:.2f}mL")
            elif isinstance(current_volume, (int, float)):
                # 直接数值类型
                vessel["data"]["liquid_volume"] += volume
+                debug_print(f"📊 添加后容器体积: {vessel['data']['liquid_volume']:.2f}mL (+{volume:.2f}mL)")
            else:
-                debug_print(f"未知的体积数据格式: {type(current_volume)}")
+                debug_print(f"⚠️ 未知的体积数据格式: {type(current_volume)}")
                # 创建新的体积记录
                vessel["data"]["liquid_volume"] = volume
        else:
+            debug_print(f"📊 容器无液体体积数据，创建新记录: {volume:.2f}mL")
            # 确保vessel有data字段
            if "data" not in vessel:
                vessel["data"] = {}
@@ -315,16 +423,19 @@ def generate_adjust_ph_protocol(
                    G.nodes[vessel_id]['data']['liquid_volume'] = [volume]
            else:
                G.nodes[vessel_id]['data']['liquid_volume'] = current_node_volume + volume
-
+                
+            debug_print(f"✅ 图节点体积数据已更新")
+        
        action_sequence.append(create_action_log(f"容器体积已更新 (+{volume:.2f}mL)", "📊"))
        
    except Exception as e:
-        debug_print(f"生成泵协议时出错: {str(e)}")
+        debug_print(f"❌ 生成泵协议时出错: {str(e)}")
        action_sequence.append(create_action_log(f"泵协议生成失败: {str(e)}", "❌"))
        raise ValueError(f"生成泵协议时出错: {str(e)}")
    
    # 7. 混合搅拌
    if stir and stirrer_id:
+        debug_print(f"🔍 步骤7: 混合搅拌...")
        action_sequence.append(create_action_log(f"开始混合搅拌 {stir_time:.0f}s", "🌀"))
        
        action_sequence.append({
@@ -337,10 +448,14 @@ def generate_adjust_ph_protocol(
                "purpose": f"pH调节: 混合试剂，目标pH={ph_value}"
            }
        })
+        
+        debug_print(f"✅ 混合搅拌设置完成")
    else:
+        debug_print(f"⏭️ 跳过混合搅拌")
        action_sequence.append(create_action_log("跳过混合搅拌", "⏭️"))
-
+    
    # 8. 等待平衡
+    debug_print(f"🔍 步骤8: 反应平衡...")
    action_sequence.append(create_action_log(f"等待pH平衡 {settling_time:.0f}s", "⚖️"))
    
    action_sequence.append({
@@ -353,7 +468,17 @@ def generate_adjust_ph_protocol(
    
    # 9. 完成总结
    total_time = addition_time + stir_time + settling_time
-    debug_print(f"pH调节协议完成: {len(action_sequence)} 个动作, {total_time:.0f}s, {volume:.2f}mL {reagent} → {vessel_id} pH {ph_value}")
+    
+    debug_print("=" * 60)
+    debug_print(f"🎉 pH调节协议生成完成")
+    debug_print(f"📊 协议统计:")
+    debug_print(f"  📋 总动作数: {len(action_sequence)}")
+    debug_print(f"  ⏱️ 预计总时间: {total_time:.0f}s ({total_time/60:.1f}分钟)")
+    debug_print(f"  🧪 试剂: {reagent}")
+    debug_print(f"  📏 体积: {volume:.2f}mL")
+    debug_print(f"  📊 目标pH: {ph_value}")
+    debug_print(f"  🥼 目标容器: {vessel_id}")
+    debug_print("=" * 60)
    
    # 添加完成日志
    summary_msg = f"pH调节协议完成: {vessel_id} → pH {ph_value} (使用 {volume:.2f}mL {reagent})"
@@ -385,18 +510,28 @@ def generate_adjust_ph_protocol_stepwise(
    """
    # 🔧 核心修改：从字典中提取容器ID
    vessel_id = vessel["id"]
-
-    debug_print(f"分步pH调节: vessel={vessel_id}, ph={ph_value}, reagent={reagent}, max_volume={max_volume}mL, steps={steps}")
+    
+    debug_print("=" * 60)
+    debug_print(f"🔄 开始分步pH调节")
+    debug_print(f"📋 分步参数:")
+    debug_print(f"  🥼 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  📊 ph_value: {ph_value}")
+    debug_print(f"  🧪 reagent: {reagent}")
+    debug_print(f"  📏 max_volume: {max_volume}mL")
+    debug_print(f"  🔢 steps: {steps}")
+    debug_print("=" * 60)
    
    action_sequence = []
    
    # 每步添加的体积
    step_volume = max_volume / steps
+    debug_print(f"📊 每步体积: {step_volume:.2f}mL")
    
    action_sequence.append(create_action_log(f"开始分步pH调节 ({steps}步)", "🔄"))
    action_sequence.append(create_action_log(f"每步添加: {step_volume:.2f}mL", "📏"))
    
    for i in range(steps):
+        debug_print(f"🔄 执行第 {i+1}/{steps} 步，添加 {step_volume:.2f}mL")
        action_sequence.append(create_action_log(f"第 {i+1}/{steps} 步开始", "🚀"))
        
        # 生成单步协议
@@ -413,10 +548,12 @@ def generate_adjust_ph_protocol_stepwise(
        )
        
        action_sequence.extend(step_actions)
+        debug_print(f"✅ 第 {i+1}/{steps} 步完成，添加了 {len(step_actions)} 个动作")
        action_sequence.append(create_action_log(f"第 {i+1}/{steps} 步完成", "✅"))
        
        # 步骤间等待
        if i < steps - 1:
+            debug_print(f"⏳ 步骤间等待30s")
            action_sequence.append(create_action_log("步骤间等待...", "⏳"))
            action_sequence.append({
                "action_name": "wait",
@@ -426,7 +563,7 @@ def generate_adjust_ph_protocol_stepwise(
                }
            })
    
-    debug_print(f"分步pH调节完成: {len(action_sequence)} 个动作")
+    debug_print(f"🎉 分步pH调节完成，共 {len(action_sequence)} 个动作")
    action_sequence.append(create_action_log("分步pH调节全部完成", "🎉"))
    
    return action_sequence
@@ -440,7 +577,7 @@ def generate_acidify_protocol(
 ) -> List[Dict[str, Any]]:
    """酸化协议"""
    vessel_id = vessel["id"]
-    debug_print(f"酸化协议: {vessel_id} → pH {target_ph} ({acid})")
+    debug_print(f"🍋 生成酸化协议: {vessel_id} → pH {target_ph} (使用 {acid})")
    return generate_adjust_ph_protocol(
        G, vessel, target_ph, acid
    )
@@ -453,7 +590,7 @@ def generate_basify_protocol(
 ) -> List[Dict[str, Any]]:
    """碱化协议"""
    vessel_id = vessel["id"]
-    debug_print(f"碱化协议: {vessel_id} → pH {target_ph} ({base})")
+    debug_print(f"🧂 生成碱化协议: {vessel_id} → pH {target_ph} (使用 {base})")
    return generate_adjust_ph_protocol(
        G, vessel, target_ph, base
    )
@@ -465,7 +602,7 @@ def generate_neutralize_protocol(
 ) -> List[Dict[str, Any]]:
    """中和协议（pH=7）"""
    vessel_id = vessel["id"]
-    debug_print(f"中和协议: {vessel_id} → pH 7.0 ({reagent})")
+    debug_print(f"⚖️ 生成中和协议: {vessel_id} → pH 7.0 (使用 {reagent})")
    return generate_adjust_ph_protocol(
        G, vessel, 7.0, reagent
    )
@@ -473,7 +610,10 @@ def generate_neutralize_protocol(
 # 测试函数
 def test_adjust_ph_protocol():
    """测试pH调节协议"""
+    debug_print("=== ADJUST PH PROTOCOL 增强版测试 ===")
+    
    # 测试体积计算
+    debug_print("🧮 测试体积计算...")
    test_cases = [
        (2.0, "hydrochloric acid", 100.0),
        (4.0, "hydrochloric acid", 100.0),
@@ -481,12 +621,12 @@ def test_adjust_ph_protocol():
        (10.0, "sodium hydroxide", 100.0),
        (7.0, "unknown reagent", 100.0)
    ]
-
+    
    for ph, reagent, volume in test_cases:
        result = calculate_reagent_volume(ph, reagent, volume)
-        debug_print(f"{reagent} → pH {ph}: {result:.2f}mL")
-
-    debug_print("测试完成")
+        debug_print(f"📊 {reagent} → pH {ph}: {result:.2f}mL")
+    
+    debug_print("✅ 测试完成")

 if __name__ == "__main__":
    test_adjust_ph_protocol()
--- a/unilabos/compile/agv_transfer_protocol.py
+++ b/unilabos/compile/agv_transfer_protocol.py
@@ -1,12 +1,4 @@
-"""
-AGV 单物料转运编译器
-
-从 physical_setup_graph 中查询 AGV 配置（device_roles, route_table），
-不再硬编码 device_id 和路由表。
-"""
-
 import networkx as nx
-from unilabos.compile._agv_utils import find_agv_config


 def generate_agv_transfer_protocol(
@@ -25,32 +17,37 @@ def generate_agv_transfer_protocol(
    from_repo_id = from_repo_["id"]
    to_repo_id = to_repo_["id"]

-    # 从 G 中查询 AGV 配置
-    agv_cfg = find_agv_config(G)
-    device_roles = agv_cfg["device_roles"]
-    route_table = agv_cfg["route_table"]
+    wf_list = {
+        ("AiChemEcoHiWo", "zhixing_agv"): {"nav_command" : '{"target" : "LM14"}',
+                             "arm_command": '{"task_name" : "camera/250111_biaozhi.urp"}'},
+        ("AiChemEcoHiWo", "AGV"): {"nav_command" : '{"target" : "LM14"}',
+                             "arm_command": '{"task_name" : "camera/250111_biaozhi.urp"}'},

-    route_key = f"{from_repo_id}->{to_repo_id}"
-    if route_key not in route_table:
-        raise KeyError(f"AGV 路由表中未找到路线: {route_key}，可用路线: {list(route_table.keys())}")
+        ("zhixing_agv", "Revvity"): {"nav_command" : '{"target" : "LM13"}',
+                             "arm_command": '{"task_name" : "camera/250111_put_board.urp"}'},

-    route = route_table[route_key]
-    nav_device = device_roles.get("navigator", device_roles.get("nav"))
-    arm_device = device_roles.get("arm")
+        ("AGV", "Revvity"): {"nav_command" : '{"target" : "LM13"}',
+                             "arm_command": '{"task_name" : "camera/250111_put_board.urp"}'},

+        ("Revvity", "HPLC"): {"nav_command": '{"target" : "LM13"}',
+                              "arm_command": '{"task_name" : "camera/250111_hplc.urp"}'},
+
+        ("HPLC", "Revvity"): {"nav_command": '{"target" : "LM13"}',
+                              "arm_command": '{"task_name" : "camera/250111_lfp.urp"}'},
+    }
    return [
        {
-            "device_id": nav_device,
+            "device_id": "zhixing_agv",
            "action_name": "send_nav_task",
            "action_kwargs": {
-                "command": route["nav_command"]
+                "command": wf_list[(from_repo_id, to_repo_id)]["nav_command"]
            }
        },
        {
-            "device_id": arm_device,
+            "device_id": "zhixing_ur_arm",
            "action_name": "move_pos_task",
            "action_kwargs": {
-                "command": route.get("arm_command", route.get("arm_place", ""))
+                "command": wf_list[(from_repo_id, to_repo_id)]["arm_command"]
            }
        }
    ]
--- a/unilabos/compile/batch_transfer_protocol.py
+++ b/unilabos/compile/batch_transfer_protocol.py
@@ -1,228 +0,0 @@
-"""
-批量物料转运编译器
-
-将 BatchTransferProtocol 编译为多批次的 nav → pick × N → nav → place × N 动作序列。
-自动按 AGV 容量分批，全程维护三方 children dict 的物料系统一致性。
-"""
-
-import copy
-from typing import Any, Dict, List
-
-import networkx as nx
-
-from unilabos.compile._agv_utils import find_agv_config, split_batches
-
-
-def generate_batch_transfer_protocol(
-    G: nx.Graph,
-    from_repo: dict,
-    to_repo: dict,
-    transfer_resources: list,
-    from_positions: list,
-    to_positions: list,
-) -> List[Dict[str, Any]]:
-    """编译批量转运协议为可执行的 action steps
-
-    Args:
-        G: 设备图 (physical_setup_graph)
-        from_repo: 来源工站资源 dict（{station_id: {..., children: {...}}}）
-        to_repo: 目标工站资源 dict（含堆栈和位置信息）
-        transfer_resources: 被转运的物料列表（Resource dict）
-        from_positions: 来源 slot 位置列表（与 transfer_resources 平行）
-        to_positions: 目标 slot 位置列表（与 transfer_resources 平行）
-
-    Returns:
-        action steps 列表，ROS2WorkstationNode 按序执行
-    """
-    if not transfer_resources:
-        return []
-
-    n = len(transfer_resources)
-    if len(from_positions) != n or len(to_positions) != n:
-        raise ValueError(
-            f"transfer_resources({n}), from_positions({len(from_positions)}), "
-            f"to_positions({len(to_positions)}) 长度不一致"
-        )
-
-    # 组合为内部 transfer_items 便于分批处理
-    transfer_items = []
-    for i in range(n):
-        res = transfer_resources[i] if isinstance(transfer_resources[i], dict) else {}
-        transfer_items.append({
-            "resource_id": res.get("id", res.get("name", "")),
-            "resource_uuid": res.get("sample_id", ""),
-            "from_position": from_positions[i],
-            "to_position": to_positions[i],
-            "resource": res,
-        })
-
-    # 查询 AGV 配置
-    agv_cfg = find_agv_config(G)
-    agv_id = agv_cfg["agv_id"]
-    device_roles = agv_cfg["device_roles"]
-    route_table = agv_cfg["route_table"]
-    capacity = agv_cfg["capacity"]
-
-    if capacity <= 0:
-        raise ValueError(f"AGV {agv_id} 容量为 0，请检查 Warehouse 子节点配置")
-
-    nav_device = device_roles.get("navigator", device_roles.get("nav"))
-    arm_device = device_roles.get("arm")
-    if not nav_device or not arm_device:
-        raise ValueError(f"AGV {agv_id} device_roles 缺少 navigator 或 arm: {device_roles}")
-
-    from_repo_ = list(from_repo.values())[0]
-    to_repo_ = list(to_repo.values())[0]
-    from_station_id = from_repo_["id"]
-    to_station_id = to_repo_["id"]
-
-    # 查找路由
-    route_to_source = _find_route(route_table, agv_id, from_station_id)
-    route_to_target = _find_route(route_table, from_station_id, to_station_id)
-
-    # 构建 AGV carrier 的 children dict（用于 compile 阶段状态追踪）
-    agv_carrier_children: Dict[str, Any] = {}
-
-    # 计算 slot 名称（A01, A02, B01, ...）
-    agv_slot_names = _get_agv_slot_names(G, agv_cfg)
-
-    # 分批
-    batches = split_batches(transfer_items, capacity)
-
-    steps: List[Dict[str, Any]] = []
-
-    for batch_idx, batch in enumerate(batches):
-        is_last_batch = (batch_idx == len(batches) - 1)
-
-        # 阶段 1: AGV 导航到来源工站
-        steps.append({
-            "device_id": nav_device,
-            "action_name": "send_nav_task",
-            "action_kwargs": {
-                "command": route_to_source.get("nav_command", "")
-            },
-            "_comment": f"批次{batch_idx + 1}/{len(batches)}: AGV 导航至来源 {from_station_id}"
-        })
-
-        # 阶段 2: 逐个 pick
-        for item_idx, item in enumerate(batch):
-            from_pos = item["from_position"]
-            slot = agv_slot_names[item_idx] if item_idx < len(agv_slot_names) else f"S{item_idx + 1}"
-
-            # compile 阶段更新 children dict
-            if from_pos in from_repo_.get("children", {}):
-                resource_data = from_repo_["children"].pop(from_pos)
-                resource_data["parent"] = agv_id
-                agv_carrier_children[slot] = resource_data
-
-            steps.append({
-                "device_id": arm_device,
-                "action_name": "move_pos_task",
-                "action_kwargs": {
-                    "command": route_to_source.get("arm_pick", route_to_source.get("arm_command", ""))
-                },
-                "_transfer_meta": {
-                    "phase": "pick",
-                    "resource_uuid": item.get("resource_uuid", ""),
-                    "resource_id": item.get("resource_id", ""),
-                    "from_parent": from_station_id,
-                    "from_position": from_pos,
-                    "agv_slot": slot,
-                },
-                "_comment": f"Pick {item.get('resource_id', from_pos)} → AGV.{slot}"
-            })
-
-        # 阶段 3: AGV 导航到目标工站
-        steps.append({
-            "device_id": nav_device,
-            "action_name": "send_nav_task",
-            "action_kwargs": {
-                "command": route_to_target.get("nav_command", "")
-            },
-            "_comment": f"批次{batch_idx + 1}: AGV 导航至目标 {to_station_id}"
-        })
-
-        # 阶段 4: 逐个 place
-        for item_idx, item in enumerate(batch):
-            to_pos = item["to_position"]
-            slot = agv_slot_names[item_idx] if item_idx < len(agv_slot_names) else f"S{item_idx + 1}"
-
-            # compile 阶段更新 children dict
-            if slot in agv_carrier_children:
-                resource_data = agv_carrier_children.pop(slot)
-                resource_data["parent"] = to_repo_["id"]
-                to_repo_["children"][to_pos] = resource_data
-
-            steps.append({
-                "device_id": arm_device,
-                "action_name": "move_pos_task",
-                "action_kwargs": {
-                    "command": route_to_target.get("arm_place", route_to_target.get("arm_command", ""))
-                },
-                "_transfer_meta": {
-                    "phase": "place",
-                    "resource_uuid": item.get("resource_uuid", ""),
-                    "resource_id": item.get("resource_id", ""),
-                    "to_parent": to_station_id,
-                    "to_position": to_pos,
-                    "agv_slot": slot,
-                },
-                "_comment": f"Place AGV.{slot} → {to_station_id}.{to_pos}"
-            })
-
-        # 如果还有下一批，AGV 需要返回来源取料
-        if not is_last_batch:
-            steps.append({
-                "device_id": nav_device,
-                "action_name": "send_nav_task",
-                "action_kwargs": {
-                    "command": route_to_source.get("nav_command", "")
-                },
-                "_comment": f"AGV 返回来源 {from_station_id} 取下一批"
-            })
-
-    return steps
-
-
-def _find_route(route_table: Dict[str, Any], from_id: str, to_id: str) -> Dict[str, str]:
-    """在路由表中查找路线，支持 A->B 和 (A, B) 两种 key 格式"""
-    # 优先 "A->B" 格式
-    key = f"{from_id}->{to_id}"
-    if key in route_table:
-        return route_table[key]
-    # 兼容 tuple key（JSON 中以逗号分隔字符串表示）
-    tuple_key = f"({from_id}, {to_id})"
-    if tuple_key in route_table:
-        return route_table[tuple_key]
-    raise KeyError(f"路由表中未找到: {key}，可用路线: {list(route_table.keys())}")
-
-
-def _get_agv_slot_names(G: nx.Graph, agv_cfg: dict) -> List[str]:
-    """从设备图中获取 AGV Warehouse 的 slot 名称列表"""
-    agv_id = agv_cfg["agv_id"]
-    neighbors = G.successors(agv_id) if G.is_directed() else G.neighbors(agv_id)
-    for neighbor in neighbors:
-        ndata = G.nodes[neighbor]
-        node_type = ndata.get("type", "")
-        res_content = ndata.get("res_content")
-        if hasattr(res_content, "type"):
-            node_type = res_content.type or node_type
-        elif isinstance(res_content, dict):
-            node_type = res_content.get("type", node_type)
-        if node_type == "warehouse":
-            config = ndata.get("config", {})
-            if hasattr(res_content, "config") and isinstance(res_content.config, dict):
-                config = res_content.config
-            elif isinstance(res_content, dict):
-                config = res_content.get("config", config)
-            num_x = config.get("num_items_x", 1)
-            num_y = config.get("num_items_y", 1)
-            num_z = config.get("num_items_z", 1)
-            # 与 warehouse_factory 一致的命名
-            letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-            len_x = num_x if num_z == 1 else (num_y if num_x == 1 else num_x)
-            len_y = num_y if num_z == 1 else (num_z if num_x == 1 else num_z)
-            return [f"{letters[j]}{i + 1:02d}" for i in range(len_x) for j in range(len_y)]
-    # 兜底生成通用名称
-    capacity = agv_cfg.get("capacity", 4)
-    return [f"S{i + 1}" for i in range(capacity)]
--- a/unilabos/compile/clean_vessel_protocol.py
+++ b/unilabos/compile/clean_vessel_protocol.py
@@ -1,9 +1,7 @@
 from typing import List, Dict, Any
 import networkx as nx
-from .utils.vessel_parser import get_vessel, find_solvent_vessel, find_connected_heatchill
-from .utils.logger_util import debug_print
+from .utils.vessel_parser import get_vessel, find_solvent_vessel
 from .pump_protocol import generate_pump_protocol
-from .utils.resource_helper import get_resource_liquid_volume


 def find_solvent_vessel_by_any_match(G: nx.DiGraph, solvent: str) -> str:
@@ -19,23 +17,43 @@ def find_waste_vessel(G: nx.DiGraph) -> str:
    """
    possible_waste_names = [
        "waste_workup",
-        "flask_waste",
+        "flask_waste", 
        "bottle_waste",
        "waste",
        "waste_vessel",
        "waste_container"
    ]
-
+    
    for waste_name in possible_waste_names:
        if waste_name in G.nodes():
            return waste_name
-
+    
    raise ValueError(f"未找到废液容器。尝试了以下名称: {possible_waste_names}")


+def find_connected_heatchill(G: nx.DiGraph, vessel: str) -> str:
+    """
+    查找与指定容器相连的加热冷却设备
+    """
+    # 查找所有加热冷却设备节点
+    heatchill_nodes = [node for node in G.nodes() 
+                      if (G.nodes[node].get('class') or '') == 'virtual_heatchill']
+    
+    # 检查哪个加热设备与目标容器相连（机械连接）
+    for heatchill in heatchill_nodes:
+        if G.has_edge(heatchill, vessel) or G.has_edge(vessel, heatchill):
+            return heatchill
+    
+    # 如果没有直接连接，返回第一个可用的加热设备
+    if heatchill_nodes:
+        return heatchill_nodes[0]
+    
+    return None  # 没有加热设备也可以工作，只是不能加热
+
+
 def generate_clean_vessel_protocol(
    G: nx.DiGraph,
-    vessel: dict,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
    solvent: str,
    volume: float,
    temp: float,
@@ -43,7 +61,7 @@ def generate_clean_vessel_protocol(
 ) -> List[Dict[str, Any]]:
    """
    生成容器清洗操作的协议序列，复用 pump_protocol 的成熟算法
-
+    
    清洗流程：
    1. 查找溶剂容器和废液容器
    2. 如果需要加热，启动加热设备
@@ -52,50 +70,63 @@ def generate_clean_vessel_protocol(
       b. (可选) 等待清洗作用时间
       c. 使用 pump_protocol 将清洗液从目标容器转移到废液容器
    4. 如果加热了，停止加热
-
+    
    Args:
        G: 有向图，节点为设备和容器，边为流体管道
        vessel: 要清洗的容器字典（包含id字段）
-        solvent: 用于清洗的溶剂名称
+        solvent: 用于清洗的溶剂名称  
        volume: 每次清洗使用的溶剂体积
        temp: 清洗时的温度
        repeats: 清洗操作的重复次数，默认为 1
-
+    
    Returns:
        List[Dict[str, Any]]: 容器清洗操作的动作序列
+    
+    Raises:
+        ValueError: 当找不到必要的容器或设备时抛出异常
+    
+    Examples:
+        clean_protocol = generate_clean_vessel_protocol(G, {"id": "main_reactor"}, "water", 100.0, 60.0, 2)
    """
+    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, vessel_data = get_vessel(vessel)
-
+    
    action_sequence = []
-
-    debug_print(f"开始生成容器清洗协议: vessel={vessel_id}, solvent={solvent}, volume={volume}mL, temp={temp}°C, repeats={repeats}")
-
+    
+    print(f"CLEAN_VESSEL: 开始生成容器清洗协议")
+    print(f"  - 目标容器: {vessel} (ID: {vessel_id})")
+    print(f"  - 清洗溶剂: {solvent}")
+    print(f"  - 清洗体积: {volume} mL")
+    print(f"  - 清洗温度: {temp}°C")
+    print(f"  - 重复次数: {repeats}")
+    
    # 验证目标容器存在
    if vessel_id not in G.nodes():
        raise ValueError(f"目标容器 '{vessel_id}' 不存在于系统中")
-
+    
    # 查找溶剂容器
    try:
        solvent_vessel = find_solvent_vessel(G, solvent)
-        debug_print(f"找到溶剂容器: {solvent_vessel}")
+        print(f"CLEAN_VESSEL: 找到溶剂容器: {solvent_vessel}")
    except ValueError as e:
        raise ValueError(f"无法找到溶剂容器: {str(e)}")
-
+    
    # 查找废液容器
    try:
        waste_vessel = find_waste_vessel(G)
-        debug_print(f"找到废液容器: {waste_vessel}")
+        print(f"CLEAN_VESSEL: 找到废液容器: {waste_vessel}")
    except ValueError as e:
        raise ValueError(f"无法找到废液容器: {str(e)}")
-
+    
    # 查找加热设备（可选）
-    heatchill_id = find_connected_heatchill(G, vessel_id)
+    heatchill_id = find_connected_heatchill(G, vessel_id)  # 🔧 使用 vessel_id
    if heatchill_id:
-        debug_print(f"找到加热设备: {heatchill_id}")
+        print(f"CLEAN_VESSEL: 找到加热设备: {heatchill_id}")
    else:
-        debug_print(f"未找到加热设备，将在室温下清洗")
-
-    # 记录清洗前的容器状态
+        print(f"CLEAN_VESSEL: 未找到加热设备，将在室温下清洗")
+    
+    # 🔧 新增：记录清洗前的容器状态
+    print(f"CLEAN_VESSEL: 记录清洗前容器状态...")
    original_liquid_volume = 0.0
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
@@ -103,69 +134,79 @@ def generate_clean_vessel_protocol(
            original_liquid_volume = current_volume[0]
        elif isinstance(current_volume, (int, float)):
            original_liquid_volume = current_volume
-
+    print(f"CLEAN_VESSEL: 清洗前液体体积: {original_liquid_volume:.2f}mL")
+    
    # 第一步：如果需要加热且有加热设备，启动加热
    if temp > 25.0 and heatchill_id:
-        debug_print(f"启动加热至 {temp}°C")
+        print(f"CLEAN_VESSEL: 启动加热至 {temp}°C")
        heatchill_start_action = {
            "device_id": heatchill_id,
            "action_name": "heat_chill_start",
            "action_kwargs": {
-                "vessel": {"id": vessel_id},
+                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
                "temp": temp,
                "purpose": f"cleaning with {solvent}"
            }
        }
        action_sequence.append(heatchill_start_action)
-
+        
+        # 等待温度稳定
        wait_action = {
-            "action_name": "wait",
-            "action_kwargs": {"time": 30}
+            "action_name": "wait", 
+            "action_kwargs": {"time": 30}  # 等待30秒让温度稳定
        }
        action_sequence.append(wait_action)
-
+    
    # 第二步：重复清洗操作
    for repeat in range(repeats):
-        debug_print(f"执行第 {repeat + 1}/{repeats} 次清洗")
-
+        print(f"CLEAN_VESSEL: 执行第 {repeat + 1} 次清洗")
+        
        # 2a. 使用 pump_protocol 将溶剂转移到目标容器
+        print(f"CLEAN_VESSEL: 将 {volume} mL {solvent} 转移到 {vessel_id}")
        try:
+            # 调用成熟的 pump_protocol 算法
            add_solvent_actions = generate_pump_protocol(
                G=G,
                from_vessel=solvent_vessel,
-                to_vessel=vessel_id,
+                to_vessel=vessel_id,  # 🔧 使用 vessel_id
                volume=volume,
-                flowrate=2.5,
+                flowrate=2.5,  # 适中的流速，避免飞溅
                transfer_flowrate=2.5
            )
            action_sequence.extend(add_solvent_actions)
-
-            # 更新容器体积（添加清洗溶剂）
+            
+            # 🔧 新增：更新容器体积（添加清洗溶剂）
+            print(f"CLEAN_VESSEL: 更新容器体积 - 添加清洗溶剂 {volume:.2f}mL")
            if "data" not in vessel:
                vessel["data"] = {}
-
+            
            if "liquid_volume" in vessel["data"]:
                current_volume = vessel["data"]["liquid_volume"]
                if isinstance(current_volume, list):
                    if len(current_volume) > 0:
                        vessel["data"]["liquid_volume"][0] += volume
+                        print(f"CLEAN_VESSEL: 添加溶剂后体积: {vessel['data']['liquid_volume'][0]:.2f}mL (+{volume:.2f}mL)")
                    else:
                        vessel["data"]["liquid_volume"] = [volume]
+                        print(f"CLEAN_VESSEL: 初始化清洗体积: {volume:.2f}mL")
                elif isinstance(current_volume, (int, float)):
                    vessel["data"]["liquid_volume"] += volume
+                    print(f"CLEAN_VESSEL: 添加溶剂后体积: {vessel['data']['liquid_volume']:.2f}mL (+{volume:.2f}mL)")
                else:
                    vessel["data"]["liquid_volume"] = volume
+                    print(f"CLEAN_VESSEL: 重置体积为: {volume:.2f}mL")
            else:
                vessel["data"]["liquid_volume"] = volume
-
-            # 同时更新图中的容器数据
+                print(f"CLEAN_VESSEL: 创建新体积记录: {volume:.2f}mL")
+            
+            # 🔧 同时更新图中的容器数据
            if vessel_id in G.nodes():
                if 'data' not in G.nodes[vessel_id]:
                    G.nodes[vessel_id]['data'] = {}
-
+                
                vessel_node_data = G.nodes[vessel_id]['data']
                current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
-
+                
                if isinstance(current_node_volume, list):
                    if len(current_node_volume) > 0:
                        G.nodes[vessel_id]['data']['liquid_volume'][0] += volume
@@ -173,48 +214,58 @@ def generate_clean_vessel_protocol(
                        G.nodes[vessel_id]['data']['liquid_volume'] = [volume]
                else:
                    G.nodes[vessel_id]['data']['liquid_volume'] = current_node_volume + volume
-
+                
+                print(f"CLEAN_VESSEL: 图节点体积数据已更新")
+            
        except Exception as e:
            raise ValueError(f"无法将溶剂转移到容器: {str(e)}")
-
-        # 2b. 等待清洗作用时间
-        cleaning_wait_time = 60 if temp > 50.0 else 30
+        
+        # 2b. 等待清洗作用时间（让溶剂充分清洗容器）
+        cleaning_wait_time = 60 if temp > 50.0 else 30  # 高温下等待更久
+        print(f"CLEAN_VESSEL: 等待清洗作用 {cleaning_wait_time} 秒")
        wait_action = {
-            "action_name": "wait",
+            "action_name": "wait", 
            "action_kwargs": {"time": cleaning_wait_time}
        }
        action_sequence.append(wait_action)
-
+        
        # 2c. 使用 pump_protocol 将清洗液转移到废液容器
+        print(f"CLEAN_VESSEL: 将清洗液从 {vessel_id} 转移到废液容器")
        try:
+            # 调用成熟的 pump_protocol 算法
            remove_waste_actions = generate_pump_protocol(
                G=G,
-                from_vessel=vessel_id,
+                from_vessel=vessel_id,  # 🔧 使用 vessel_id
                to_vessel=waste_vessel,
                volume=volume,
-                flowrate=2.5,
+                flowrate=2.5,  # 适中的流速
                transfer_flowrate=2.5
            )
            action_sequence.extend(remove_waste_actions)
-
-            # 更新容器体积（移除清洗液）
+            
+            # 🔧 新增：更新容器体积（移除清洗液）
+            print(f"CLEAN_VESSEL: 更新容器体积 - 移除清洗液 {volume:.2f}mL")
            if "data" in vessel and "liquid_volume" in vessel["data"]:
                current_volume = vessel["data"]["liquid_volume"]
                if isinstance(current_volume, list):
                    if len(current_volume) > 0:
                        vessel["data"]["liquid_volume"][0] = max(0.0, vessel["data"]["liquid_volume"][0] - volume)
+                        print(f"CLEAN_VESSEL: 移除清洗液后体积: {vessel['data']['liquid_volume'][0]:.2f}mL (-{volume:.2f}mL)")
                    else:
                        vessel["data"]["liquid_volume"] = [0.0]
+                        print(f"CLEAN_VESSEL: 重置体积为0mL")
                elif isinstance(current_volume, (int, float)):
                    vessel["data"]["liquid_volume"] = max(0.0, current_volume - volume)
+                    print(f"CLEAN_VESSEL: 移除清洗液后体积: {vessel['data']['liquid_volume']:.2f}mL (-{volume:.2f}mL)")
                else:
                    vessel["data"]["liquid_volume"] = 0.0
-
-            # 同时更新图中的容器数据
+                    print(f"CLEAN_VESSEL: 重置体积为0mL")
+            
+            # 🔧 同时更新图中的容器数据
            if vessel_id in G.nodes():
                vessel_node_data = G.nodes[vessel_id].get('data', {})
                current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
-
+                
                if isinstance(current_node_volume, list):
                    if len(current_node_volume) > 0:
                        G.nodes[vessel_id]['data']['liquid_volume'][0] = max(0.0, current_node_volume[0] - volume)
@@ -222,30 +273,34 @@ def generate_clean_vessel_protocol(
                        G.nodes[vessel_id]['data']['liquid_volume'] = [0.0]
                else:
                    G.nodes[vessel_id]['data']['liquid_volume'] = max(0.0, current_node_volume - volume)
-
+                
+                print(f"CLEAN_VESSEL: 图节点体积数据已更新")
+            
        except Exception as e:
            raise ValueError(f"无法将清洗液转移到废液容器: {str(e)}")
-
+        
        # 2d. 清洗循环间的短暂等待
-        if repeat < repeats - 1:
+        if repeat < repeats - 1:  # 不是最后一次清洗
+            print(f"CLEAN_VESSEL: 清洗循环间等待")
            wait_action = {
-                "action_name": "wait",
+                "action_name": "wait", 
                "action_kwargs": {"time": 10}
            }
            action_sequence.append(wait_action)
-
+    
    # 第三步：如果加热了，停止加热
    if temp > 25.0 and heatchill_id:
+        print(f"CLEAN_VESSEL: 停止加热")
        heatchill_stop_action = {
            "device_id": heatchill_id,
            "action_name": "heat_chill_stop",
            "action_kwargs": {
-                "vessel": {"id": vessel_id},
+                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
            }
        }
        action_sequence.append(heatchill_stop_action)
-
-    # 清洗完成后的状态
+    
+    # 🔧 新增：清洗完成后的状态报告
    final_liquid_volume = 0.0
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
@@ -253,17 +308,20 @@ def generate_clean_vessel_protocol(
            final_liquid_volume = current_volume[0]
        elif isinstance(current_volume, (int, float)):
            final_liquid_volume = current_volume
-
-    debug_print(f"清洗完成: {len(action_sequence)} 个动作, 体积 {original_liquid_volume:.2f} -> {final_liquid_volume:.2f}mL")
-
+    
+    print(f"CLEAN_VESSEL: 清洗完成")
+    print(f"  - 清洗前体积: {original_liquid_volume:.2f}mL")
+    print(f"  - 清洗后体积: {final_liquid_volume:.2f}mL")
+    print(f"  - 生成了 {len(action_sequence)} 个动作")
+    
    return action_sequence


-# 便捷函数
+# 便捷函数：常用清洗方案
 def generate_quick_clean_protocol(
-    G: nx.DiGraph,
-    vessel: dict,
-    solvent: str = "water",
+    G: nx.DiGraph, 
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    solvent: str = "water", 
    volume: float = 100.0
 ) -> List[Dict[str, Any]]:
    """快速清洗：室温，单次清洗"""
@@ -271,9 +329,9 @@ def generate_quick_clean_protocol(


 def generate_thorough_clean_protocol(
-    G: nx.DiGraph,
-    vessel: dict,
-    solvent: str = "water",
+    G: nx.DiGraph, 
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    solvent: str = "water", 
    volume: float = 150.0,
    temp: float = 60.0
 ) -> List[Dict[str, Any]]:
@@ -282,13 +340,13 @@ def generate_thorough_clean_protocol(


 def generate_organic_clean_protocol(
-    G: nx.DiGraph,
-    vessel: dict,
+    G: nx.DiGraph, 
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
    volume: float = 100.0
 ) -> List[Dict[str, Any]]:
    """有机清洗：先用有机溶剂，再用水清洗"""
    action_sequence = []
-
+    
    # 第一步：有机溶剂清洗
    try:
        organic_actions = generate_clean_vessel_protocol(
@@ -296,71 +354,96 @@ def generate_organic_clean_protocol(
        )
        action_sequence.extend(organic_actions)
    except ValueError:
+        # 如果没有丙酮，尝试乙醇
        try:
            organic_actions = generate_clean_vessel_protocol(
                G, vessel, "ethanol", volume, 25.0, 2
            )
            action_sequence.extend(organic_actions)
        except ValueError:
-            debug_print("未找到有机溶剂，跳过有机清洗步骤")
-
+            print("警告：未找到有机溶剂，跳过有机清洗步骤")
+    
    # 第二步：水清洗
    water_actions = generate_clean_vessel_protocol(
        G, vessel, "water", volume, 25.0, 2
    )
    action_sequence.extend(water_actions)
-
+    
    return action_sequence


+def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
+    """获取容器中的液体体积（修复版）"""
+    if vessel not in G.nodes():
+        return 0.0
+    
+    vessel_data = G.nodes[vessel].get('data', {})
+    liquids = vessel_data.get('liquid', [])
+    
+    total_volume = 0.0
+    for liquid in liquids:
+        if isinstance(liquid, dict):
+            # 支持两种格式：新格式 (name, volume) 和旧格式 (liquid_type, liquid_volume)
+            volume = liquid.get('volume') or liquid.get('liquid_volume', 0.0)
+            total_volume += volume
+    
+    return total_volume
+
+
 def get_vessel_liquid_types(G: nx.DiGraph, vessel: str) -> List[str]:
    """获取容器中所有液体的类型"""
    if vessel not in G.nodes():
        return []
-
+    
    vessel_data = G.nodes[vessel].get('data', {})
    liquids = vessel_data.get('liquid', [])
-
+    
    liquid_types = []
    for liquid in liquids:
        if isinstance(liquid, dict):
+            # 支持两种格式的液体类型字段
            liquid_type = liquid.get('liquid_type') or liquid.get('name', '')
            if liquid_type:
                liquid_types.append(liquid_type)
-
+    
    return liquid_types


 def find_vessel_by_content(G: nx.DiGraph, content: str) -> List[str]:
    """
    根据内容物查找所有匹配的容器
+    返回匹配容器的ID列表
    """
    matching_vessels = []
-
+    
    for node_id in G.nodes():
        if G.nodes[node_id].get('type') == 'container':
+            # 检查容器名称匹配
            node_name = G.nodes[node_id].get('name', '').lower()
            if content.lower() in node_id.lower() or content.lower() in node_name:
                matching_vessels.append(node_id)
                continue
-
+            
+            # 检查液体类型匹配
            vessel_data = G.nodes[node_id].get('data', {})
            liquids = vessel_data.get('liquid', [])
            config_data = G.nodes[node_id].get('config', {})
-
+            
+            # 检查 reagent_name 和 config.reagent
            reagent_name = vessel_data.get('reagent_name', '').lower()
            config_reagent = config_data.get('reagent', '').lower()
-
-            if (content.lower() == reagent_name or
+            
+            if (content.lower() == reagent_name or 
                content.lower() == config_reagent):
                matching_vessels.append(node_id)
                continue
-
+            
+            # 检查液体列表
            for liquid in liquids:
                if isinstance(liquid, dict):
                    liquid_type = liquid.get('liquid_type') or liquid.get('name', '')
                    if liquid_type.lower() == content.lower():
                        matching_vessels.append(node_id)
                        break
-
-    return matching_vessels
+    
+    return matching_vessels
--- a/unilabos/compile/dissolve_protocol.py
+++ b/unilabos/compile/dissolve_protocol.py
@@ -1,19 +1,402 @@
 from functools import partial

 import networkx as nx
+import re
 import logging
 from typing import List, Dict, Any, Union

-from .utils.logger_util import debug_print, action_log
-from .utils.unit_parser import parse_volume_input, parse_mass_input, parse_time_input, parse_temperature_input
-from .utils.vessel_parser import get_vessel, find_solvent_vessel, find_connected_heatchill, find_connected_stirrer, find_solid_dispenser
+from .utils.vessel_parser import get_vessel
+from .utils.logger_util import action_log
 from .pump_protocol import generate_pump_protocol_with_rinsing

 logger = logging.getLogger(__name__)

-# 创建进度日志动作
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[DISSOLVE] {message}")
+
+# 🆕 创建进度日志动作
 create_action_log = partial(action_log, prefix="[DISSOLVE]")

+def parse_volume_input(volume_input: Union[str, float]) -> float:
+    """
+    解析体积输入，支持带单位的字符串
+    
+    Args:
+        volume_input: 体积输入（如 "10 mL", "?", 10.0）
+    
+    Returns:
+        float: 体积（毫升）
+    """
+    if isinstance(volume_input, (int, float)):
+        debug_print(f"📏 体积输入为数值: {volume_input}")
+        return float(volume_input)
+    
+    if not volume_input or not str(volume_input).strip():
+        debug_print(f"⚠️ 体积输入为空，返回0.0mL")
+        return 0.0
+    
+    volume_str = str(volume_input).lower().strip()
+    debug_print(f"🔍 解析体积输入: '{volume_str}'")
+    
+    # 处理未知体积
+    if volume_str in ['?', 'unknown', 'tbd', 'to be determined']:
+        default_volume = 50.0  # 默认50mL
+        debug_print(f"❓ 检测到未知体积，使用默认值: {default_volume}mL 🎯")
+        return default_volume
+    
+    # 移除空格并提取数字和单位
+    volume_clean = re.sub(r'\s+', '', volume_str)
+    
+    # 匹配数字和单位的正则表达式
+    match = re.match(r'([0-9]*\.?[0-9]+)\s*(ml|l|μl|ul|microliter|milliliter|liter)?', volume_clean)
+    
+    if not match:
+        debug_print(f"❌ 无法解析体积: '{volume_str}'，使用默认值50mL")
+        return 50.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or 'ml'  # 默认单位为毫升
+    
+    # 转换为毫升
+    if unit in ['l', 'liter']:
+        volume = value * 1000.0  # L -> mL
+        debug_print(f"🔄 体积转换: {value}L → {volume}mL")
+    elif unit in ['μl', 'ul', 'microliter']:
+        volume = value / 1000.0  # μL -> mL
+        debug_print(f"🔄 体积转换: {value}μL → {volume}mL")
+    else:  # ml, milliliter 或默认
+        volume = value  # 已经是mL
+        debug_print(f"✅ 体积已为mL: {volume}mL")
+    
+    return volume
+
+def parse_mass_input(mass_input: Union[str, float]) -> float:
+    """
+    解析质量输入，支持带单位的字符串
+    
+    Args:
+        mass_input: 质量输入（如 "2.9 g", "?", 2.5）
+    
+    Returns:
+        float: 质量（克）
+    """
+    if isinstance(mass_input, (int, float)):
+        debug_print(f"⚖️ 质量输入为数值: {mass_input}g")
+        return float(mass_input)
+    
+    if not mass_input or not str(mass_input).strip():
+        debug_print(f"⚠️ 质量输入为空，返回0.0g")
+        return 0.0
+    
+    mass_str = str(mass_input).lower().strip()
+    debug_print(f"🔍 解析质量输入: '{mass_str}'")
+    
+    # 处理未知质量
+    if mass_str in ['?', 'unknown', 'tbd', 'to be determined']:
+        default_mass = 1.0  # 默认1g
+        debug_print(f"❓ 检测到未知质量，使用默认值: {default_mass}g 🎯")
+        return default_mass
+    
+    # 移除空格并提取数字和单位
+    mass_clean = re.sub(r'\s+', '', mass_str)
+    
+    # 匹配数字和单位的正则表达式
+    match = re.match(r'([0-9]*\.?[0-9]+)\s*(g|mg|kg|gram|milligram|kilogram)?', mass_clean)
+    
+    if not match:
+        debug_print(f"❌ 无法解析质量: '{mass_str}'，返回0.0g")
+        return 0.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or 'g'  # 默认单位为克
+    
+    # 转换为克
+    if unit in ['mg', 'milligram']:
+        mass = value / 1000.0  # mg -> g
+        debug_print(f"🔄 质量转换: {value}mg → {mass}g")
+    elif unit in ['kg', 'kilogram']:
+        mass = value * 1000.0  # kg -> g
+        debug_print(f"🔄 质量转换: {value}kg → {mass}g")
+    else:  # g, gram 或默认
+        mass = value  # 已经是g
+        debug_print(f"✅ 质量已为g: {mass}g")
+    
+    return mass
+
+def parse_time_input(time_input: Union[str, float]) -> float:
+    """
+    解析时间输入，支持带单位的字符串
+    
+    Args:
+        time_input: 时间输入（如 "30 min", "1 h", "?", 60.0）
+    
+    Returns:
+        float: 时间（秒）
+    """
+    if isinstance(time_input, (int, float)):
+        debug_print(f"⏱️ 时间输入为数值: {time_input}秒")
+        return float(time_input)
+    
+    if not time_input or not str(time_input).strip():
+        debug_print(f"⚠️ 时间输入为空，返回0秒")
+        return 0.0
+    
+    time_str = str(time_input).lower().strip()
+    debug_print(f"🔍 解析时间输入: '{time_str}'")
+    
+    # 处理未知时间
+    if time_str in ['?', 'unknown', 'tbd']:
+        default_time = 600.0  # 默认10分钟
+        debug_print(f"❓ 检测到未知时间，使用默认值: {default_time}s (10分钟) ⏰")
+        return default_time
+    
+    # 移除空格并提取数字和单位
+    time_clean = re.sub(r'\s+', '', time_str)
+    
+    # 匹配数字和单位的正则表达式
+    match = re.match(r'([0-9]*\.?[0-9]+)\s*(s|sec|second|min|minute|h|hr|hour|d|day)?', time_clean)
+    
+    if not match:
+        debug_print(f"❌ 无法解析时间: '{time_str}'，返回0s")
+        return 0.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or 's'  # 默认单位为秒
+    
+    # 转换为秒
+    if unit in ['min', 'minute']:
+        time_sec = value * 60.0  # min -> s
+        debug_print(f"🔄 时间转换: {value}分钟 → {time_sec}秒")
+    elif unit in ['h', 'hr', 'hour']:
+        time_sec = value * 3600.0  # h -> s
+        debug_print(f"🔄 时间转换: {value}小时 → {time_sec}秒")
+    elif unit in ['d', 'day']:
+        time_sec = value * 86400.0  # d -> s
+        debug_print(f"🔄 时间转换: {value}天 → {time_sec}秒")
+    else:  # s, sec, second 或默认
+        time_sec = value  # 已经是s
+        debug_print(f"✅ 时间已为秒: {time_sec}秒")
+    
+    return time_sec
+
+def parse_temperature_input(temp_input: Union[str, float]) -> float:
+    """
+    解析温度输入，支持带单位的字符串
+    
+    Args:
+        temp_input: 温度输入（如 "60 °C", "room temperature", "?", 25.0）
+    
+    Returns:
+        float: 温度（摄氏度）
+    """
+    if isinstance(temp_input, (int, float)):
+        debug_print(f"🌡️ 温度输入为数值: {temp_input}°C")
+        return float(temp_input)
+    
+    if not temp_input or not str(temp_input).strip():
+        debug_print(f"⚠️ 温度输入为空，使用默认室温25°C")
+        return 25.0  # 默认室温
+    
+    temp_str = str(temp_input).lower().strip()
+    debug_print(f"🔍 解析温度输入: '{temp_str}'")
+    
+    # 处理特殊温度描述
+    temp_aliases = {
+        'room temperature': 25.0,
+        'rt': 25.0,
+        'ambient': 25.0,
+        'cold': 4.0,
+        'ice': 0.0,
+        'reflux': 80.0,  # 默认回流温度
+        '?': 25.0,
+        'unknown': 25.0
+    }
+    
+    if temp_str in temp_aliases:
+        result = temp_aliases[temp_str]
+        debug_print(f"🏷️ 温度别名解析: '{temp_str}' → {result}°C")
+        return result
+    
+    # 移除空格并提取数字和单位
+    temp_clean = re.sub(r'\s+', '', temp_str)
+    
+    # 匹配数字和单位的正则表达式
+    match = re.match(r'([0-9]*\.?[0-9]+)\s*(°c|c|celsius|°f|f|fahrenheit|k|kelvin)?', temp_clean)
+    
+    if not match:
+        debug_print(f"❌ 无法解析温度: '{temp_str}'，使用默认值25°C")
+        return 25.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or 'c'  # 默认单位为摄氏度
+    
+    # 转换为摄氏度
+    if unit in ['°f', 'f', 'fahrenheit']:
+        temp_c = (value - 32) * 5/9  # F -> C
+        debug_print(f"🔄 温度转换: {value}°F → {temp_c:.1f}°C")
+    elif unit in ['k', 'kelvin']:
+        temp_c = value - 273.15  # K -> C
+        debug_print(f"🔄 温度转换: {value}K → {temp_c:.1f}°C")
+    else:  # °c, c, celsius 或默认
+        temp_c = value  # 已经是C
+        debug_print(f"✅ 温度已为°C: {temp_c}°C")
+    
+    return temp_c
+
+def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
+    """增强版溶剂容器查找，支持多种匹配模式"""
+    debug_print(f"🔍 开始查找溶剂 '{solvent}' 的容器...")
+    
+    # 🔧 方法1：直接搜索 data.reagent_name 和 config.reagent
+    debug_print(f"📋 方法1: 搜索reagent字段...")
+    for node in G.nodes():
+        node_data = G.nodes[node].get('data', {})
+        node_type = G.nodes[node].get('type', '')
+        config_data = G.nodes[node].get('config', {})
+        
+        # 只搜索容器类型的节点
+        if node_type == 'container':
+            reagent_name = node_data.get('reagent_name', '').lower()
+            config_reagent = config_data.get('reagent', '').lower()
+            
+            # 精确匹配
+            if reagent_name == solvent.lower() or config_reagent == solvent.lower():
+                debug_print(f"✅ 通过reagent字段精确匹配到容器: {node} 🎯")
+                return node
+            
+            # 模糊匹配
+            if (solvent.lower() in reagent_name and reagent_name) or \
+               (solvent.lower() in config_reagent and config_reagent):
+                debug_print(f"✅ 通过reagent字段模糊匹配到容器: {node} 🔍")
+                return node
+    
+    # 🔧 方法2：常见的容器命名规则
+    debug_print(f"📋 方法2: 使用命名规则查找...")
+    solvent_clean = solvent.lower().replace(' ', '_').replace('-', '_')
+    possible_names = [
+        solvent_clean,
+        f"flask_{solvent_clean}",
+        f"bottle_{solvent_clean}",
+        f"vessel_{solvent_clean}",
+        f"{solvent_clean}_flask",
+        f"{solvent_clean}_bottle",
+        f"solvent_{solvent_clean}",
+        f"reagent_{solvent_clean}",
+        f"reagent_bottle_{solvent_clean}",
+        f"reagent_bottle_1",  # 通用试剂瓶
+        f"reagent_bottle_2",
+        f"reagent_bottle_3"
+    ]
+    
+    debug_print(f"🔍 尝试的容器名称: {possible_names[:5]}... (共{len(possible_names)}个)")
+    
+    for name in possible_names:
+        if name in G.nodes():
+            node_type = G.nodes[name].get('type', '')
+            if node_type == 'container':
+                debug_print(f"✅ 通过命名规则找到容器: {name} 📝")
+                return name
+    
+    # 🔧 方法3：节点名称模糊匹配
+    debug_print(f"📋 方法3: 节点名称模糊匹配...")
+    for node_id in G.nodes():
+        node_data = G.nodes[node_id]
+        if node_data.get('type') == 'container':
+            # 检查节点名称是否包含溶剂名称
+            if solvent_clean in node_id.lower():
+                debug_print(f"✅ 通过节点名称模糊匹配到容器: {node_id} 🔍")
+                return node_id
+            
+            # 检查液体类型匹配
+            vessel_data = node_data.get('data', {})
+            liquids = vessel_data.get('liquid', [])
+            for liquid in liquids:
+                if isinstance(liquid, dict):
+                    liquid_type = liquid.get('liquid_type') or liquid.get('name', '')
+                    if liquid_type.lower() == solvent.lower():
+                        debug_print(f"✅ 通过液体类型匹配到容器: {node_id} 💧")
+                        return node_id
+    
+    # 🔧 方法4：使用第一个试剂瓶作为备选
+    debug_print(f"📋 方法4: 查找备选试剂瓶...")
+    for node_id in G.nodes():
+        node_data = G.nodes[node_id]
+        if (node_data.get('type') == 'container' and 
+            ('reagent' in node_id.lower() or 'bottle' in node_id.lower() or 'flask' in node_id.lower())):
+            debug_print(f"⚠️ 未找到专用容器，使用备选试剂瓶: {node_id} 🔄")
+            return node_id
+    
+    debug_print(f"❌ 所有方法都失败了，无法找到容器!")
+    raise ValueError(f"找不到溶剂 '{solvent}' 对应的容器")
+
+def find_connected_heatchill(G: nx.DiGraph, vessel: str) -> str:
+    """查找连接到指定容器的加热搅拌器"""
+    debug_print(f"🔍 查找连接到容器 '{vessel}' 的加热搅拌器...")
+    
+    heatchill_nodes = []
+    for node in G.nodes():
+        node_class = G.nodes[node].get('class', '').lower()
+        if 'heatchill' in node_class:
+            heatchill_nodes.append(node)
+            debug_print(f"📋 发现加热搅拌器: {node}")
+    
+    debug_print(f"📊 共找到 {len(heatchill_nodes)} 个加热搅拌器")
+    
+    # 查找连接到容器的加热器
+    for heatchill in heatchill_nodes:
+        if G.has_edge(heatchill, vessel) or G.has_edge(vessel, heatchill):
+            debug_print(f"✅ 找到连接的加热搅拌器: {heatchill} 🔗")
+            return heatchill
+    
+    # 返回第一个加热器
+    if heatchill_nodes:
+        debug_print(f"⚠️ 未找到直接连接的加热搅拌器，使用第一个: {heatchill_nodes[0]} 🔄")
+        return heatchill_nodes[0]
+    
+    debug_print(f"❌ 未找到任何加热搅拌器")
+    return ""
+
+def find_connected_stirrer(G: nx.DiGraph, vessel: str) -> str:
+    """查找连接到指定容器的搅拌器"""
+    debug_print(f"🔍 查找连接到容器 '{vessel}' 的搅拌器...")
+    
+    stirrer_nodes = []
+    for node in G.nodes():
+        node_class = G.nodes[node].get('class', '').lower()
+        if 'stirrer' in node_class:
+            stirrer_nodes.append(node)
+            debug_print(f"📋 发现搅拌器: {node}")
+    
+    debug_print(f"📊 共找到 {len(stirrer_nodes)} 个搅拌器")
+    
+    # 查找连接到容器的搅拌器
+    for stirrer in stirrer_nodes:
+        if G.has_edge(stirrer, vessel) or G.has_edge(vessel, stirrer):
+            debug_print(f"✅ 找到连接的搅拌器: {stirrer} 🔗")
+            return stirrer
+    
+    # 返回第一个搅拌器
+    if stirrer_nodes:
+        debug_print(f"⚠️ 未找到直接连接的搅拌器，使用第一个: {stirrer_nodes[0]} 🔄")
+        return stirrer_nodes[0]
+    
+    debug_print(f"❌ 未找到任何搅拌器")
+    return ""
+
+def find_solid_dispenser(G: nx.DiGraph) -> str:
+    """查找固体加样器"""
+    debug_print(f"🔍 查找固体加样器...")
+    
+    for node in G.nodes():
+        node_class = G.nodes[node].get('class', '').lower()
+        if 'solid_dispenser' in node_class or 'dispenser' in node_class:
+            debug_print(f"✅ 找到固体加样器: {node} 🥄")
+            return node
+    
+    debug_print(f"❌ 未找到固体加样器")
+    return ""
+
 def generate_dissolve_protocol(
    G: nx.DiGraph,
    vessel: dict,  # 🔧 修改：从字符串改为字典类型
@@ -53,21 +436,43 @@ def generate_dissolve_protocol(
    - mol: "0.12 mol", "16.2 mmol"
    """
    
-    # 从字典中提取容器ID
+    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, vessel_data = get_vessel(vessel)
-
-    debug_print(f"溶解协议: vessel={vessel_id}, solvent='{solvent}', volume={volume}, "
-                f"mass={mass}, temp={temp}, time={time}")
-
+    
+    debug_print("=" * 60)
+    debug_print("🧪 开始生成溶解协议")
+    debug_print(f"📋 原始参数:")
+    debug_print(f"  🥼 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  💧 solvent: '{solvent}'")
+    debug_print(f"  📏 volume: {volume} (类型: {type(volume)})")
+    debug_print(f"  ⚖️ mass: {mass} (类型: {type(mass)})")
+    debug_print(f"  🌡️ temp: {temp} (类型: {type(temp)})")
+    debug_print(f"  ⏱️ time: {time} (类型: {type(time)})")
+    debug_print(f"  🧪 reagent: '{reagent}'")
+    debug_print(f"  🧬 mol: '{mol}'")
+    debug_print(f"  🎯 event: '{event}'")
+    debug_print(f"  📦 kwargs: {kwargs}")  # 显示额外参数
+    debug_print("=" * 60)
+    
    action_sequence = []
-
+    
+    # === 参数验证 ===
+    debug_print("🔍 步骤1: 参数验证...")
+    action_sequence.append(create_action_log(f"开始溶解操作 - 容器: {vessel_id}", "🎬"))
+    
    if not vessel_id:
+        debug_print("❌ vessel 参数不能为空")
        raise ValueError("vessel 参数不能为空")
    
    if vessel_id not in G.nodes():
+        debug_print(f"❌ 容器 '{vessel_id}' 不存在于系统中")
        raise ValueError(f"容器 '{vessel_id}' 不存在于系统中")
-
-    # 记录溶解前的容器状态
+    
+    debug_print("✅ 基本参数验证通过")
+    action_sequence.append(create_action_log("参数验证通过", "✅"))
+    
+    # 🔧 新增：记录溶解前的容器状态
+    debug_print("🔍 记录溶解前容器状态...")
    original_liquid_volume = 0.0
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
@@ -75,16 +480,30 @@ def generate_dissolve_protocol(
            original_liquid_volume = current_volume[0]
        elif isinstance(current_volume, (int, float)):
            original_liquid_volume = current_volume
-
-    # === 参数解析 ===
+    debug_print(f"📊 溶解前液体体积: {original_liquid_volume:.2f}mL")
+    
+    # === 🔧 关键修复：参数解析 ===
+    debug_print("🔍 步骤2: 参数解析...")
+    action_sequence.append(create_action_log("正在解析溶解参数...", "🔍"))
+    
+    # 解析各种参数为数值
    final_volume = parse_volume_input(volume)
    final_mass = parse_mass_input(mass)
    final_temp = parse_temperature_input(temp)
    final_time = parse_time_input(time)
-
-    debug_print(f"参数解析: vol={final_volume}mL, mass={final_mass}g, temp={final_temp}°C, time={final_time}s")
-
+    
+    debug_print(f"📊 解析结果:")
+    debug_print(f"  📏 体积: {final_volume}mL")
+    debug_print(f"  ⚖️ 质量: {final_mass}g")
+    debug_print(f"  🌡️ 温度: {final_temp}°C")
+    debug_print(f"  ⏱️ 时间: {final_time}s")
+    debug_print(f"  🧪 试剂: '{reagent}'")
+    debug_print(f"  🧬 摩尔: '{mol}'")
+    debug_print(f"  🎯 事件: '{event}'")
+    
    # === 判断溶解类型 ===
+    debug_print("🔍 步骤3: 判断溶解类型...")
+    action_sequence.append(create_action_log("正在判断溶解类型...", "🔍"))
    
    # 判断是固体溶解还是液体溶解
    is_solid_dissolve = (final_mass > 0 or (mol and mol.strip() != "") or (reagent and reagent.strip() != ""))
@@ -96,31 +515,49 @@ def generate_dissolve_protocol(
        final_volume = 50.0
        if not solvent:
            solvent = "water"  # 默认溶剂
-        debug_print("未明确指定溶解参数，默认为50mL水溶解")
+        debug_print("⚠️ 未明确指定溶解参数，默认为50mL水溶解")
    
    dissolve_type = "固体溶解" if is_solid_dissolve else "液体溶解"
-    debug_print(f"溶解类型: {dissolve_type}")
-
-    action_sequence.append(create_action_log(f"溶解类型: {dissolve_type}", "📋"))
-
+    dissolve_emoji = "🧂" if is_solid_dissolve else "💧"
+    debug_print(f"📋 溶解类型: {dissolve_type} {dissolve_emoji}")
+    
+    action_sequence.append(create_action_log(f"确定溶解类型: {dissolve_type} {dissolve_emoji}", "📋"))
+    
    # === 查找设备 ===
+    debug_print("🔍 步骤4: 查找设备...")
+    action_sequence.append(create_action_log("正在查找相关设备...", "🔍"))
+    
+    # 查找加热搅拌器
    heatchill_id = find_connected_heatchill(G, vessel_id)
    stirrer_id = find_connected_stirrer(G, vessel_id)
    
    # 优先使用加热搅拌器，否则使用独立搅拌器
    stir_device_id = heatchill_id or stirrer_id
-    debug_print(f"设备: heatchill='{heatchill_id}', stirrer='{stirrer_id}'")
-
-    if not stir_device_id:
+    
+    debug_print(f"📊 设备映射:")
+    debug_print(f"  🔥 加热器: '{heatchill_id}'")
+    debug_print(f"  🌪️ 搅拌器: '{stirrer_id}'")
+    debug_print(f"  🎯 使用设备: '{stir_device_id}'")
+    
+    if heatchill_id:
+        action_sequence.append(create_action_log(f"找到加热搅拌器: {heatchill_id}", "🔥"))
+    elif stirrer_id:
+        action_sequence.append(create_action_log(f"找到搅拌器: {stirrer_id}", "🌪️"))
+    else:
        action_sequence.append(create_action_log("未找到搅拌设备，将跳过搅拌", "⚠️"))
    
    # === 执行溶解流程 ===
+    debug_print("🔍 步骤5: 执行溶解流程...")
+    
    try:
-        # 启动加热搅拌（如果需要）
+        # 步骤5.1: 启动加热搅拌（如果需要）
        if stir_device_id and (final_temp > 25.0 or final_time > 0 or stir_speed > 0):
-
+            debug_print(f"🔍 5.1: 启动加热搅拌，温度: {final_temp}°C")
+            action_sequence.append(create_action_log(f"准备加热搅拌 (目标温度: {final_temp}°C)", "🔥"))
+            
            if heatchill_id and (final_temp > 25.0 or final_time > 0):
                # 使用加热搅拌器
+                action_sequence.append(create_action_log(f"启动加热搅拌器 {heatchill_id}", "🔥"))
                
                heatchill_action = {
                    "device_id": heatchill_id,
@@ -136,6 +573,7 @@ def generate_dissolve_protocol(
                # 等待温度稳定
                if final_temp > 25.0:
                    wait_time = min(60, abs(final_temp - 25.0) * 1.5)
+                    action_sequence.append(create_action_log(f"等待温度稳定 ({wait_time:.0f}秒)", "⏳"))
                    action_sequence.append({
                        "action_name": "wait",
                        "action_kwargs": {"time": wait_time}
@@ -143,6 +581,7 @@ def generate_dissolve_protocol(
            
            elif stirrer_id:
                # 使用独立搅拌器
+                action_sequence.append(create_action_log(f"启动搅拌器 {stirrer_id} (速度: {stir_speed}rpm)", "🌪️"))
                
                stir_action = {
                    "device_id": stirrer_id,
@@ -154,8 +593,9 @@ def generate_dissolve_protocol(
                    }
                }
                action_sequence.append(stir_action)
-
+                
                # 等待搅拌稳定
+                action_sequence.append(create_action_log("等待搅拌稳定...", "⏳"))
                action_sequence.append({
                    "action_name": "wait",
                    "action_kwargs": {"time": 5}
@@ -163,8 +603,12 @@ def generate_dissolve_protocol(
        
        if is_solid_dissolve:
            # === 固体溶解路径 ===
+            debug_print(f"🔍 5.2: 使用固体溶解路径")
+            action_sequence.append(create_action_log("开始固体溶解流程", "🧂"))
+            
            solid_dispenser = find_solid_dispenser(G)
            if solid_dispenser:
+                action_sequence.append(create_action_log(f"找到固体加样器: {solid_dispenser}", "🥄"))
                
                # 固体加样
                add_kwargs = {
@@ -176,27 +620,42 @@ def generate_dissolve_protocol(
                
                if final_mass > 0:
                    add_kwargs["mass"] = str(final_mass)
+                    action_sequence.append(create_action_log(f"准备添加固体: {final_mass}g", "⚖️"))
                if mol and mol.strip():
                    add_kwargs["mol"] = mol
-
+                    action_sequence.append(create_action_log(f"按摩尔数添加: {mol}", "🧬"))
+                
+                action_sequence.append(create_action_log("开始固体加样操作", "🥄"))
                action_sequence.append({
                    "device_id": solid_dispenser,
                    "action_name": "add_solid",
                    "action_kwargs": add_kwargs
                })
-
-                # 固体溶解体积运算 - 固体本身不会显著增加体积
+                
+                debug_print(f"✅ 固体加样完成")
+                action_sequence.append(create_action_log("固体加样完成", "✅"))
+                
+                # 🔧 新增：固体溶解体积运算 - 固体本身不会显著增加体积，但可能有少量变化
+                debug_print(f"🔧 固体溶解 - 体积变化很小，主要是质量变化")
+                # 固体通常不会显著改变液体体积，这里只记录日志
+                action_sequence.append(create_action_log(f"固体已添加: {final_mass}g", "📊"))
                
            else:
-                debug_print("未找到固体加样器，跳过固体添加")
+                debug_print("⚠️ 未找到固体加样器，跳过固体添加")
                action_sequence.append(create_action_log("未找到固体加样器，无法添加固体", "❌"))
        
        elif is_liquid_dissolve:
            # === 液体溶解路径 ===
+            debug_print(f"🔍 5.3: 使用液体溶解路径")
+            action_sequence.append(create_action_log("开始液体溶解流程", "💧"))
+            
+            # 查找溶剂容器
+            action_sequence.append(create_action_log("正在查找溶剂容器...", "🔍"))
            try:
                solvent_vessel = find_solvent_vessel(G, solvent)
+                action_sequence.append(create_action_log(f"找到溶剂容器: {solvent_vessel}", "🧪"))
            except ValueError as e:
-                debug_print(f"溶剂容器查找失败: {str(e)}，跳过溶剂添加")
+                debug_print(f"⚠️ {str(e)}，跳过溶剂添加")
                action_sequence.append(create_action_log(f"溶剂容器查找失败: {str(e)}", "❌"))
                solvent_vessel = None
            
@@ -204,7 +663,10 @@ def generate_dissolve_protocol(
                # 计算流速 - 溶解时通常用较慢的速度，避免飞溅
                flowrate = 1.0  # 较慢的注入速度
                transfer_flowrate = 0.5  # 较慢的转移速度
-
+                
+                action_sequence.append(create_action_log(f"设置流速: {flowrate}mL/min (缓慢注入)", "⚡"))
+                action_sequence.append(create_action_log(f"开始转移 {final_volume}mL {solvent}", "🚰"))
+                
                # 调用pump protocol
                pump_actions = generate_pump_protocol_with_rinsing(
                    G=G,
@@ -226,9 +688,12 @@ def generate_dissolve_protocol(
                    **kwargs
                )
                action_sequence.extend(pump_actions)
-
-                # 液体溶解体积运算 - 添加溶剂后更新容器体积
-
+                debug_print(f"✅ 溶剂转移完成，添加了 {len(pump_actions)} 个动作")
+                action_sequence.append(create_action_log(f"溶剂转移完成 ({len(pump_actions)} 个操作)", "✅"))
+                
+                # 🔧 新增：液体溶解体积运算 - 添加溶剂后更新容器体积
+                debug_print(f"🔧 更新容器液体体积 - 添加溶剂 {final_volume:.2f}mL")
+                
                # 确保vessel有data字段
                if "data" not in vessel:
                    vessel["data"] = {}
@@ -238,14 +703,19 @@ def generate_dissolve_protocol(
                    if isinstance(current_volume, list):
                        if len(current_volume) > 0:
                            vessel["data"]["liquid_volume"][0] += final_volume
+                            debug_print(f"📊 添加溶剂后体积: {vessel['data']['liquid_volume'][0]:.2f}mL (+{final_volume:.2f}mL)")
                        else:
                            vessel["data"]["liquid_volume"] = [final_volume]
+                            debug_print(f"📊 初始化溶解体积: {final_volume:.2f}mL")
                    elif isinstance(current_volume, (int, float)):
                        vessel["data"]["liquid_volume"] += final_volume
+                        debug_print(f"📊 添加溶剂后体积: {vessel['data']['liquid_volume']:.2f}mL (+{final_volume:.2f}mL)")
                    else:
                        vessel["data"]["liquid_volume"] = final_volume
+                        debug_print(f"📊 重置体积为: {final_volume:.2f}mL")
                else:
                    vessel["data"]["liquid_volume"] = final_volume
+                    debug_print(f"📊 创建新体积记录: {final_volume:.2f}mL")
                
                # 🔧 同时更新图中的容器数据
                if vessel_id in G.nodes():
@@ -262,19 +732,27 @@ def generate_dissolve_protocol(
                            G.nodes[vessel_id]['data']['liquid_volume'] = [final_volume]
                    else:
                        G.nodes[vessel_id]['data']['liquid_volume'] = current_node_volume + final_volume
-
+                    
+                    debug_print(f"✅ 图节点体积数据已更新")
+                
+                action_sequence.append(create_action_log(f"容器体积已更新 (+{final_volume:.2f}mL)", "📊"))
+                
                # 溶剂添加后等待
+                action_sequence.append(create_action_log("溶剂添加后短暂等待...", "⏳"))
                action_sequence.append({
                    "action_name": "wait",
                    "action_kwargs": {"time": 5}
                })
        
-        # 等待溶解完成
+        # 步骤5.4: 等待溶解完成
        if final_time > 0:
+            debug_print(f"🔍 5.4: 等待溶解完成 - {final_time}s")
            wait_minutes = final_time / 60
-
+            action_sequence.append(create_action_log(f"开始溶解等待 ({wait_minutes:.1f}分钟)", "⏰"))
+            
            if heatchill_id:
                # 使用定时加热搅拌
+                action_sequence.append(create_action_log(f"使用加热搅拌器进行定时溶解", "🔥"))
                
                dissolve_action = {
                    "device_id": heatchill_id,
@@ -292,6 +770,7 @@ def generate_dissolve_protocol(
            
            elif stirrer_id:
                # 使用定时搅拌
+                action_sequence.append(create_action_log(f"使用搅拌器进行定时溶解", "🌪️"))
                
                stir_action = {
                    "device_id": stirrer_id,
@@ -308,6 +787,7 @@ def generate_dissolve_protocol(
            
            else:
                # 简单等待
+                action_sequence.append(create_action_log(f"简单等待溶解完成", "⏳"))
                action_sequence.append({
                    "action_name": "wait",
                    "action_kwargs": {"time": final_time}
@@ -315,7 +795,9 @@ def generate_dissolve_protocol(
        
        # 步骤5.5: 停止加热搅拌（如果需要）
        if heatchill_id and final_time == 0 and final_temp > 25.0:
-
+            debug_print(f"🔍 5.5: 停止加热器")
+            action_sequence.append(create_action_log("停止加热搅拌器", "🛑"))
+            
            stop_action = {
                "device_id": heatchill_id,
                "action_name": "heat_chill_stop",
@@ -326,7 +808,7 @@ def generate_dissolve_protocol(
            action_sequence.append(stop_action)
        
    except Exception as e:
-        debug_print(f"溶解流程执行失败: {str(e)}")
+        debug_print(f"❌ 溶解流程执行失败: {str(e)}")
        action_sequence.append(create_action_log(f"溶解流程失败: {str(e)}", "❌"))
        # 添加错误日志
        action_sequence.append({
@@ -347,8 +829,23 @@ def generate_dissolve_protocol(
            final_liquid_volume = current_volume
    
    # === 最终结果 ===
-    debug_print(f"溶解协议完成: {vessel_id}, 类型={dissolve_type}, "
-                f"动作数={len(action_sequence)}, 体积={original_liquid_volume:.2f}→{final_liquid_volume:.2f}mL")
+    debug_print("=" * 60)
+    debug_print(f"🎉 溶解协议生成完成")
+    debug_print(f"📊 协议统计:")
+    debug_print(f"  📋 总动作数: {len(action_sequence)}")
+    debug_print(f"  🥼 容器: {vessel_id}")
+    debug_print(f"  {dissolve_emoji} 溶解类型: {dissolve_type}")
+    if is_liquid_dissolve:
+        debug_print(f"  💧 溶剂: {solvent} ({final_volume}mL)")
+    if is_solid_dissolve:
+        debug_print(f"  🧪 试剂: {reagent}")
+        debug_print(f"  ⚖️ 质量: {final_mass}g")
+        debug_print(f"  🧬 摩尔: {mol}")
+    debug_print(f"  🌡️ 温度: {final_temp}°C")
+    debug_print(f"  ⏱️ 时间: {final_time}s")
+    debug_print(f"  📊 溶解前体积: {original_liquid_volume:.2f}mL")
+    debug_print(f"  📊 溶解后体积: {final_liquid_volume:.2f}mL")
+    debug_print("=" * 60)
    
    # 添加完成日志
    summary_msg = f"溶解协议完成: {vessel_id}"
@@ -357,7 +854,7 @@ def generate_dissolve_protocol(
    if is_solid_dissolve:
        summary_msg += f" (溶解 {final_mass}g {reagent})"
    
-    action_sequence.append(create_action_log(summary_msg, "✅"))
+    action_sequence.append(create_action_log(summary_msg, "🎉"))
    
    return action_sequence

@@ -369,7 +866,7 @@ def dissolve_solid_by_mass(G: nx.DiGraph, vessel: dict, reagent: str, mass: Unio
                          temp: Union[str, float] = 25.0, time: Union[str, float] = "10 min") -> List[Dict[str, Any]]:
    """按质量溶解固体"""
    vessel_id = vessel["id"]
-    debug_print(f"快速固体溶解: {reagent} ({mass}) → {vessel_id}")
+    debug_print(f"🧂 快速固体溶解: {reagent} ({mass}) → {vessel_id}")
    return generate_dissolve_protocol(
        G, vessel, 
        mass=mass, 
@@ -382,7 +879,7 @@ def dissolve_solid_by_moles(G: nx.DiGraph, vessel: dict, reagent: str, mol: str,
                           temp: Union[str, float] = 25.0, time: Union[str, float] = "10 min") -> List[Dict[str, Any]]:
    """按摩尔数溶解固体"""
    vessel_id = vessel["id"]
-    debug_print(f"按摩尔数溶解固体: {reagent} ({mol}) → {vessel_id}")
+    debug_print(f"🧬 按摩尔数溶解固体: {reagent} ({mol}) → {vessel_id}")
    return generate_dissolve_protocol(
        G, vessel, 
        mol=mol, 
@@ -395,7 +892,7 @@ def dissolve_with_solvent(G: nx.DiGraph, vessel: dict, solvent: str, volume: Uni
                         temp: Union[str, float] = 25.0, time: Union[str, float] = "5 min") -> List[Dict[str, Any]]:
    """用溶剂溶解"""
    vessel_id = vessel["id"]
-    debug_print(f"溶剂溶解: {solvent} ({volume}) → {vessel_id}")
+    debug_print(f"💧 溶剂溶解: {solvent} ({volume}) → {vessel_id}")
    return generate_dissolve_protocol(
        G, vessel, 
        solvent=solvent, 
@@ -407,7 +904,7 @@ def dissolve_with_solvent(G: nx.DiGraph, vessel: dict, solvent: str, volume: Uni
 def dissolve_at_room_temp(G: nx.DiGraph, vessel: dict, solvent: str, volume: Union[str, float]) -> List[Dict[str, Any]]:
    """室温溶解"""
    vessel_id = vessel["id"]
-    debug_print(f"室温溶解: {solvent} ({volume}) → {vessel_id}")
+    debug_print(f"🌡️ 室温溶解: {solvent} ({volume}) → {vessel_id}")
    return generate_dissolve_protocol(
        G, vessel, 
        solvent=solvent, 
@@ -420,7 +917,7 @@ def dissolve_with_heating(G: nx.DiGraph, vessel: dict, solvent: str, volume: Uni
                         temp: Union[str, float] = "60 °C", time: Union[str, float] = "15 min") -> List[Dict[str, Any]]:
    """加热溶解"""
    vessel_id = vessel["id"]
-    debug_print(f"加热溶解: {solvent} ({volume}) → {vessel_id} @ {temp}")
+    debug_print(f"🔥 加热溶解: {solvent} ({volume}) → {vessel_id} @ {temp}")
    return generate_dissolve_protocol(
        G, vessel, 
        solvent=solvent, 
@@ -432,31 +929,37 @@ def dissolve_with_heating(G: nx.DiGraph, vessel: dict, solvent: str, volume: Uni
 # 测试函数
 def test_dissolve_protocol():
    """测试溶解协议的各种参数解析"""
+    debug_print("=== DISSOLVE PROTOCOL 增强版测试 ===")
+    
    # 测试体积解析
+    debug_print("💧 测试体积解析...")
    volumes = ["10 mL", "?", 10.0, "1 L", "500 μL"]
    for vol in volumes:
        result = parse_volume_input(vol)
-        debug_print(f"体积解析: {vol} → {result}mL")
-
+        debug_print(f"📏 体积解析: {vol} → {result}mL")
+    
    # 测试质量解析
+    debug_print("⚖️ 测试质量解析...")
    masses = ["2.9 g", "?", 2.5, "500 mg"]
    for mass in masses:
        result = parse_mass_input(mass)
-        debug_print(f"质量解析: {mass} → {result}g")
-
+        debug_print(f"⚖️ 质量解析: {mass} → {result}g")
+    
    # 测试温度解析
+    debug_print("🌡️ 测试温度解析...")
    temps = ["60 °C", "room temperature", "?", 25.0, "reflux"]
    for temp in temps:
        result = parse_temperature_input(temp)
-        debug_print(f"温度解析: {temp} → {result}°C")
-
+        debug_print(f"🌡️ 温度解析: {temp} → {result}°C")
+    
    # 测试时间解析
+    debug_print("⏱️ 测试时间解析...")
    times = ["30 min", "1 h", "?", 60.0]
    for time in times:
        result = parse_time_input(time)
-        debug_print(f"时间解析: {time} → {result}s")
-
-    debug_print("测试完成")
+        debug_print(f"⏱️ 时间解析: {time} → {result}s")
+    
+    debug_print("✅ 测试完成")

 if __name__ == "__main__":
    test_dissolve_protocol()
--- a/unilabos/compile/dry_protocol.py
+++ b/unilabos/compile/dry_protocol.py
@@ -1,40 +1,87 @@
 import networkx as nx
 from typing import List, Dict, Any

-from .utils.vessel_parser import get_vessel, find_connected_heatchill
-from .utils.logger_util import debug_print
+from unilabos.compile.utils.vessel_parser import get_vessel
+
+
+def find_connected_heater(G: nx.DiGraph, vessel: str) -> str:
+    """
+    查找与容器相连的加热器
+    
+    Args:
+        G: 网络图
+        vessel: 容器名称
+    
+    Returns:
+        str: 加热器ID，如果没有则返回None
+    """
+    print(f"DRY: 正在查找与容器 '{vessel}' 相连的加热器...")
+    
+    # 查找所有加热器节点
+    heater_nodes = [node for node in G.nodes() 
+                   if ('heater' in node.lower() or 
+                       'heat' in node.lower() or
+                       G.nodes[node].get('class') == 'virtual_heatchill' or
+                       G.nodes[node].get('type') == 'heater')]
+    
+    print(f"DRY: 找到的加热器节点: {heater_nodes}")
+    
+    # 检查是否有加热器与目标容器相连
+    for heater in heater_nodes:
+        if G.has_edge(heater, vessel) or G.has_edge(vessel, heater):
+            print(f"DRY: 找到与容器 '{vessel}' 相连的加热器: {heater}")
+            return heater
+    
+    # 如果没有直接连接，查找距离最近的加热器
+    for heater in heater_nodes:
+        try:
+            path = nx.shortest_path(G, source=heater, target=vessel)
+            if len(path) <= 3:  # 最多2个中间节点
+                print(f"DRY: 找到距离较近的加热器: {heater}, 路径: {' → '.join(path)}")
+                return heater
+        except nx.NetworkXNoPath:
+            continue
+    
+    print(f"DRY: 未找到与容器 '{vessel}' 相连的加热器")
+    return None


 def generate_dry_protocol(
    G: nx.DiGraph,
-    vessel: dict,
-    compound: str = "",
-    **kwargs
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    compound: str = "",  # 🔧 修改：参数顺序调整，并设置默认值
+    **kwargs  # 接收其他可能的参数但不使用
 ) -> List[Dict[str, Any]]:
    """
    生成干燥协议序列
-
+    
    Args:
        G: 有向图，节点为容器和设备
        vessel: 目标容器字典（从XDL传入）
        compound: 化合物名称（从XDL传入，可选）
        **kwargs: 其他可选参数，但不使用
-
+    
    Returns:
        List[Dict[str, Any]]: 动作序列
    """
+    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, vessel_data = get_vessel(vessel)
-
+    
    action_sequence = []
-
+    
    # 默认参数
-    dry_temp = 60.0
-    dry_time = 3600.0
-    simulation_time = 60.0
-
-    debug_print(f"开始生成干燥协议: vessel={vessel_id}, compound={compound or '未指定'}, temp={dry_temp}°C")
-
-    # 记录干燥前的容器状态
+    dry_temp = 60.0  # 默认干燥温度 60°C
+    dry_time = 3600.0  # 默认干燥时间 1小时（3600秒）
+    simulation_time = 60.0  # 模拟时间 1分钟
+    
+    print(f"🌡️ DRY: 开始生成干燥协议 ✨")
+    print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    print(f"  🧪 化合物: {compound or '未指定'}")
+    print(f"  🔥 干燥温度: {dry_temp}°C")
+    print(f"  ⏰ 干燥时间: {dry_time/60:.0f} 分钟")
+    
+    # 🔧 新增：记录干燥前的容器状态
+    print(f"🔍 记录干燥前容器状态...")
    original_liquid_volume = 0.0
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
@@ -42,30 +89,39 @@ def generate_dry_protocol(
            original_liquid_volume = current_volume[0]
        elif isinstance(current_volume, (int, float)):
            original_liquid_volume = current_volume
-
+    print(f"📊 干燥前液体体积: {original_liquid_volume:.2f}mL")
+    
    # 1. 验证目标容器存在
+    print(f"\n📋 步骤1: 验证目标容器 '{vessel_id}' 是否存在...")
    if vessel_id not in G.nodes():
-        debug_print(f"容器 '{vessel_id}' 不存在于系统中，跳过干燥")
+        print(f"⚠️ DRY: 警告 - 容器 '{vessel_id}' 不存在于系统中，跳过干燥 😢")
        return action_sequence
-
+    print(f"✅ 容器 '{vessel_id}' 验证通过!")
+    
    # 2. 查找相连的加热器
-    heater_id = find_connected_heatchill(G, vessel_id)
-
+    print(f"\n🔍 步骤2: 查找与容器相连的加热器...")
+    heater_id = find_connected_heater(G, vessel_id)  # 🔧 使用 vessel_id
+    
    if heater_id is None:
-        debug_print(f"未找到与容器 '{vessel_id}' 相连的加热器，添加模拟干燥动作")
+        print(f"😭 DRY: 警告 - 未找到与容器 '{vessel_id}' 相连的加热器，跳过干燥")
+        print(f"🎭 添加模拟干燥动作...")
+        # 添加一个等待动作，表示干燥过程（模拟）
        action_sequence.append({
            "action_name": "wait",
            "action_kwargs": {
-                "time": 10.0,
+                "time": 10.0,  # 模拟等待时间
                "description": f"模拟干燥 {compound or '化合物'} (无加热器可用)"
            }
        })
-
-        # 模拟干燥的体积变化
+        
+        # 🔧 新增：模拟干燥的体积变化（溶剂蒸发）
+        print(f"🔧 模拟干燥过程的体积减少...")
        if original_liquid_volume > 0:
+            # 假设干燥过程中损失10%的体积（溶剂蒸发）
            volume_loss = original_liquid_volume * 0.1
            new_volume = max(0.0, original_liquid_volume - volume_loss)
-
+            
+            # 更新vessel字典中的体积
            if "data" in vessel and "liquid_volume" in vessel["data"]:
                current_volume = vessel["data"]["liquid_volume"]
                if isinstance(current_volume, list):
@@ -77,14 +133,15 @@ def generate_dry_protocol(
                    vessel["data"]["liquid_volume"] = new_volume
                else:
                    vessel["data"]["liquid_volume"] = new_volume
-
+            
+            # 🔧 同时更新图中的容器数据
            if vessel_id in G.nodes():
                if 'data' not in G.nodes[vessel_id]:
                    G.nodes[vessel_id]['data'] = {}
-
+                
                vessel_node_data = G.nodes[vessel_id]['data']
                current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
-
+                
                if isinstance(current_node_volume, list):
                    if len(current_node_volume) > 0:
                        G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume
@@ -92,27 +149,33 @@ def generate_dry_protocol(
                        G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume]
                else:
                    G.nodes[vessel_id]['data']['liquid_volume'] = new_volume
-
-            debug_print(f"模拟干燥体积变化: {original_liquid_volume:.2f}mL -> {new_volume:.2f}mL")
-
-        debug_print(f"协议生成完成，共 {len(action_sequence)} 个动作")
+            
+            print(f"📊 模拟干燥体积变化: {original_liquid_volume:.2f}mL → {new_volume:.2f}mL (-{volume_loss:.2f}mL)")
+        
+        print(f"📄 DRY: 协议生成完成，共 {len(action_sequence)} 个动作 🎯")
        return action_sequence
-
-    debug_print(f"找到加热器: {heater_id}")
-
+    
+    print(f"🎉 找到加热器: {heater_id}!")
+    
    # 3. 启动加热器进行干燥
+    print(f"\n🚀 步骤3: 开始执行干燥流程...")
+    print(f"🔥 启动加热器 {heater_id} 进行干燥")
+    
    # 3.1 启动加热
+    print(f"  ⚡ 动作1: 启动加热到 {dry_temp}°C...")
    action_sequence.append({
        "device_id": heater_id,
        "action_name": "heat_chill_start",
        "action_kwargs": {
-            "vessel": {"id": vessel_id},
+            "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
            "temp": dry_temp,
            "purpose": f"干燥 {compound or '化合物'}"
        }
    })
-
+    print(f"  ✅ 加热器启动命令已添加 🔥")
+    
    # 3.2 等待温度稳定
+    print(f"  ⏳ 动作2: 等待温度稳定...")
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {
@@ -120,27 +183,34 @@ def generate_dry_protocol(
            "description": f"等待温度稳定到 {dry_temp}°C"
        }
    })
-
+    print(f"  ✅ 温度稳定等待命令已添加 🌡️")
+    
    # 3.3 保持干燥温度
+    print(f"  🔄 动作3: 保持干燥温度 {simulation_time/60:.0f} 分钟...")
    action_sequence.append({
        "device_id": heater_id,
        "action_name": "heat_chill",
        "action_kwargs": {
-            "vessel": {"id": vessel_id},
+            "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
            "temp": dry_temp,
            "time": simulation_time,
            "purpose": f"干燥 {compound or '化合物'}，保持温度 {dry_temp}°C"
        }
    })
-
-    # 干燥过程中的体积变化计算
+    print(f"  ✅ 温度保持命令已添加 🌡️⏰")
+    
+    # 🔧 新增：干燥过程中的体积变化计算
+    print(f"🔧 计算干燥过程中的体积变化...")
    if original_liquid_volume > 0:
-        evaporation_rate = 0.001 * dry_temp
-        total_evaporation = min(original_liquid_volume * 0.8,
-                               evaporation_rate * simulation_time)
-
+        # 干燥过程中，溶剂会蒸发，固体保留
+        # 根据温度和时间估算蒸发量
+        evaporation_rate = 0.001 * dry_temp  # 每秒每°C蒸发0.001mL
+        total_evaporation = min(original_liquid_volume * 0.8, 
+                               evaporation_rate * simulation_time)  # 最多蒸发80%
+        
        new_volume = max(0.0, original_liquid_volume - total_evaporation)
-
+        
+        # 更新vessel字典中的体积
        if "data" in vessel and "liquid_volume" in vessel["data"]:
            current_volume = vessel["data"]["liquid_volume"]
            if isinstance(current_volume, list):
@@ -152,14 +222,15 @@ def generate_dry_protocol(
                vessel["data"]["liquid_volume"] = new_volume
            else:
                vessel["data"]["liquid_volume"] = new_volume
-
+        
+        # 🔧 同时更新图中的容器数据
        if vessel_id in G.nodes():
            if 'data' not in G.nodes[vessel_id]:
                G.nodes[vessel_id]['data'] = {}
-
+            
            vessel_node_data = G.nodes[vessel_id]['data']
            current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
-
+            
            if isinstance(current_node_volume, list):
                if len(current_node_volume) > 0:
                    G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume
@@ -167,29 +238,37 @@ def generate_dry_protocol(
                    G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume]
            else:
                G.nodes[vessel_id]['data']['liquid_volume'] = new_volume
-
-        debug_print(f"干燥体积变化: {original_liquid_volume:.2f}mL -> {new_volume:.2f}mL (-{total_evaporation:.2f}mL)")
-
+        
+        print(f"📊 干燥体积变化计算:")
+        print(f"  - 初始体积: {original_liquid_volume:.2f}mL")
+        print(f"  - 蒸发量: {total_evaporation:.2f}mL")
+        print(f"  - 剩余体积: {new_volume:.2f}mL")
+        print(f"  - 蒸发率: {(total_evaporation/original_liquid_volume*100):.1f}%")
+    
    # 3.4 停止加热
+    print(f"  ⏹️ 动作4: 停止加热...")
    action_sequence.append({
        "device_id": heater_id,
        "action_name": "heat_chill_stop",
        "action_kwargs": {
-            "vessel": {"id": vessel_id},
+            "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
            "purpose": f"干燥完成，停止加热"
        }
    })
-
+    print(f"  ✅ 停止加热命令已添加 🛑")
+    
    # 3.5 等待冷却
+    print(f"  ❄️ 动作5: 等待冷却...")
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {
-            "time": 10.0,
+            "time": 10.0,  # 等待10秒冷却
            "description": f"等待 {compound or '化合物'} 冷却"
        }
    })
-
-    # 最终状态
+    print(f"  ✅ 冷却等待命令已添加 🧊")
+    
+    # 🔧 新增：干燥完成后的状态报告
    final_liquid_volume = 0.0
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
@@ -197,37 +276,60 @@ def generate_dry_protocol(
            final_liquid_volume = current_volume[0]
        elif isinstance(current_volume, (int, float)):
            final_liquid_volume = current_volume
-
-    debug_print(f"干燥协议生成完成: {len(action_sequence)} 个动作, 体积 {original_liquid_volume:.2f} -> {final_liquid_volume:.2f}mL")
-
+    
+    print(f"\n🎊 DRY: 协议生成完成，共 {len(action_sequence)} 个动作 🎯")
+    print(f"⏱️ DRY: 预计总时间: {(simulation_time + 30)/60:.0f} 分钟 ⌛")
+    print(f"📊 干燥结果:")
+    print(f"  - 容器: {vessel_id}")
+    print(f"  - 化合物: {compound or '未指定'}")
+    print(f"  - 干燥前体积: {original_liquid_volume:.2f}mL")
+    print(f"  - 干燥后体积: {final_liquid_volume:.2f}mL")
+    print(f"  - 蒸发体积: {(original_liquid_volume - final_liquid_volume):.2f}mL")
+    print(f"🏁 所有动作序列准备就绪! ✨")
+    
    return action_sequence


-# 便捷函数
-def generate_quick_dry_protocol(G: nx.DiGraph, vessel: dict, compound: str = "",
+# 🔧 新增：便捷函数
+def generate_quick_dry_protocol(G: nx.DiGraph, vessel: dict, compound: str = "", 
                               temp: float = 40.0, time: float = 30.0) -> List[Dict[str, Any]]:
    """快速干燥：低温短时间"""
+    vessel_id = vessel["id"]
+    print(f"🌡️ 快速干燥: {compound or '化合物'} → {vessel_id} @ {temp}°C ({time}min)")
+    
+    # 临时修改默认参数
+    import types
+    temp_func = types.FunctionType(
+        generate_dry_protocol.__code__, 
+        generate_dry_protocol.__globals__
+    )
+    
+    # 直接调用原函数，但修改内部参数
    return generate_dry_protocol(G, vessel, compound)


-def generate_thorough_dry_protocol(G: nx.DiGraph, vessel: dict, compound: str = "",
+def generate_thorough_dry_protocol(G: nx.DiGraph, vessel: dict, compound: str = "", 
                                  temp: float = 80.0, time: float = 120.0) -> List[Dict[str, Any]]:
    """深度干燥：高温长时间"""
+    vessel_id = vessel["id"]
+    print(f"🔥 深度干燥: {compound or '化合物'} → {vessel_id} @ {temp}°C ({time}min)")
    return generate_dry_protocol(G, vessel, compound)


-def generate_gentle_dry_protocol(G: nx.DiGraph, vessel: dict, compound: str = "",
+def generate_gentle_dry_protocol(G: nx.DiGraph, vessel: dict, compound: str = "", 
                                temp: float = 30.0, time: float = 180.0) -> List[Dict[str, Any]]:
    """温和干燥：低温长时间"""
+    vessel_id = vessel["id"]
+    print(f"🌡️ 温和干燥: {compound or '化合物'} → {vessel_id} @ {temp}°C ({time}min)")
    return generate_dry_protocol(G, vessel, compound)


 # 测试函数
 def test_dry_protocol():
    """测试干燥协议"""
-    debug_print("=== DRY PROTOCOL 测试 ===")
-    debug_print("测试完成")
+    print("=== DRY PROTOCOL 测试 ===")
+    print("测试完成")


 if __name__ == "__main__":
-    test_dry_protocol()
+    test_dry_protocol()
--- a/unilabos/compile/evacuateandrefill_protocol.py
+++ b/unilabos/compile/evacuateandrefill_protocol.py
@@ -3,14 +3,38 @@ from functools import partial
 import networkx as nx
 import logging
 import uuid
+import sys
 from typing import List, Dict, Any, Optional
-from .utils.vessel_parser import get_vessel, find_connected_stirrer
-from .utils.logger_util import debug_print, action_log
+from .utils.vessel_parser import get_vessel
+from .utils.logger_util import action_log
 from .pump_protocol import generate_pump_protocol_with_rinsing, generate_pump_protocol

 # 设置日志
 logger = logging.getLogger(__name__)

+# 确保输出编码为UTF-8
+if hasattr(sys.stdout, 'reconfigure'):
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except:
+        pass
+
+def debug_print(message):
+    """调试输出函数 - 支持中文"""
+    try:
+        # 确保消息是字符串格式
+        safe_message = str(message)
+        logger.info(f"[抽真空充气] {safe_message}")
+    except UnicodeEncodeError:
+        # 如果编码失败，尝试替换不支持的字符
+        safe_message = str(message).encode('utf-8', errors='replace').decode('utf-8')
+        logger.info(f"[抽真空充气] {safe_message}")
+    except Exception as e:
+        # 最后的安全措施
+        fallback_message = f"日志输出错误: {repr(message)}"
+        logger.info(f"[抽真空充气] {fallback_message}")
+
 create_action_log = partial(action_log, prefix="[抽真空充气]")

 def find_gas_source(G: nx.DiGraph, gas: str) -> str:
@@ -20,9 +44,10 @@ def find_gas_source(G: nx.DiGraph, gas: str) -> str:
    2. 气体类型匹配（data.gas_type）
    3. 默认气源
    """
-    debug_print(f"正在查找气体 '{gas}' 的气源...")
-
-    # 通过容器名称匹配
+    debug_print(f"🔍 正在查找气体 '{gas}' 的气源...")
+    
+    # 第一步：通过容器名称匹配
+    debug_print(f"📋 方法1: 容器名称匹配...")
    gas_source_patterns = [
        f"gas_source_{gas}",
        f"gas_{gas}",
@@ -32,178 +57,254 @@ def find_gas_source(G: nx.DiGraph, gas: str) -> str:
        f"reagent_bottle_{gas}",
        f"bottle_{gas}"
    ]
-
+    
+    debug_print(f"🎯 尝试的容器名称: {gas_source_patterns}")
+    
    for pattern in gas_source_patterns:
        if pattern in G.nodes():
-            debug_print(f"通过名称找到气源: {pattern}")
+            debug_print(f"✅ 通过名称找到气源: {pattern}")
            return pattern
-
-    # 通过气体类型匹配 (data.gas_type)
+    
+    # 第二步：通过气体类型匹配 (data.gas_type)
+    debug_print(f"📋 方法2: 气体类型匹配...")
    for node_id in G.nodes():
        node_data = G.nodes[node_id]
        node_class = node_data.get('class', '') or ''
-
-        if ('gas_source' in node_class or
-            'gas' in node_id.lower() or
+        
+        # 检查是否是气源设备
+        if ('gas_source' in node_class or 
+            'gas' in node_id.lower() or 
            node_id.startswith('flask_')):
-
+            
+            # 检查 data.gas_type
            data = node_data.get('data', {})
            gas_type = data.get('gas_type', '')
-
+            
            if gas_type.lower() == gas.lower():
-                debug_print(f"通过气体类型找到气源: {node_id} (气体类型: {gas_type})")
+                debug_print(f"✅ 通过气体类型找到气源: {node_id} (气体类型: {gas_type})")
                return node_id
-
+            
+            # 检查 config.gas_type  
            config = node_data.get('config', {})
            config_gas_type = config.get('gas_type', '')
-
+            
            if config_gas_type.lower() == gas.lower():
-                debug_print(f"通过配置气体类型找到气源: {node_id} (配置气体类型: {config_gas_type})")
+                debug_print(f"✅ 通过配置气体类型找到气源: {node_id} (配置气体类型: {config_gas_type})")
                return node_id
-
-    # 查找所有可用的气源设备
+    
+    # 第三步：查找所有可用的气源设备
+    debug_print(f"📋 方法3: 查找可用气源...")
    available_gas_sources = []
    for node_id in G.nodes():
        node_data = G.nodes[node_id]
        node_class = node_data.get('class', '') or ''
-
-        if ('gas_source' in node_class or
+        
+        if ('gas_source' in node_class or 
            'gas' in node_id.lower() or
            (node_id.startswith('flask_') and any(g in node_id.lower() for g in ['air', 'nitrogen', 'argon']))):
-
+            
            data = node_data.get('data', {})
            gas_type = data.get('gas_type', '未知')
            available_gas_sources.append(f"{node_id} (气体类型: {gas_type})")
-
-    # 如果找不到特定气体，使用默认的第一个气源
+    
+    debug_print(f"📊 可用气源: {available_gas_sources}")
+    
+    # 第四步：如果找不到特定气体，使用默认的第一个气源
+    debug_print(f"📋 方法4: 查找默认气源...")
    default_gas_sources = [
-        node for node in G.nodes()
+        node for node in G.nodes() 
        if ((G.nodes[node].get('class') or '').find('virtual_gas_source') != -1
            or 'gas_source' in node)
    ]
-
+    
    if default_gas_sources:
        default_source = default_gas_sources[0]
-        debug_print(f"未找到特定气体 '{gas}'，使用默认气源: {default_source}")
+        debug_print(f"⚠️ 未找到特定气体 '{gas}'，使用默认气源: {default_source}")
        return default_source
-
+    
+    debug_print(f"❌ 所有方法都失败了！")
    raise ValueError(f"无法找到气体 '{gas}' 的气源。可用气源: {available_gas_sources}")

 def find_vacuum_pump(G: nx.DiGraph) -> str:
    """查找真空泵设备"""
+    debug_print("🔍 正在查找真空泵...")
+    
    vacuum_pumps = []
    for node in G.nodes():
        node_data = G.nodes[node]
        node_class = node_data.get('class', '') or ''
-
-        if ('virtual_vacuum_pump' in node_class or
-            'vacuum_pump' in node.lower() or
+        
+        if ('virtual_vacuum_pump' in node_class or 
+            'vacuum_pump' in node.lower() or 
            'vacuum' in node_class.lower()):
            vacuum_pumps.append(node)
-
+            debug_print(f"📋 发现真空泵: {node}")
+    
    if not vacuum_pumps:
+        debug_print(f"❌ 系统中未找到真空泵")
        raise ValueError("系统中未找到真空泵")
-
-    debug_print(f"使用真空泵: {vacuum_pumps[0]}")
+    
+    debug_print(f"✅ 使用真空泵: {vacuum_pumps[0]}")
    return vacuum_pumps[0]

+def find_connected_stirrer(G: nx.DiGraph, vessel: str) -> Optional[str]:
+    """查找与指定容器相连的搅拌器"""
+    debug_print(f"🔍 正在查找与容器 {vessel} 连接的搅拌器...")
+    
+    stirrer_nodes = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'virtual_stirrer' in node_class or 'stirrer' in node.lower():
+            stirrer_nodes.append(node)
+            debug_print(f"📋 发现搅拌器: {node}")
+    
+    debug_print(f"📊 找到的搅拌器总数: {len(stirrer_nodes)}")
+    
+    # 检查哪个搅拌器与目标容器相连
+    for stirrer in stirrer_nodes:
+        if G.has_edge(stirrer, vessel) or G.has_edge(vessel, stirrer):
+            debug_print(f"✅ 找到连接的搅拌器: {stirrer}")
+            return stirrer
+    
+    # 如果没有连接的搅拌器，返回第一个可用的
+    if stirrer_nodes:
+        debug_print(f"⚠️ 未找到直接连接的搅拌器，使用第一个可用的: {stirrer_nodes[0]}")
+        return stirrer_nodes[0]
+    
+    debug_print("❌ 未找到搅拌器")
+    return None
+
 def find_vacuum_solenoid_valve(G: nx.DiGraph, vacuum_pump: str) -> Optional[str]:
    """查找真空泵相关的电磁阀"""
+    debug_print(f"🔍 正在查找真空泵 {vacuum_pump} 的电磁阀...")
+    
+    # 查找所有电磁阀
    solenoid_valves = []
    for node in G.nodes():
        node_data = G.nodes[node]
        node_class = node_data.get('class', '') or ''
-
+        
        if ('solenoid' in node_class.lower() or 'solenoid_valve' in node.lower()):
            solenoid_valves.append(node)
-
+            debug_print(f"📋 发现电磁阀: {node}")
+    
+    debug_print(f"📊 找到的电磁阀: {solenoid_valves}")
+    
    # 检查连接关系
+    debug_print(f"📋 方法1: 检查连接关系...")
    for solenoid in solenoid_valves:
        if G.has_edge(solenoid, vacuum_pump) or G.has_edge(vacuum_pump, solenoid):
-            debug_print(f"找到连接的真空电磁阀: {solenoid}")
+            debug_print(f"✅ 找到连接的真空电磁阀: {solenoid}")
            return solenoid
-
+    
    # 通过命名规则查找
+    debug_print(f"📋 方法2: 检查命名规则...")
    for solenoid in solenoid_valves:
        if 'vacuum' in solenoid.lower() or solenoid == 'solenoid_valve_1':
-            debug_print(f"通过命名找到真空电磁阀: {solenoid}")
+            debug_print(f"✅ 通过命名找到真空电磁阀: {solenoid}")
            return solenoid
-
-    debug_print("未找到真空电磁阀")
+    
+    debug_print("⚠️ 未找到真空电磁阀")
    return None

 def find_gas_solenoid_valve(G: nx.DiGraph, gas_source: str) -> Optional[str]:
    """查找气源相关的电磁阀"""
+    debug_print(f"🔍 正在查找气源 {gas_source} 的电磁阀...")
+    
+    # 查找所有电磁阀
    solenoid_valves = []
    for node in G.nodes():
        node_data = G.nodes[node]
        node_class = node_data.get('class', '') or ''
-
+        
        if ('solenoid' in node_class.lower() or 'solenoid_valve' in node.lower()):
            solenoid_valves.append(node)
-
+    
+    debug_print(f"📊 找到的电磁阀: {solenoid_valves}")
+    
    # 检查连接关系
+    debug_print(f"📋 方法1: 检查连接关系...")
    for solenoid in solenoid_valves:
        if G.has_edge(gas_source, solenoid) or G.has_edge(solenoid, gas_source):
-            debug_print(f"找到连接的气源电磁阀: {solenoid}")
+            debug_print(f"✅ 找到连接的气源电磁阀: {solenoid}")
            return solenoid
-
+    
    # 通过命名规则查找
+    debug_print(f"📋 方法2: 检查命名规则...")
    for solenoid in solenoid_valves:
        if 'gas' in solenoid.lower() or solenoid == 'solenoid_valve_2':
-            debug_print(f"通过命名找到气源电磁阀: {solenoid}")
+            debug_print(f"✅ 通过命名找到气源电磁阀: {solenoid}")
            return solenoid
-
-    debug_print("未找到气源电磁阀")
+    
+    debug_print("⚠️ 未找到气源电磁阀")
    return None

 def generate_evacuateandrefill_protocol(
    G: nx.DiGraph,
-    vessel: dict,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
    gas: str,
    **kwargs
 ) -> List[Dict[str, Any]]:
    """
-    生成抽真空和充气操作的动作序列
-
+    生成抽真空和充气操作的动作序列 - 中文版
+    
    Args:
        G: 设备图
        vessel: 目标容器字典（必需）
-        gas: 气体名称（必需）
+        gas: 气体名称（必需）  
        **kwargs: 其他参数（兼容性）
-
+    
    Returns:
        List[Dict[str, Any]]: 动作序列
    """
-
+    
+    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, vessel_data = get_vessel(vessel)
-
+    
    # 硬编码重复次数为 3
    repeats = 3
-
+    
+    # 生成协议ID
    protocol_id = str(uuid.uuid4())
-
-    debug_print(f"开始生成抽真空充气协议: vessel={vessel_id}, gas={gas}, repeats={repeats}")
-
+    debug_print(f"🆔 生成协议ID: {protocol_id}")
+    
+    debug_print("=" * 60)
+    debug_print("🧪 开始生成抽真空充气协议")
+    debug_print(f"📋 原始参数:")
+    debug_print(f"  🥼 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  💨 气体: '{gas}'")
+    debug_print(f"  🔄 循环次数: {repeats} (硬编码)")
+    debug_print(f"  📦 其他参数: {kwargs}")
+    debug_print("=" * 60)
+    
    action_sequence = []
-
+    
    # === 参数验证和修正 ===
+    debug_print("🔍 步骤1: 参数验证和修正...")
    action_sequence.append(create_action_log(f"开始抽真空充气操作 - 容器: {vessel_id}", "🎬"))
    action_sequence.append(create_action_log(f"目标气体: {gas}", "💨"))
    action_sequence.append(create_action_log(f"循环次数: {repeats}", "🔄"))
-
+    
+    # 验证必需参数
    if not vessel_id:
+        debug_print("❌ 容器参数不能为空")
        raise ValueError("容器参数不能为空")
-
+    
    if not gas:
+        debug_print("❌ 气体参数不能为空")
        raise ValueError("气体参数不能为空")
-
-    if vessel_id not in G.nodes():
+    
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print(f"❌ 容器 '{vessel_id}' 在系统中不存在")
        raise ValueError(f"容器 '{vessel_id}' 在系统中不存在")
-
+    
+    debug_print("✅ 基本参数验证通过")
    action_sequence.append(create_action_log("参数验证通过", "✅"))
-
+    
    # 标准化气体名称
+    debug_print("🔧 标准化气体名称...")
    gas_aliases = {
        'n2': 'nitrogen',
        'ar': 'argon',
@@ -218,54 +319,61 @@ def generate_evacuateandrefill_protocol(
        '二氧化碳': 'carbon_dioxide',
        '氢气': 'hydrogen'
    }
-
+    
    original_gas = gas
    gas_lower = gas.lower().strip()
    if gas_lower in gas_aliases:
        gas = gas_aliases[gas_lower]
-        debug_print(f"标准化气体名称: {original_gas} -> {gas}")
+        debug_print(f"🔄 标准化气体名称: {original_gas} -> {gas}")
        action_sequence.append(create_action_log(f"气体名称标准化: {original_gas} -> {gas}", "🔄"))
-
-    debug_print(f"最终参数: 容器={vessel_id}, 气体={gas}, 重复={repeats}")
-
+    
+    debug_print(f"📋 最终参数: 容器={vessel_id}, 气体={gas}, 重复={repeats}")
+    
    # === 查找设备 ===
+    debug_print("🔍 步骤2: 查找设备...")
    action_sequence.append(create_action_log("正在查找相关设备...", "🔍"))
-
+    
    try:
        vacuum_pump = find_vacuum_pump(G)
        action_sequence.append(create_action_log(f"找到真空泵: {vacuum_pump}", "🌪️"))
-
+        
        gas_source = find_gas_source(G, gas)
        action_sequence.append(create_action_log(f"找到气源: {gas_source}", "💨"))
-
+        
        vacuum_solenoid = find_vacuum_solenoid_valve(G, vacuum_pump)
        if vacuum_solenoid:
            action_sequence.append(create_action_log(f"找到真空电磁阀: {vacuum_solenoid}", "🚪"))
        else:
            action_sequence.append(create_action_log("未找到真空电磁阀", "⚠️"))
-
+        
        gas_solenoid = find_gas_solenoid_valve(G, gas_source)
        if gas_solenoid:
            action_sequence.append(create_action_log(f"找到气源电磁阀: {gas_solenoid}", "🚪"))
        else:
            action_sequence.append(create_action_log("未找到气源电磁阀", "⚠️"))
-
-        stirrer_id = find_connected_stirrer(G, vessel_id)
+        
+        stirrer_id = find_connected_stirrer(G, vessel_id)  # 🔧 使用 vessel_id
        if stirrer_id:
            action_sequence.append(create_action_log(f"找到搅拌器: {stirrer_id}", "🌪️"))
        else:
            action_sequence.append(create_action_log("未找到搅拌器", "⚠️"))
-
-        debug_print(f"设备配置: 真空泵={vacuum_pump}, 气源={gas_source}, 搅拌器={stirrer_id}")
-
+        
+        debug_print(f"📊 设备配置:")
+        debug_print(f"  🌪️ 真空泵: {vacuum_pump}")
+        debug_print(f"  💨 气源: {gas_source}")
+        debug_print(f"  🚪 真空电磁阀: {vacuum_solenoid}")
+        debug_print(f"  🚪 气源电磁阀: {gas_solenoid}")
+        debug_print(f"  🌪️ 搅拌器: {stirrer_id}")
+        
    except Exception as e:
-        debug_print(f"设备查找失败: {str(e)}")
+        debug_print(f"❌ 设备查找失败: {str(e)}")
        action_sequence.append(create_action_log(f"设备查找失败: {str(e)}", "❌"))
        raise ValueError(f"设备查找失败: {str(e)}")
-
+    
    # === 参数设置 ===
+    debug_print("🔍 步骤3: 参数设置...")
    action_sequence.append(create_action_log("设置操作参数...", "⚙️"))
-
+    
    # 根据气体类型调整参数
    if gas.lower() in ['nitrogen', 'argon']:
        VACUUM_VOLUME = 25.0
@@ -273,6 +381,7 @@ def generate_evacuateandrefill_protocol(
        PUMP_FLOW_RATE = 2.0
        VACUUM_TIME = 30.0
        REFILL_TIME = 20.0
+        debug_print("💨 惰性气体: 使用标准参数")
        action_sequence.append(create_action_log("检测到惰性气体，使用标准参数", "💨"))
    elif gas.lower() in ['air', 'oxygen']:
        VACUUM_VOLUME = 20.0
@@ -280,6 +389,7 @@ def generate_evacuateandrefill_protocol(
        PUMP_FLOW_RATE = 1.5
        VACUUM_TIME = 45.0
        REFILL_TIME = 25.0
+        debug_print("🔥 活性气体: 使用保守参数")
        action_sequence.append(create_action_log("检测到活性气体，使用保守参数", "🔥"))
    else:
        VACUUM_VOLUME = 15.0
@@ -287,88 +397,116 @@ def generate_evacuateandrefill_protocol(
        PUMP_FLOW_RATE = 1.0
        VACUUM_TIME = 60.0
        REFILL_TIME = 30.0
+        debug_print("❓ 未知气体: 使用安全参数")
        action_sequence.append(create_action_log("未知气体类型，使用安全参数", "❓"))
-
+    
    STIR_SPEED = 200.0
-
+    
+    debug_print(f"⚙️ 操作参数:")
+    debug_print(f"  📏 真空体积: {VACUUM_VOLUME}mL")
+    debug_print(f"  📏 充气体积: {REFILL_VOLUME}mL")
+    debug_print(f"  ⚡ 泵流速: {PUMP_FLOW_RATE}mL/s")
+    debug_print(f"  ⏱️ 真空时间: {VACUUM_TIME}s")
+    debug_print(f"  ⏱️ 充气时间: {REFILL_TIME}s")
+    debug_print(f"  🌪️ 搅拌速度: {STIR_SPEED}RPM")
+    
    action_sequence.append(create_action_log(f"真空体积: {VACUUM_VOLUME}mL", "📏"))
    action_sequence.append(create_action_log(f"充气体积: {REFILL_VOLUME}mL", "📏"))
    action_sequence.append(create_action_log(f"泵流速: {PUMP_FLOW_RATE}mL/s", "⚡"))
-
+    
    # === 路径验证 ===
+    debug_print("🔍 步骤4: 路径验证...")
    action_sequence.append(create_action_log("验证传输路径...", "🛤️"))
-
+    
    try:
-        if nx.has_path(G, vessel_id, vacuum_pump):
+        # 验证抽真空路径
+        if nx.has_path(G, vessel_id, vacuum_pump):  # 🔧 使用 vessel_id
            vacuum_path = nx.shortest_path(G, source=vessel_id, target=vacuum_pump)
+            debug_print(f"✅ 真空路径: {' -> '.join(vacuum_path)}")
            action_sequence.append(create_action_log(f"真空路径: {' -> '.join(vacuum_path)}", "🛤️"))
        else:
+            debug_print(f"⚠️ 真空路径不存在，继续执行但可能有问题")
            action_sequence.append(create_action_log("真空路径检查: 路径不存在", "⚠️"))
-
-        if nx.has_path(G, gas_source, vessel_id):
+        
+        # 验证充气路径
+        if nx.has_path(G, gas_source, vessel_id):  # 🔧 使用 vessel_id
            gas_path = nx.shortest_path(G, source=gas_source, target=vessel_id)
+            debug_print(f"✅ 气体路径: {' -> '.join(gas_path)}")
            action_sequence.append(create_action_log(f"气体路径: {' -> '.join(gas_path)}", "🛤️"))
        else:
+            debug_print(f"⚠️ 气体路径不存在，继续执行但可能有问题")
            action_sequence.append(create_action_log("气体路径检查: 路径不存在", "⚠️"))
-
+        
    except Exception as e:
+        debug_print(f"⚠️ 路径验证失败: {str(e)}，继续执行")
        action_sequence.append(create_action_log(f"路径验证失败: {str(e)}", "⚠️"))
-
+    
    # === 启动搅拌器 ===
+    debug_print("🔍 步骤5: 启动搅拌器...")
+    
    if stirrer_id:
+        debug_print(f"🌪️ 启动搅拌器: {stirrer_id}")
        action_sequence.append(create_action_log(f"启动搅拌器 {stirrer_id} (速度: {STIR_SPEED}rpm)", "🌪️"))
-
+        
        action_sequence.append({
            "device_id": stirrer_id,
            "action_name": "start_stir",
            "action_kwargs": {
-                "vessel": {"id": vessel_id},
+                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
                "stir_speed": STIR_SPEED,
                "purpose": "抽真空充气前预搅拌"
            }
        })
-
+        
+        # 等待搅拌稳定
        action_sequence.append(create_action_log("等待搅拌稳定...", "⏳"))
        action_sequence.append({
            "action_name": "wait",
            "action_kwargs": {"time": 5.0}
        })
    else:
+        debug_print("⚠️ 未找到搅拌器，跳过搅拌器启动")
        action_sequence.append(create_action_log("跳过搅拌器启动", "⏭️"))
-
+    
    # === 执行循环 ===
+    debug_print("🔍 步骤6: 执行抽真空-充气循环...")
    action_sequence.append(create_action_log(f"开始 {repeats} 次抽真空-充气循环", "🔄"))
-
+    
    for cycle in range(repeats):
+        debug_print(f"=== 第 {cycle+1}/{repeats} 轮循环 ===")
        action_sequence.append(create_action_log(f"第 {cycle+1}/{repeats} 轮循环开始", "🚀"))
-
+        
        # ============ 抽真空阶段 ============
+        debug_print(f"🌪️ 抽真空阶段开始")
        action_sequence.append(create_action_log("开始抽真空阶段", "🌪️"))
-
+        
        # 启动真空泵
+        debug_print(f"🔛 启动真空泵: {vacuum_pump}")
        action_sequence.append(create_action_log(f"启动真空泵: {vacuum_pump}", "🔛"))
        action_sequence.append({
            "device_id": vacuum_pump,
            "action_name": "set_status",
            "action_kwargs": {"string": "ON"}
        })
-
+        
        # 开启真空电磁阀
        if vacuum_solenoid:
+            debug_print(f"🚪 打开真空电磁阀: {vacuum_solenoid}")
            action_sequence.append(create_action_log(f"打开真空电磁阀: {vacuum_solenoid}", "🚪"))
            action_sequence.append({
                "device_id": vacuum_solenoid,
                "action_name": "set_valve_position",
                "action_kwargs": {"command": "OPEN"}
            })
-
+        
        # 抽真空操作
+        debug_print(f"🌪️ 抽真空操作: {vessel_id} -> {vacuum_pump}")
        action_sequence.append(create_action_log(f"开始抽真空: {vessel_id} -> {vacuum_pump}", "🌪️"))
-
+        
        try:
            vacuum_transfer_actions = generate_pump_protocol_with_rinsing(
                G=G,
-                from_vessel=vessel_id,
+                from_vessel=vessel_id,  # 🔧 使用 vessel_id
                to_vessel=vacuum_pump,
                volume=VACUUM_VOLUME,
                amount="",
@@ -381,25 +519,27 @@ def generate_evacuateandrefill_protocol(
                flowrate=PUMP_FLOW_RATE,
                transfer_flowrate=PUMP_FLOW_RATE
            )
-
+            
            if vacuum_transfer_actions:
                action_sequence.extend(vacuum_transfer_actions)
+                debug_print(f"✅ 添加了 {len(vacuum_transfer_actions)} 个抽真空动作")
                action_sequence.append(create_action_log(f"抽真空协议完成 ({len(vacuum_transfer_actions)} 个操作)", "✅"))
            else:
+                debug_print("⚠️ 抽真空协议返回空序列，添加手动动作")
                action_sequence.append(create_action_log("抽真空协议为空，使用手动等待", "⚠️"))
                action_sequence.append({
                    "action_name": "wait",
                    "action_kwargs": {"time": VACUUM_TIME}
                })
-
+                
        except Exception as e:
-            debug_print(f"抽真空失败: {str(e)}")
+            debug_print(f"❌ 抽真空失败: {str(e)}")
            action_sequence.append(create_action_log(f"抽真空失败: {str(e)}", "❌"))
            action_sequence.append({
                "action_name": "wait",
                "action_kwargs": {"time": VACUUM_TIME}
            })
-
+        
        # 抽真空后等待
        wait_minutes = VACUUM_TIME / 60
        action_sequence.append(create_action_log(f"抽真空后等待 ({wait_minutes:.1f} 分钟)", "⏳"))
@@ -407,59 +547,65 @@ def generate_evacuateandrefill_protocol(
            "action_name": "wait",
            "action_kwargs": {"time": VACUUM_TIME}
        })
-
+        
        # 关闭真空电磁阀
        if vacuum_solenoid:
+            debug_print(f"🚪 关闭真空电磁阀: {vacuum_solenoid}")
            action_sequence.append(create_action_log(f"关闭真空电磁阀: {vacuum_solenoid}", "🚪"))
            action_sequence.append({
                "device_id": vacuum_solenoid,
                "action_name": "set_valve_position",
                "action_kwargs": {"command": "CLOSED"}
            })
-
+        
        # 关闭真空泵
+        debug_print(f"🔴 停止真空泵: {vacuum_pump}")
        action_sequence.append(create_action_log(f"停止真空泵: {vacuum_pump}", "🔴"))
        action_sequence.append({
            "device_id": vacuum_pump,
            "action_name": "set_status",
            "action_kwargs": {"string": "OFF"}
        })
-
+        
        # 阶段间等待
        action_sequence.append(create_action_log("抽真空阶段完成，短暂等待", "⏳"))
        action_sequence.append({
            "action_name": "wait",
            "action_kwargs": {"time": 5.0}
        })
-
+        
        # ============ 充气阶段 ============
+        debug_print(f"💨 充气阶段开始")
        action_sequence.append(create_action_log("开始气体充气阶段", "💨"))
-
+        
        # 启动气源
+        debug_print(f"🔛 启动气源: {gas_source}")
        action_sequence.append(create_action_log(f"启动气源: {gas_source}", "🔛"))
        action_sequence.append({
            "device_id": gas_source,
            "action_name": "set_status",
            "action_kwargs": {"string": "ON"}
        })
-
+        
        # 开启气源电磁阀
        if gas_solenoid:
+            debug_print(f"🚪 打开气源电磁阀: {gas_solenoid}")
            action_sequence.append(create_action_log(f"打开气源电磁阀: {gas_solenoid}", "🚪"))
            action_sequence.append({
                "device_id": gas_solenoid,
                "action_name": "set_valve_position",
                "action_kwargs": {"command": "OPEN"}
            })
-
+        
        # 充气操作
+        debug_print(f"💨 充气操作: {gas_source} -> {vessel_id}")
        action_sequence.append(create_action_log(f"开始气体充气: {gas_source} -> {vessel_id}", "💨"))
-
+        
        try:
            gas_transfer_actions = generate_pump_protocol_with_rinsing(
                G=G,
                from_vessel=gas_source,
-                to_vessel=vessel_id,
+                to_vessel=vessel_id,  # 🔧 使用 vessel_id
                volume=REFILL_VOLUME,
                amount="",
                time=0.0,
@@ -471,25 +617,27 @@ def generate_evacuateandrefill_protocol(
                flowrate=PUMP_FLOW_RATE,
                transfer_flowrate=PUMP_FLOW_RATE
            )
-
+            
            if gas_transfer_actions:
                action_sequence.extend(gas_transfer_actions)
+                debug_print(f"✅ 添加了 {len(gas_transfer_actions)} 个充气动作")
                action_sequence.append(create_action_log(f"气体充气协议完成 ({len(gas_transfer_actions)} 个操作)", "✅"))
            else:
+                debug_print("⚠️ 充气协议返回空序列，添加手动动作")
                action_sequence.append(create_action_log("充气协议为空，使用手动等待", "⚠️"))
                action_sequence.append({
                    "action_name": "wait",
                    "action_kwargs": {"time": REFILL_TIME}
                })
-
+                
        except Exception as e:
-            debug_print(f"气体充气失败: {str(e)}")
+            debug_print(f"❌ 气体充气失败: {str(e)}")
            action_sequence.append(create_action_log(f"气体充气失败: {str(e)}", "❌"))
            action_sequence.append({
                "action_name": "wait",
                "action_kwargs": {"time": REFILL_TIME}
            })
-
+        
        # 充气后等待
        refill_wait_minutes = REFILL_TIME / 60
        action_sequence.append(create_action_log(f"充气后等待 ({refill_wait_minutes:.1f} 分钟)", "⏳"))
@@ -497,26 +645,29 @@ def generate_evacuateandrefill_protocol(
            "action_name": "wait",
            "action_kwargs": {"time": REFILL_TIME}
        })
-
+        
        # 关闭气源电磁阀
        if gas_solenoid:
+            debug_print(f"🚪 关闭气源电磁阀: {gas_solenoid}")
            action_sequence.append(create_action_log(f"关闭气源电磁阀: {gas_solenoid}", "🚪"))
            action_sequence.append({
                "device_id": gas_solenoid,
                "action_name": "set_valve_position",
                "action_kwargs": {"command": "CLOSED"}
            })
-
+        
        # 关闭气源
+        debug_print(f"🔴 停止气源: {gas_source}")
        action_sequence.append(create_action_log(f"停止气源: {gas_source}", "🔴"))
        action_sequence.append({
            "device_id": gas_source,
            "action_name": "set_status",
            "action_kwargs": {"string": "OFF"}
        })
-
+        
        # 循环间等待
        if cycle < repeats - 1:
+            debug_print(f"⏳ 等待下一个循环...")
            action_sequence.append(create_action_log("等待下一个循环...", "⏳"))
            action_sequence.append({
                "action_name": "wait",
@@ -524,58 +675,78 @@ def generate_evacuateandrefill_protocol(
            })
        else:
            action_sequence.append(create_action_log(f"第 {cycle+1}/{repeats} 轮循环完成", "✅"))
-
+    
    # === 停止搅拌器 ===
+    debug_print("🔍 步骤7: 停止搅拌器...")
+    
    if stirrer_id:
+        debug_print(f"🛑 停止搅拌器: {stirrer_id}")
        action_sequence.append(create_action_log(f"停止搅拌器: {stirrer_id}", "🛑"))
        action_sequence.append({
            "device_id": stirrer_id,
            "action_name": "stop_stir",
-            "action_kwargs": {"vessel": {"id": vessel_id},}
+            "action_kwargs": {"vessel": {"id": vessel_id},}  # 🔧 使用 vessel_id
        })
    else:
        action_sequence.append(create_action_log("跳过搅拌器停止", "⏭️"))
-
+    
    # === 最终等待 ===
    action_sequence.append(create_action_log("最终稳定等待...", "⏳"))
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {"time": 10.0}
    })
-
+    
    # === 总结 ===
    total_time = (VACUUM_TIME + REFILL_TIME + 25) * repeats + 20
-
-    debug_print(f"抽真空充气协议生成完成: {len(action_sequence)} 个动作, 预计 {total_time:.0f}s")
-
+    
+    debug_print("=" * 60)
+    debug_print(f"🎉 抽真空充气协议生成完成")
+    debug_print(f"📊 协议统计:")
+    debug_print(f"  📋 总动作数: {len(action_sequence)}")
+    debug_print(f"  ⏱️ 预计总时间: {total_time:.0f}s ({total_time/60:.1f} 分钟)")
+    debug_print(f"  🥼 处理容器: {vessel_id}")
+    debug_print(f"  💨 使用气体: {gas}")
+    debug_print(f"  🔄 重复次数: {repeats}")
+    debug_print("=" * 60)
+    
+    # 添加完成日志
    summary_msg = f"抽真空充气协议完成: {vessel_id} (使用 {gas}，{repeats} 次循环)"
    action_sequence.append(create_action_log(summary_msg, "🎉"))
-
+    
    return action_sequence

 # === 便捷函数 ===

-def generate_nitrogen_purge_protocol(G: nx.DiGraph, vessel: dict, **kwargs) -> List[Dict[str, Any]]:
+def generate_nitrogen_purge_protocol(G: nx.DiGraph, vessel: dict, **kwargs) -> List[Dict[str, Any]]:  # 🔧 修改参数类型
    """生成氮气置换协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"💨 生成氮气置换协议: {vessel_id}")
    return generate_evacuateandrefill_protocol(G, vessel, "nitrogen", **kwargs)

-def generate_argon_purge_protocol(G: nx.DiGraph, vessel: dict, **kwargs) -> List[Dict[str, Any]]:
+def generate_argon_purge_protocol(G: nx.DiGraph, vessel: dict, **kwargs) -> List[Dict[str, Any]]:  # 🔧 修改参数类型
    """生成氩气置换协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"💨 生成氩气置换协议: {vessel_id}")
    return generate_evacuateandrefill_protocol(G, vessel, "argon", **kwargs)

-def generate_air_purge_protocol(G: nx.DiGraph, vessel: dict, **kwargs) -> List[Dict[str, Any]]:
+def generate_air_purge_protocol(G: nx.DiGraph, vessel: dict, **kwargs) -> List[Dict[str, Any]]:  # 🔧 修改参数类型
    """生成空气置换协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"💨 生成空气置换协议: {vessel_id}")
    return generate_evacuateandrefill_protocol(G, vessel, "air", **kwargs)

-def generate_inert_atmosphere_protocol(G: nx.DiGraph, vessel: dict, gas: str = "nitrogen", **kwargs) -> List[Dict[str, Any]]:
+def generate_inert_atmosphere_protocol(G: nx.DiGraph, vessel: dict, gas: str = "nitrogen", **kwargs) -> List[Dict[str, Any]]:  # 🔧 修改参数类型
    """生成惰性气氛协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"🛡️ 生成惰性气氛协议: {vessel_id} (使用 {gas})")
    return generate_evacuateandrefill_protocol(G, vessel, gas, **kwargs)

 # 测试函数
 def test_evacuateandrefill_protocol():
    """测试抽真空充气协议"""
-    debug_print("=== 抽真空充气协议测试 ===")
-    debug_print("测试完成")
+    debug_print("=== 抽真空充气协议增强中文版测试 ===")
+    debug_print("✅ 测试完成")

 if __name__ == "__main__":
-    test_evacuateandrefill_protocol()
+    test_evacuateandrefill_protocol()
--- a/unilabos/compile/evacuateandrefill_protocol_old.py
+++ b/unilabos/compile/evacuateandrefill_protocol_old.py
@@ -0,0 +1,143 @@
+# import numpy as np
+# import networkx as nx
+
+
+# def generate_evacuateandrefill_protocol(
+#     G: nx.DiGraph, 
+#     vessel: str, 
+#     gas: str, 
+#     repeats: int = 1
+# ) -> list[dict]:
+#     """
+#     生成泵操作的动作序列。
+    
+#     :param G: 有向图, 节点为容器和注射泵, 边为流体管道, A→B边的属性为管道接A端的阀门位置
+#     :param from_vessel: 容器A
+#     :param to_vessel: 容器B
+#     :param volume: 转移的体积
+#     :param flowrate: 最终注入容器B时的流速
+#     :param transfer_flowrate: 泵骨架中转移流速（若不指定，默认与注入流速相同）
+#     :return: 泵操作的动作序列
+#     """
+    
+#     # 生成电磁阀、真空泵、气源操作的动作序列
+#     vacuum_action_sequence = []
+#     nodes = G.nodes(data=True)
+    
+#     # 找到和 vessel 相连的电磁阀和真空泵、气源
+#     vacuum_backbone = {"vessel": vessel}
+    
+#     for neighbor in G.neighbors(vessel):
+#         if nodes[neighbor]["class"].startswith("solenoid_valve"):
+#             for neighbor2 in G.neighbors(neighbor):
+#                 if neighbor2 == vessel:
+#                     continue
+#                 if nodes[neighbor2]["class"].startswith("vacuum_pump"):
+#                     vacuum_backbone.update({"vacuum_valve": neighbor, "pump": neighbor2})
+#                     break
+#                 elif nodes[neighbor2]["class"].startswith("gas_source"):
+#                     vacuum_backbone.update({"gas_valve": neighbor, "gas": neighbor2})
+#                     break
+#     # 判断是否设备齐全
+#     if len(vacuum_backbone) < 5:
+#         print(f"\n\n\n{vacuum_backbone}\n\n\n")
+#         raise ValueError("Not all devices are connected to the vessel.")
+    
+#     # 生成操作的动作序列
+#     for i in range(repeats):
+#         # 打开真空泵阀门、关闭气源阀门
+#         vacuum_action_sequence.append([
+#             {
+#                 "device_id": vacuum_backbone["vacuum_valve"],
+#                 "action_name": "set_valve_position",
+#                 "action_kwargs": {
+#                     "command": "OPEN"
+#                 }
+#             },
+#             {
+#                 "device_id": vacuum_backbone["gas_valve"],
+#                 "action_name": "set_valve_position",
+#                 "action_kwargs": {
+#                     "command": "CLOSED"
+#                 }
+#             }
+#         ])
+        
+#         # 打开真空泵、关闭气源
+#         vacuum_action_sequence.append([
+#             {
+#                 "device_id": vacuum_backbone["pump"],
+#                 "action_name": "set_status",
+#                 "action_kwargs": {
+#                     "string": "ON"
+#                 }
+#             },
+#             {
+#                 "device_id": vacuum_backbone["gas"],
+#                 "action_name": "set_status",
+#                 "action_kwargs": {
+#                     "string": "OFF"
+#                 }
+#             }
+#         ])
+#         vacuum_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 60}})
+        
+#         # 关闭真空泵阀门、打开气源阀门
+#         vacuum_action_sequence.append([
+#             {
+#                 "device_id": vacuum_backbone["vacuum_valve"],
+#                 "action_name": "set_valve_position",
+#                 "action_kwargs": {
+#                     "command": "CLOSED"
+#                 }
+#             },
+#             {
+#                 "device_id": vacuum_backbone["gas_valve"],
+#                 "action_name": "set_valve_position",
+#                 "action_kwargs": {
+#                     "command": "OPEN"
+#                 }
+#             }
+#         ])
+        
+#         # 关闭真空泵、打开气源
+#         vacuum_action_sequence.append([
+#             {
+#                 "device_id": vacuum_backbone["pump"],
+#                 "action_name": "set_status",
+#                 "action_kwargs": {
+#                     "string": "OFF"
+#                 }
+#             },
+#             {
+#                 "device_id": vacuum_backbone["gas"],
+#                 "action_name": "set_status",
+#                 "action_kwargs": {
+#                     "string": "ON"
+#                 }
+#             }
+#         ])
+#         vacuum_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 60}})
+        
+#         # 关闭气源
+#         vacuum_action_sequence.append(
+#             {
+#                 "device_id": vacuum_backbone["gas"],
+#                 "action_name": "set_status",
+#                 "action_kwargs": {
+#                     "string": "OFF"
+#                 }
+#             }
+#         )
+        
+#         # 关闭阀门
+#         vacuum_action_sequence.append(
+#             {
+#                 "device_id": vacuum_backbone["gas_valve"],
+#                 "action_name": "set_valve_position",
+#                 "action_kwargs": {
+#                     "command": "CLOSED"
+#                 }
+#             }
+#         )
+#     return vacuum_action_sequence
--- a/unilabos/compile/evaporate_protocol.py
+++ b/unilabos/compile/evaporate_protocol.py
@@ -4,99 +4,128 @@ import logging
 import re
 from .utils.vessel_parser import get_vessel
 from .utils.unit_parser import parse_time_input
-from .utils.logger_util import debug_print

 logger = logging.getLogger(__name__)

+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[EVAPORATE] {message}")
+

 def find_rotavap_device(G: nx.DiGraph, vessel: str = None) -> Optional[str]:
    """
    在组态图中查找旋转蒸发仪设备
-
+    
    Args:
        G: 设备图
        vessel: 指定的设备名称（可选）
-
+    
    Returns:
        str: 找到的旋转蒸发仪设备ID，如果没找到返回None
    """
+    debug_print("🔍 开始查找旋转蒸发仪设备... 🌪️")
+    
    # 如果指定了vessel，先检查是否存在且是旋转蒸发仪
    if vessel:
+        debug_print(f"🎯 检查指定设备: {vessel} 🔧")
        if vessel in G.nodes():
            node_data = G.nodes[vessel]
            node_class = node_data.get('class', '')
            node_type = node_data.get('type', '')
-
+            
+            debug_print(f"📋 设备信息 {vessel}: class={node_class}, type={node_type}")
+            
+            # 检查是否为旋转蒸发仪
            if any(keyword in str(node_class).lower() for keyword in ['rotavap', 'rotary', 'evaporat']):
-                debug_print(f"找到指定的旋转蒸发仪: {vessel}")
+                debug_print(f"🎉 找到指定的旋转蒸发仪: {vessel} ✨")
                return vessel
            elif node_type == 'device':
-                debug_print(f"指定设备存在，尝试直接使用: {vessel}")
+                debug_print(f"✅ 指定设备存在，尝试直接使用: {vessel} 🔧")
                return vessel
-
+        else:
+            debug_print(f"❌ 指定的设备 {vessel} 不存在 😞")
+    
    # 在所有设备中查找旋转蒸发仪
+    debug_print("🔎 在所有设备中搜索旋转蒸发仪... 🕵️‍♀️")
    rotavap_candidates = []
-
+    
    for node_id, node_data in G.nodes(data=True):
        node_class = node_data.get('class', '')
        node_type = node_data.get('type', '')
-
+        
+        # 跳过非设备节点
        if node_type != 'device':
            continue
-
+            
+        # 检查设备类型
        if any(keyword in str(node_class).lower() for keyword in ['rotavap', 'rotary', 'evaporat']):
            rotavap_candidates.append(node_id)
+            debug_print(f"🌟 找到旋转蒸发仪候选: {node_id} (class: {node_class}) 🌪️")
        elif any(keyword in str(node_id).lower() for keyword in ['rotavap', 'rotary', 'evaporat']):
            rotavap_candidates.append(node_id)
-
+            debug_print(f"🌟 找到旋转蒸发仪候选 (按名称): {node_id} 🌪️")
+    
    if rotavap_candidates:
-        selected = rotavap_candidates[0]
-        debug_print(f"选择旋转蒸发仪: {selected}")
+        selected = rotavap_candidates[0]  # 选择第一个找到的
+        debug_print(f"🎯 选择旋转蒸发仪: {selected} 🏆")
        return selected
-
-    debug_print("未找到旋转蒸发仪设备")
+    
+    debug_print("😭 未找到旋转蒸发仪设备 💔")
    return None

 def find_connected_vessel(G: nx.DiGraph, rotavap_device: str) -> Optional[str]:
    """
    查找与旋转蒸发仪连接的容器
+    
+    Args:
+        G: 设备图
+        rotavap_device: 旋转蒸发仪设备ID
+    
+    Returns:
+        str: 连接的容器ID，如果没找到返回None
    """
+    debug_print(f"🔗 查找与 {rotavap_device} 连接的容器... 🥽")
+    
+    # 查看旋转蒸发仪的子设备
    rotavap_data = G.nodes[rotavap_device]
    children = rotavap_data.get('children', [])
-
+    
+    debug_print(f"👶 检查子设备: {children}")
    for child_id in children:
        if child_id in G.nodes():
            child_data = G.nodes[child_id]
            child_type = child_data.get('type', '')
-
+            
            if child_type == 'container':
-                debug_print(f"找到连接的容器: {child_id}")
+                debug_print(f"🎉 找到连接的容器: {child_id} 🥽✨")
                return child_id
-
+    
+    # 查看邻接的容器
+    debug_print("🤝 检查邻接设备...")
    for neighbor in G.neighbors(rotavap_device):
        neighbor_data = G.nodes[neighbor]
        neighbor_type = neighbor_data.get('type', '')
-
+        
        if neighbor_type == 'container':
-            debug_print(f"找到邻接的容器: {neighbor}")
+            debug_print(f"🎉 找到邻接的容器: {neighbor} 🥽✨")
            return neighbor
-
-    debug_print("未找到连接的容器")
+    
+    debug_print("😞 未找到连接的容器 💔")
    return None

 def generate_evaporate_protocol(
    G: nx.DiGraph,
-    vessel: dict,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
    pressure: float = 0.1,
    temp: float = 60.0,
-    time: Union[str, float] = "180",
+    time: Union[str, float] = "180",     # 🔧 修改：支持字符串时间
    stir_speed: float = 100.0,
    solvent: str = "",
    **kwargs
 ) -> List[Dict[str, Any]]:
    """
    生成蒸发操作的协议序列 - 支持单位和体积运算
-
+    
    Args:
        G: 设备图
        vessel: 容器字典（从XDL传入）
@@ -106,16 +135,27 @@ def generate_evaporate_protocol(
        stir_speed: 旋转速度 (RPM)，默认100
        solvent: 溶剂名称（用于参数优化）
        **kwargs: 其他参数（兼容性）
-
+    
    Returns:
        List[Dict[str, Any]]: 动作序列
    """
-
+    
+    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, vessel_data = get_vessel(vessel)
-
-    debug_print(f"开始生成蒸发协议: vessel={vessel_id}, pressure={pressure}, temp={temp}, time={time}")
-
-    # 记录蒸发前的容器状态
+    
+    debug_print("🌟" * 20)
+    debug_print("🌪️ 开始生成蒸发协议（支持单位和体积运算）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  💨 pressure: {pressure} bar")
+    debug_print(f"  🌡️ temp: {temp}°C")
+    debug_print(f"  ⏰ time: {time} (类型: {type(time)})")
+    debug_print(f"  🌪️ stir_speed: {stir_speed} RPM")
+    debug_print(f"  🧪 solvent: '{solvent}'")
+    debug_print("🌟" * 20)
+    
+    # 🔧 新增：记录蒸发前的容器状态
+    debug_print("🔍 记录蒸发前容器状态...")
    original_liquid_volume = 0.0
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
@@ -123,97 +163,168 @@ def generate_evaporate_protocol(
            original_liquid_volume = current_volume[0]
        elif isinstance(current_volume, (int, float)):
            original_liquid_volume = current_volume
-
-    # 查找旋转蒸发仪设备
+    debug_print(f"📊 蒸发前液体体积: {original_liquid_volume:.2f}mL")
+    
+    # === 步骤1: 查找旋转蒸发仪设备 ===
+    debug_print("📍 步骤1: 查找旋转蒸发仪设备... 🔍")
+    
+    # 验证vessel参数
    if not vessel_id:
+        debug_print("❌ vessel 参数不能为空! 😱")
        raise ValueError("vessel 参数不能为空")
-
+    
+    # 查找旋转蒸发仪设备
    rotavap_device = find_rotavap_device(G, vessel_id)
    if not rotavap_device:
+        debug_print("💥 未找到旋转蒸发仪设备! 😭")
        raise ValueError(f"未找到旋转蒸发仪设备。请检查组态图中是否包含 class 包含 'rotavap'、'rotary' 或 'evaporat' 的设备")
-
-    # 确定目标容器
+    
+    debug_print(f"🎉 成功找到旋转蒸发仪: {rotavap_device} ✨")
+    
+    # === 步骤2: 确定目标容器 ===
+    debug_print("📍 步骤2: 确定目标容器... 🥽")
+    
    target_vessel = vessel_id
-
+    
+    # 如果vessel就是旋转蒸发仪设备，查找连接的容器
    if vessel_id == rotavap_device:
+        debug_print("🔄 vessel就是旋转蒸发仪，查找连接的容器...")
        connected_vessel = find_connected_vessel(G, rotavap_device)
        if connected_vessel:
            target_vessel = connected_vessel
+            debug_print(f"✅ 使用连接的容器: {target_vessel} 🥽✨")
        else:
+            debug_print(f"⚠️ 未找到连接的容器，使用设备本身: {rotavap_device} 🔧")
            target_vessel = rotavap_device
    elif vessel_id in G.nodes() and G.nodes[vessel_id].get('type') == 'container':
+        debug_print(f"✅ 使用指定的容器: {vessel_id} 🥽✨")
        target_vessel = vessel_id
    else:
+        debug_print(f"⚠️ 容器 '{vessel_id}' 不存在或类型不正确，使用旋转蒸发仪设备: {rotavap_device} 🔧")
        target_vessel = rotavap_device
-
-    # 单位解析处理
+    
+    # === 🔧 新增：步骤3：单位解析处理 ===
+    debug_print("📍 步骤3: 单位解析处理... ⚡")
+    
+    # 解析时间
    final_time = parse_time_input(time)
-    debug_print(f"时间解析: {time} -> {final_time}s ({final_time/60:.1f}分钟)")
-
-    # 参数验证和修正
+    debug_print(f"🎯 时间解析完成: {time} → {final_time}s ({final_time/60:.1f}分钟) ⏰✨")
+    
+    # === 步骤4: 参数验证和修正 ===
+    debug_print("📍 步骤4: 参数验证和修正... 🔧")
+    
+    # 修正参数范围
    if pressure <= 0 or pressure > 1.0:
+        debug_print(f"⚠️ 真空度 {pressure} bar 超出范围，修正为 0.1 bar 💨")
        pressure = 0.1
-
+    else:
+        debug_print(f"✅ 真空度 {pressure} bar 在正常范围内 💨")
+    
    if temp < 10.0 or temp > 200.0:
+        debug_print(f"⚠️ 温度 {temp}°C 超出范围，修正为 60°C 🌡️")
        temp = 60.0
-
+    else:
+        debug_print(f"✅ 温度 {temp}°C 在正常范围内 🌡️")
+    
    if final_time <= 0:
+        debug_print(f"⚠️ 时间 {final_time}s 无效，修正为 180s (3分钟) ⏰")
        final_time = 180.0
-
+    else:
+        debug_print(f"✅ 时间 {final_time}s ({final_time/60:.1f}分钟) 有效 ⏰")
+    
    if stir_speed < 10.0 or stir_speed > 300.0:
+        debug_print(f"⚠️ 旋转速度 {stir_speed} RPM 超出范围，修正为 100 RPM 🌪️")
        stir_speed = 100.0
-
+    else:
+        debug_print(f"✅ 旋转速度 {stir_speed} RPM 在正常范围内 🌪️")
+    
    # 根据溶剂优化参数
    if solvent:
+        debug_print(f"🧪 根据溶剂 '{solvent}' 优化参数... 🔬")
        solvent_lower = solvent.lower()
-
+        
        if any(s in solvent_lower for s in ['water', 'aqueous', 'h2o']):
            temp = max(temp, 80.0)
            pressure = max(pressure, 0.2)
+            debug_print("💧 水系溶剂：提高温度和真空度 🌡️💨")
        elif any(s in solvent_lower for s in ['ethanol', 'methanol', 'acetone']):
            temp = min(temp, 50.0)
            pressure = min(pressure, 0.05)
+            debug_print("🍺 易挥发溶剂：降低温度和真空度 🌡️💨")
        elif any(s in solvent_lower for s in ['dmso', 'dmi', 'toluene']):
            temp = max(temp, 100.0)
            pressure = min(pressure, 0.01)
-
-    debug_print(f"最终参数: pressure={pressure}bar, temp={temp}°C, time={final_time}s, stir_speed={stir_speed}RPM")
-
-    # 蒸发体积计算
+            debug_print("🔥 高沸点溶剂：提高温度，降低真空度 🌡️💨")
+        else:
+            debug_print("🧪 通用溶剂，使用标准参数 ✨")
+    else:
+        debug_print("🤷‍♀️ 未指定溶剂，使用默认参数 ✨")
+    
+    debug_print(f"🎯 最终参数: pressure={pressure} bar 💨, temp={temp}°C 🌡️, time={final_time}s ⏰, stir_speed={stir_speed} RPM 🌪️")
+    
+    # === 🔧 新增：步骤5：蒸发体积计算 ===
+    debug_print("📍 步骤5: 蒸发体积计算... 📊")
+    
+    # 根据温度、真空度、时间和溶剂类型估算蒸发量
    evaporation_volume = 0.0
    if original_liquid_volume > 0:
-        base_evap_rate = 0.5
+        # 基础蒸发速率（mL/min）
+        base_evap_rate = 0.5  # 基础速率
+        
+        # 温度系数（高温蒸发更快）
        temp_factor = 1.0 + (temp - 25.0) / 100.0
+        
+        # 真空系数（真空度越高蒸发越快）
        vacuum_factor = 1.0 + (1.0 - pressure) * 2.0
-
+        
+        # 溶剂系数
        solvent_factor = 1.0
        if solvent:
            solvent_lower = solvent.lower()
            if any(s in solvent_lower for s in ['water', 'h2o']):
-                solvent_factor = 0.8
+                solvent_factor = 0.8  # 水蒸发较慢
            elif any(s in solvent_lower for s in ['ethanol', 'methanol', 'acetone']):
-                solvent_factor = 1.5
+                solvent_factor = 1.5  # 易挥发溶剂蒸发快
            elif any(s in solvent_lower for s in ['dmso', 'dmi']):
-                solvent_factor = 0.3
-
+                solvent_factor = 0.3  # 高沸点溶剂蒸发慢
+        
+        # 计算总蒸发量
        total_evap_rate = base_evap_rate * temp_factor * vacuum_factor * solvent_factor
        evaporation_volume = min(
-            original_liquid_volume * 0.95,
-            total_evap_rate * (final_time / 60.0)
+            original_liquid_volume * 0.95,  # 最多蒸发95%
+            total_evap_rate * (final_time / 60.0)  # 时间相关的蒸发量
        )
-
-        debug_print(f"预计蒸发量: {evaporation_volume:.2f}mL ({evaporation_volume/original_liquid_volume*100:.1f}%)")
-
-    # 生成动作序列
+        
+        debug_print(f"📊 蒸发量计算:")
+        debug_print(f"  - 基础蒸发速率: {base_evap_rate} mL/min")
+        debug_print(f"  - 温度系数: {temp_factor:.2f} (基于 {temp}°C)")
+        debug_print(f"  - 真空系数: {vacuum_factor:.2f} (基于 {pressure} bar)")
+        debug_print(f"  - 溶剂系数: {solvent_factor:.2f} ({solvent or '通用'})")
+        debug_print(f"  - 总蒸发速率: {total_evap_rate:.2f} mL/min")
+        debug_print(f"  - 预计蒸发量: {evaporation_volume:.2f}mL ({evaporation_volume/original_liquid_volume*100:.1f}%)")
+    
+    # === 步骤6: 生成动作序列 ===
+    debug_print("📍 步骤6: 生成动作序列... 🎬")
+    
    action_sequence = []
-
+    
    # 1. 等待稳定
+    debug_print("  🔄 动作1: 添加初始等待稳定... ⏳")
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {"time": 10}
    })
-
+    debug_print("  ✅ 初始等待动作已添加 ⏳✨")
+    
    # 2. 执行蒸发
+    debug_print(f"  🌪️ 动作2: 执行蒸发操作...")
+    debug_print(f"    🔧 设备: {rotavap_device}")
+    debug_print(f"    🥽 容器: {target_vessel}")
+    debug_print(f"    💨 真空度: {pressure} bar")
+    debug_print(f"    🌡️ 温度: {temp}°C")
+    debug_print(f"    ⏰ 时间: {final_time}s ({final_time/60:.1f}分钟)")
+    debug_print(f"    🌪️ 旋转速度: {stir_speed} RPM")
+    
    evaporate_action = {
        "device_id": rotavap_device,
        "action_name": "evaporate",
@@ -221,17 +332,20 @@ def generate_evaporate_protocol(
            "vessel": {"id": target_vessel},
            "pressure": float(pressure),
            "temp": float(temp),
-            "time": float(final_time),
+            "time": float(final_time),  # 🔧 强制转换为float类型
            "stir_speed": float(stir_speed),
            "solvent": str(solvent)
        }
    }
    action_sequence.append(evaporate_action)
-
-    # 蒸发过程中的体积变化
+    debug_print("  ✅ 蒸发动作已添加 🌪️✨")
+    
+    # 🔧 新增：蒸发过程中的体积变化
+    debug_print("  🔧 更新容器体积 - 蒸发过程...")
    if evaporation_volume > 0:
        new_volume = max(0.0, original_liquid_volume - evaporation_volume)
-
+        
+        # 更新vessel字典中的体积
        if "data" in vessel and "liquid_volume" in vessel["data"]:
            current_volume = vessel["data"]["liquid_volume"]
            if isinstance(current_volume, list):
@@ -243,14 +357,15 @@ def generate_evaporate_protocol(
                vessel["data"]["liquid_volume"] = new_volume
            else:
                vessel["data"]["liquid_volume"] = new_volume
-
+        
+        # 🔧 同时更新图中的容器数据
        if vessel_id in G.nodes():
            if 'data' not in G.nodes[vessel_id]:
                G.nodes[vessel_id]['data'] = {}
-
+            
            vessel_node_data = G.nodes[vessel_id]['data']
            current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
-
+            
            if isinstance(current_node_volume, list):
                if len(current_node_volume) > 0:
                    G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume
@@ -258,16 +373,18 @@ def generate_evaporate_protocol(
                    G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume]
            else:
                G.nodes[vessel_id]['data']['liquid_volume'] = new_volume
-
-        debug_print(f"蒸发体积变化: {original_liquid_volume:.2f}mL -> {new_volume:.2f}mL (-{evaporation_volume:.2f}mL)")
-
+        
+        debug_print(f"  📊 蒸发体积变化: {original_liquid_volume:.2f}mL → {new_volume:.2f}mL (-{evaporation_volume:.2f}mL)")
+    
    # 3. 蒸发后等待
+    debug_print("  🔄 动作3: 添加蒸发后等待... ⏳")
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {"time": 10}
    })
-
-    # 最终状态
+    debug_print("  ✅ 蒸发后等待动作已添加 ⏳✨")
+    
+    # 🔧 新增：蒸发完成后的状态报告
    final_liquid_volume = 0.0
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
@@ -275,7 +392,19 @@ def generate_evaporate_protocol(
            final_liquid_volume = current_volume[0]
        elif isinstance(current_volume, (int, float)):
            final_liquid_volume = current_volume
-
-    debug_print(f"蒸发协议生成完成: {len(action_sequence)} 个动作, 设备={rotavap_device}, 容器={target_vessel}")
-
+    
+    # === 总结 ===
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 蒸发协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个 📝")
+    debug_print(f"🌪️ 旋转蒸发仪: {rotavap_device} 🔧")
+    debug_print(f"🥽 目标容器: {target_vessel} 🧪")
+    debug_print(f"⚙️ 蒸发参数: {pressure} bar 💨, {temp}°C 🌡️, {final_time}s ⏰, {stir_speed} RPM 🌪️")
+    debug_print(f"⏱️ 预计总时间: {(final_time + 20)/60:.1f} 分钟 ⌛")
+    debug_print(f"📊 体积变化:")
+    debug_print(f"  - 蒸发前: {original_liquid_volume:.2f}mL")
+    debug_print(f"  - 蒸发后: {final_liquid_volume:.2f}mL") 
+    debug_print(f"  - 蒸发量: {evaporation_volume:.2f}mL ({evaporation_volume/max(original_liquid_volume, 0.01)*100:.1f}%)")
+    debug_print("🎊" * 20)
+    
    return action_sequence
--- a/unilabos/compile/filter_protocol.py
+++ b/unilabos/compile/filter_protocol.py
@@ -2,64 +2,87 @@ from typing import List, Dict, Any, Optional
 import networkx as nx
 import logging
 from .utils.vessel_parser import get_vessel
-from .utils.logger_util import debug_print
 from .pump_protocol import generate_pump_protocol_with_rinsing

 logger = logging.getLogger(__name__)

+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[FILTER] {message}")
+
 def find_filter_device(G: nx.DiGraph) -> str:
    """查找过滤器设备"""
+    debug_print("🔍 查找过滤器设备... 🌊")
+    
+    # 查找过滤器设备
    for node in G.nodes():
        node_data = G.nodes[node]
        node_class = node_data.get('class', '') or ''
-
+        
        if 'filter' in node_class.lower() or 'filter' in node.lower():
-            debug_print(f"找到过滤器设备: {node}")
+            debug_print(f"🎉 找到过滤器设备: {node} ✨")
            return node
-
+    
+    # 如果没找到，寻找可能的过滤器名称
+    debug_print("🔎 在预定义名称中搜索过滤器... 📋")
    possible_names = ["filter", "filter_1", "virtual_filter", "filtration_unit"]
    for name in possible_names:
        if name in G.nodes():
-            debug_print(f"找到过滤器设备: {name}")
+            debug_print(f"🎉 找到过滤器设备: {name} ✨")
            return name
-
+    
+    debug_print("😭 未找到过滤器设备 💔")
    raise ValueError("未找到过滤器设备")

 def validate_vessel(G: nx.DiGraph, vessel: str, vessel_type: str = "容器") -> None:
    """验证容器是否存在"""
+    debug_print(f"🔍 验证{vessel_type}: '{vessel}' 🧪")
+    
    if not vessel:
+        debug_print(f"❌ {vessel_type}不能为空! 😱")
        raise ValueError(f"{vessel_type}不能为空")
-
+    
    if vessel not in G.nodes():
+        debug_print(f"❌ {vessel_type} '{vessel}' 不存在于系统中! 😞")
        raise ValueError(f"{vessel_type} '{vessel}' 不存在于系统中")
+    
+    debug_print(f"✅ {vessel_type} '{vessel}' 验证通过 🎯")

 def generate_filter_protocol(
    G: nx.DiGraph,
-    vessel: dict,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
    filtrate_vessel: dict = {"id": "waste"},
    **kwargs
 ) -> List[Dict[str, Any]]:
    """
    生成过滤操作的协议序列 - 支持体积运算
-
+    
    Args:
        G: 设备图
        vessel: 过滤容器字典（必需）- 包含需要过滤的混合物
        filtrate_vessel: 滤液容器名称（可选）- 如果提供则收集滤液
        **kwargs: 其他参数（兼容性）
-
+    
    Returns:
        List[Dict[str, Any]]: 过滤操作的动作序列
    """
-
+    
+    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, vessel_data = get_vessel(vessel)
    filtrate_vessel_id, filtrate_vessel_data = get_vessel(filtrate_vessel)
-
-    debug_print(f"开始生成过滤协议: vessel={vessel_id}, filtrate_vessel={filtrate_vessel_id}")
-
+    
+    debug_print("🌊" * 20)
+    debug_print("🚀 开始生成过滤协议（支持体积运算）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  🧪 filtrate_vessel: {filtrate_vessel}")
+    debug_print(f"  ⚙️ 其他参数: {kwargs}")
+    debug_print("🌊" * 20)
+    
    action_sequence = []
-
-    # 记录过滤前的容器状态
+    
+    # 🔧 新增：记录过滤前的容器状态
+    debug_print("🔍 记录过滤前容器状态...")
    original_liquid_volume = 0.0
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
@@ -67,45 +90,79 @@ def generate_filter_protocol(
            original_liquid_volume = current_volume[0]
        elif isinstance(current_volume, (int, float)):
            original_liquid_volume = current_volume
-
+    debug_print(f"📊 过滤前液体体积: {original_liquid_volume:.2f}mL")
+    
    # === 参数验证 ===
-    validate_vessel(G, vessel_id, "过滤容器")
-
+    debug_print("📍 步骤1: 参数验证... 🔧")
+    
+    # 验证必需参数
+    debug_print("  🔍 验证必需参数...")
+    validate_vessel(G, vessel_id, "过滤容器")  # 🔧 使用 vessel_id
+    debug_print("  ✅ 必需参数验证完成 🎯")
+    
+    # 验证可选参数
+    debug_print("  🔍 验证可选参数...")
    if filtrate_vessel:
        validate_vessel(G, filtrate_vessel_id, "滤液容器")
-
+        debug_print("  🌊 模式: 过滤并收集滤液 💧")
+    else:
+        debug_print("  🧱 模式: 过滤并收集固体 🔬")
+    debug_print("  ✅ 可选参数验证完成 🎯")
+    
    # === 查找设备 ===
+    debug_print("📍 步骤2: 查找设备... 🔍")
+    
    try:
+        debug_print("  🔎 搜索过滤器设备...")
        filter_device = find_filter_device(G)
-        debug_print(f"使用过滤器设备: {filter_device}")
+        debug_print(f"  🎉 使用过滤器设备: {filter_device} 🌊✨")
+        
    except Exception as e:
+        debug_print(f"  ❌ 设备查找失败: {str(e)} 😭")
        raise ValueError(f"设备查找失败: {str(e)}")
-
-    # 过滤体积分配估算
-    solid_ratio = 0.1
-    liquid_ratio = 0.9
-    volume_loss_ratio = 0.05
-
+    
+    # 🔧 新增：过滤效率和体积分配估算
+    debug_print("📍 步骤2.5: 过滤体积分配估算... 📊")
+    
+    # 估算过滤分离比例（基于经验数据）
+    solid_ratio = 0.1  # 假设10%是固体（保留在过滤器上）
+    liquid_ratio = 0.9  # 假设90%是液体（通过过滤器）
+    volume_loss_ratio = 0.05  # 假设5%体积损失（残留在过滤器等）
+    
+    # 从kwargs中获取过滤参数进行优化
    if "solid_content" in kwargs:
        try:
            solid_ratio = float(kwargs["solid_content"])
            liquid_ratio = 1.0 - solid_ratio
+            debug_print(f"📋 使用指定的固体含量: {solid_ratio*100:.1f}%")
        except:
-            pass
-
+            debug_print("⚠️ 固体含量参数无效，使用默认值")
+    
    if original_liquid_volume > 0:
        expected_filtrate_volume = original_liquid_volume * liquid_ratio * (1.0 - volume_loss_ratio)
        expected_solid_volume = original_liquid_volume * solid_ratio
        volume_loss = original_liquid_volume * volume_loss_ratio
-
+        
+        debug_print(f"📊 过滤体积分配估算:")
+        debug_print(f"  - 原始体积: {original_liquid_volume:.2f}mL")
+        debug_print(f"  - 预计滤液体积: {expected_filtrate_volume:.2f}mL ({liquid_ratio*100:.1f}%)")
+        debug_print(f"  - 预计固体体积: {expected_solid_volume:.2f}mL ({solid_ratio*100:.1f}%)")
+        debug_print(f"  - 预计损失体积: {volume_loss:.2f}mL ({volume_loss_ratio*100:.1f}%)")
+    
    # === 转移到过滤器（如果需要）===
-    if vessel_id != filter_device:
+    debug_print("📍 步骤3: 转移到过滤器... 🚚")
+    
+    if vessel_id != filter_device:  # 🔧 使用 vessel_id
+        debug_print(f"  🚛 需要转移: {vessel_id} → {filter_device} 📦")
+        
        try:
+            debug_print("  🔄 开始执行转移操作...")
+            # 使用pump protocol转移液体到过滤器
            transfer_actions = generate_pump_protocol_with_rinsing(
                G=G,
-                from_vessel={"id": vessel_id},
+                from_vessel={"id": vessel_id},  # 🔧 使用 vessel_id
                to_vessel={"id": filter_device},
-                volume=0.0,
+                volume=0.0,  # 转移所有液体
                amount="",
                time=0.0,
                viscous=False,
@@ -116,59 +173,88 @@ def generate_filter_protocol(
                flowrate=2.0,
                transfer_flowrate=2.0
            )
-
+            
            if transfer_actions:
                action_sequence.extend(transfer_actions)
-                debug_print(f"添加了 {len(transfer_actions)} 个转移动作")
-
-                # 更新容器体积
+                debug_print(f"  ✅ 添加了 {len(transfer_actions)} 个转移动作 🚚✨")
+                
+                # 🔧 新增：转移后更新容器体积
+                debug_print("  🔧 更新转移后的容器体积...")
+                
+                # 原容器体积变为0（所有液体已转移）
                if "data" in vessel and "liquid_volume" in vessel["data"]:
                    current_volume = vessel["data"]["liquid_volume"]
                    if isinstance(current_volume, list):
                        vessel["data"]["liquid_volume"] = [0.0] if len(current_volume) > 0 else [0.0]
                    else:
                        vessel["data"]["liquid_volume"] = 0.0
-
+                
+                # 同时更新图中的容器数据
                if vessel_id in G.nodes():
                    if 'data' not in G.nodes[vessel_id]:
                        G.nodes[vessel_id]['data'] = {}
                    G.nodes[vessel_id]['data']['liquid_volume'] = 0.0
-
+                
+                debug_print(f"  📊 转移完成，{vessel_id} 体积更新为 0.0mL")
+                
+            else:
+                debug_print("  ⚠️ 转移协议返回空序列 🤔")
+                
        except Exception as e:
-            debug_print(f"转移失败: {str(e)}，继续执行")
-
+            debug_print(f"  ❌ 转移失败: {str(e)} 😞")
+            debug_print("  🔄 继续执行，可能是直接连接的过滤器 🤞")
+    else:
+        debug_print("  ✅ 过滤容器就是过滤器，无需转移 🎯")
+    
    # === 执行过滤操作 ===
+    debug_print("📍 步骤4: 执行过滤操作... 🌊")
+    
+    # 构建过滤动作参数
+    debug_print("  ⚙️ 构建过滤参数...")
    filter_kwargs = {
-        "vessel": {"id": filter_device},
-        "filtrate_vessel": {"id": filtrate_vessel_id},
+        "vessel": {"id": filter_device},  # 过滤器设备
+        "filtrate_vessel": {"id": filtrate_vessel_id},  # 滤液容器（可能为空）
        "stir": kwargs.get("stir", False),
        "stir_speed": kwargs.get("stir_speed", 0.0),
        "temp": kwargs.get("temp", 25.0),
        "continue_heatchill": kwargs.get("continue_heatchill", False),
-        "volume": kwargs.get("volume", 0.0)
+        "volume": kwargs.get("volume", 0.0)  # 0表示过滤所有
    }
-
+    
+    debug_print(f"  📋 过滤参数: {filter_kwargs}")
+    debug_print("  🌊 开始过滤操作...")
+    
+    # 过滤动作
    filter_action = {
        "device_id": filter_device,
        "action_name": "filter",
        "action_kwargs": filter_kwargs
    }
    action_sequence.append(filter_action)
-
+    debug_print("  ✅ 过滤动作已添加 🌊✨")
+    
    # 过滤后等待
+    debug_print("  ⏳ 添加过滤后等待...")
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {"time": 10.0}
    })
-
+    debug_print("  ✅ 过滤后等待动作已添加 ⏰✨")
+    
    # === 收集滤液（如果需要）===
+    debug_print("📍 步骤5: 收集滤液... 💧")
+    
    if filtrate_vessel_id and filtrate_vessel_id not in G.neighbors(filter_device):
+        debug_print(f"  🧪 收集滤液: {filter_device} → {filtrate_vessel_id} 💧")
+        
        try:
+            debug_print("  🔄 开始执行收集操作...")
+            # 使用pump protocol收集滤液
            collect_actions = generate_pump_protocol_with_rinsing(
                G=G,
                from_vessel=filter_device,
                to_vessel=filtrate_vessel,
-                volume=0.0,
+                volume=0.0,  # 收集所有滤液
                amount="",
                time=0.0,
                viscous=False,
@@ -179,15 +265,19 @@ def generate_filter_protocol(
                flowrate=2.0,
                transfer_flowrate=2.0
            )
-
+            
            if collect_actions:
                action_sequence.extend(collect_actions)
-
-                # 更新滤液容器体积
+                debug_print(f"  ✅ 添加了 {len(collect_actions)} 个收集动作 🧪✨")
+                
+                # 🔧 新增：收集滤液后的体积更新
+                debug_print("  🔧 更新滤液容器体积...")
+                
+                # 更新filtrate_vessel在图中的体积（如果它是节点）
                if filtrate_vessel_id in G.nodes():
                    if 'data' not in G.nodes[filtrate_vessel_id]:
                        G.nodes[filtrate_vessel_id]['data'] = {}
-
+                    
                    current_filtrate_volume = G.nodes[filtrate_vessel_id]['data'].get('liquid_volume', 0.0)
                    if isinstance(current_filtrate_volume, list):
                        if len(current_filtrate_volume) > 0:
@@ -196,37 +286,58 @@ def generate_filter_protocol(
                            G.nodes[filtrate_vessel_id]['data']['liquid_volume'] = [expected_filtrate_volume]
                    else:
                        G.nodes[filtrate_vessel_id]['data']['liquid_volume'] = current_filtrate_volume + expected_filtrate_volume
-
+                    
+                    debug_print(f"  📊 滤液容器 {filtrate_vessel_id} 体积增加 {expected_filtrate_volume:.2f}mL")
+                
+            else:
+                debug_print("  ⚠️ 收集协议返回空序列 🤔")
+                
        except Exception as e:
-            debug_print(f"收集滤液失败: {str(e)}，继续执行")
-
-    # 过滤完成后容器状态更新
+            debug_print(f"  ❌ 收集滤液失败: {str(e)} 😞")
+            debug_print("  🔄 继续执行，可能滤液直接流入指定容器 🤞")
+    else:
+        debug_print("  🧱 未指定滤液容器，固体保留在过滤器中 🔬")
+    
+    # 🔧 新增：过滤完成后的容器状态更新
+    debug_print("📍 步骤5.5: 过滤完成后状态更新... 📊")
+    
    if vessel_id == filter_device:
+        # 如果过滤容器就是过滤器，需要更新其体积状态
        if original_liquid_volume > 0:
            if filtrate_vessel:
+                # 收集滤液模式：过滤器中主要保留固体
                remaining_volume = expected_solid_volume
+                debug_print(f"  🧱 过滤器中保留固体: {remaining_volume:.2f}mL")
            else:
+                # 保留固体模式：过滤器中保留所有物质
                remaining_volume = original_liquid_volume * (1.0 - volume_loss_ratio)
-
+                debug_print(f"  🔬 过滤器中保留所有物质: {remaining_volume:.2f}mL")
+            
+            # 更新vessel字典中的体积
            if "data" in vessel and "liquid_volume" in vessel["data"]:
                current_volume = vessel["data"]["liquid_volume"]
                if isinstance(current_volume, list):
                    vessel["data"]["liquid_volume"] = [remaining_volume] if len(current_volume) > 0 else [remaining_volume]
                else:
                    vessel["data"]["liquid_volume"] = remaining_volume
-
+            
+            # 同时更新图中的容器数据
            if vessel_id in G.nodes():
                if 'data' not in G.nodes[vessel_id]:
                    G.nodes[vessel_id]['data'] = {}
                G.nodes[vessel_id]['data']['liquid_volume'] = remaining_volume
-
+            
+            debug_print(f"  📊 过滤器 {vessel_id} 体积更新为: {remaining_volume:.2f}mL")
+    
    # === 最终等待 ===
+    debug_print("📍 步骤6: 最终等待... ⏰")
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {"time": 5.0}
    })
-
-    # 最终状态
+    debug_print("  ✅ 最终等待动作已添加 ⏰✨")
+    
+    # 🔧 新增：过滤完成后的状态报告
    final_vessel_volume = 0.0
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
@@ -234,7 +345,22 @@ def generate_filter_protocol(
            final_vessel_volume = current_volume[0]
        elif isinstance(current_volume, (int, float)):
            final_vessel_volume = current_volume
-
-    debug_print(f"过滤协议生成完成: {len(action_sequence)} 个动作, 容器={vessel_id}, 过滤器={filter_device}")
-
+    
+    # === 总结 ===
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 过滤协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个 📝")
+    debug_print(f"🥽 过滤容器: {vessel_id} 🧪")
+    debug_print(f"🌊 过滤器设备: {filter_device} 🔧")
+    debug_print(f"💧 滤液容器: {filtrate_vessel_id or '无（保留固体）'} 🧱")
+    debug_print(f"⏱️ 预计总时间: {(len(action_sequence) * 5):.0f} 秒 ⌛")
+    if original_liquid_volume > 0:
+        debug_print(f"📊 体积变化统计:")
+        debug_print(f"  - 过滤前体积: {original_liquid_volume:.2f}mL")
+        debug_print(f"  - 过滤后容器体积: {final_vessel_volume:.2f}mL")
+        if filtrate_vessel:
+            debug_print(f"  - 预计滤液体积: {expected_filtrate_volume:.2f}mL")
+        debug_print(f"  - 预计损失体积: {volume_loss:.2f}mL")
+    debug_print("🎊" * 20)
+    
    return action_sequence
--- a/unilabos/compile/heatchill_protocol.py
+++ b/unilabos/compile/heatchill_protocol.py
@@ -1,24 +1,118 @@
 from typing import List, Dict, Any, Union
 import networkx as nx
-from .utils.vessel_parser import get_vessel, find_connected_heatchill
-from .utils.unit_parser import parse_time_input, parse_temperature_input
-from .utils.logger_util import debug_print
+import logging
+import re
+from .utils.vessel_parser import get_vessel
+from .utils.unit_parser import parse_time_input

+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[HEATCHILL] {message}")
+
+
+def parse_temp_input(temp_input: Union[str, float], default_temp: float = 25.0) -> float:
+    """
+    解析温度输入（统一函数）
+    
+    Args:
+        temp_input: 温度输入
+        default_temp: 默认温度
+        
+    Returns:
+        float: 温度（°C）
+    """
+    if not temp_input:
+        return default_temp
+    
+    # 🔢 数值输入
+    if isinstance(temp_input, (int, float)):
+        result = float(temp_input)
+        debug_print(f"🌡️ 数值温度: {temp_input} → {result}°C")
+        return result
+    
+    # 📝 字符串输入
+    temp_str = str(temp_input).lower().strip()
+    debug_print(f"🔍 解析温度: '{temp_str}'")
+    
+    # 🎯 特殊温度
+    special_temps = {
+        "room temperature": 25.0, "reflux": 78.0, "ice bath": 0.0,
+        "boiling": 100.0, "hot": 60.0, "warm": 40.0, "cold": 10.0
+    }
+    
+    if temp_str in special_temps:
+        result = special_temps[temp_str]
+        debug_print(f"🎯 特殊温度: '{temp_str}' → {result}°C")
+        return result
+    
+    # 📐 正则解析（如 "256 °C"）
+    temp_pattern = r'(\d+(?:\.\d+)?)\s*°?[cf]?'
+    match = re.search(temp_pattern, temp_str)
+    
+    if match:
+        result = float(match.group(1))
+        debug_print(f"✅ 温度解析: '{temp_str}' → {result}°C")
+        return result
+    
+    debug_print(f"⚠️ 无法解析温度: '{temp_str}'，使用默认值: {default_temp}°C")
+    return default_temp
+
+def find_connected_heatchill(G: nx.DiGraph, vessel: str) -> str:
+    """查找与指定容器相连的加热/冷却设备"""
+    debug_print(f"🔍 查找加热设备，目标容器: {vessel}")
+    
+    # 🔧 查找所有加热设备
+    heatchill_nodes = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'heatchill' in node_class.lower() or 'virtual_heatchill' in node_class:
+            heatchill_nodes.append(node)
+            debug_print(f"🎉 找到加热设备: {node}")
+    
+    # 🔗 检查连接
+    if vessel and heatchill_nodes:
+        for heatchill in heatchill_nodes:
+            if G.has_edge(heatchill, vessel) or G.has_edge(vessel, heatchill):
+                debug_print(f"✅ 加热设备 '{heatchill}' 与容器 '{vessel}' 相连")
+                return heatchill
+    
+    # 🎯 使用第一个可用设备
+    if heatchill_nodes:
+        selected = heatchill_nodes[0]
+        debug_print(f"🔧 使用第一个加热设备: {selected}")
+        return selected
+    
+    # 🆘 默认设备
+    debug_print("⚠️ 未找到加热设备，使用默认设备")
+    return "heatchill_1"

 def validate_and_fix_params(temp: float, time: float, stir_speed: float) -> tuple:
    """验证和修正参数"""
+    # 🌡️ 温度范围验证
    if temp < -50.0 or temp > 300.0:
        debug_print(f"⚠️ 温度 {temp}°C 超出范围，修正为 25°C")
        temp = 25.0
-
+    else:
+        debug_print(f"✅ 温度 {temp}°C 在正常范围内")
+    
+    # ⏰ 时间验证
    if time < 0:
        debug_print(f"⚠️ 时间 {time}s 无效，修正为 300s")
        time = 300.0
-
+    else:
+        debug_print(f"✅ 时间 {time}s ({time/60:.1f}分钟) 有效")
+    
+    # 🌪️ 搅拌速度验证
    if stir_speed < 0 or stir_speed > 1500.0:
        debug_print(f"⚠️ 搅拌速度 {stir_speed} RPM 超出范围，修正为 300 RPM")
        stir_speed = 300.0
-
+    else:
+        debug_print(f"✅ 搅拌速度 {stir_speed} RPM 在正常范围内")
+    
    return temp, time, stir_speed

 def generate_heat_chill_protocol(
@@ -37,7 +131,7 @@ def generate_heat_chill_protocol(
 ) -> List[Dict[str, Any]]:
    """
    生成加热/冷却操作的协议序列 - 支持vessel字典
-
+    
    Args:
        G: 设备图
        vessel: 容器字典（从XDL传入）
@@ -51,58 +145,82 @@ def generate_heat_chill_protocol(
        stir_speed: 搅拌速度 (RPM)
        purpose: 操作目的说明
        **kwargs: 其他参数（兼容性）
-
+    
    Returns:
        List[Dict[str, Any]]: 加热/冷却操作的动作序列
    """
-
+    
    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, vessel_data = get_vessel(vessel)
-
-    debug_print(f"开始生成加热冷却协议: vessel={vessel_id}, temp={temp}°C, "
-                f"time={time}, stir={stir} ({stir_speed} RPM), purpose='{purpose}'")
-
-    # 参数验证
-    if not vessel_id:
+    
+    debug_print("🌡️" * 20)
+    debug_print("🚀 开始生成加热冷却协议（支持vessel字典）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  🌡️ temp: {temp}°C")
+    debug_print(f"  ⏰ time: {time}")
+    debug_print(f"  🎯 temp_spec: {temp_spec}")
+    debug_print(f"  ⏱️ time_spec: {time_spec}")
+    debug_print(f"  🌪️ stir: {stir} ({stir_speed} RPM)")
+    debug_print(f"  🎭 purpose: '{purpose}'")
+    debug_print("🌡️" * 20)
+    
+    # 📋 参数验证
+    debug_print("📍 步骤1: 参数验证... 🔧")
+    if not vessel_id:  # 🔧 使用 vessel_id
+        debug_print("❌ vessel 参数不能为空! 😱")
        raise ValueError("vessel 参数不能为空")
-
-    if vessel_id not in G.nodes():
+    
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print(f"❌ 容器 '{vessel_id}' 不存在于系统中! 😞")
        raise ValueError(f"容器 '{vessel_id}' 不存在于系统中")
-
-    # 参数解析
-    # 温度解析：优先使用 temp_spec
-    final_temp = parse_temperature_input(temp_spec, temp) if temp_spec else temp
-
+    
+    debug_print("✅ 基础参数验证通过 🎯")
+    
+    # 🔄 参数解析
+    debug_print("📍 步骤2: 参数解析... ⚡")
+    
+    #温度解析：优先使用 temp_spec
+    final_temp = parse_temp_input(temp_spec, temp) if temp_spec else temp
+    
    # 时间解析：优先使用 time_spec
    final_time = parse_time_input(time_spec) if time_spec else parse_time_input(time)
-
+    
    # 参数修正
    final_temp, final_time, stir_speed = validate_and_fix_params(final_temp, final_time, stir_speed)
-
-    debug_print(f"最终参数: temp={final_temp}°C, time={final_time}s, stir_speed={stir_speed} RPM")
-
-    # 查找设备
+    
+    debug_print(f"🎯 最终参数: temp={final_temp}°C, time={final_time}s, stir_speed={stir_speed} RPM")
+    
+    # 🔍 查找设备
+    debug_print("📍 步骤3: 查找加热设备... 🔍")
    try:
-        heatchill_id = find_connected_heatchill(G, vessel_id)
-        debug_print(f"使用加热设备: {heatchill_id}")
+        heatchill_id = find_connected_heatchill(G, vessel_id)  # 🔧 使用 vessel_id
+        debug_print(f"🎉 使用加热设备: {heatchill_id} ✨")
    except Exception as e:
+        debug_print(f"❌ 设备查找失败: {str(e)} 😭")
        raise ValueError(f"无法找到加热设备: {str(e)}")
-
-    # 生成动作
-    # 模拟运行时间优化
+    
+    # 🚀 生成动作
+    debug_print("📍 步骤4: 生成加热动作... 🔥")
+    
+    # 🕐 模拟运行时间优化
+    debug_print("  ⏱️ 检查模拟运行时间限制...")
    original_time = final_time
    simulation_time_limit = 100.0  # 模拟运行时间限制：100秒
-
+    
    if final_time > simulation_time_limit:
        final_time = simulation_time_limit
-        debug_print(f"模拟运行优化: {original_time}s → {final_time}s (限制为{simulation_time_limit}s)")
-
+        debug_print(f"  🎮 模拟运行优化: {original_time}s → {final_time}s (限制为{simulation_time_limit}s) ⚡")
+        debug_print(f"  📊 时间缩短: {original_time/60:.1f}分钟 → {final_time/60:.1f}分钟 🚀")
+    else:
+        debug_print(f"  ✅ 时间在限制内: {final_time}s ({final_time/60:.1f}分钟) 保持不变 🎯")
+    
    action_sequence = []
    heatchill_action = {
        "device_id": heatchill_id,
        "action_name": "heat_chill",
        "action_kwargs": {
-            "vessel": {"id": vessel_id},
+            "vessel": {"id": vessel},
            "temp": float(final_temp),
            "time": float(final_time),
            "stir": bool(stir),
@@ -111,10 +229,21 @@ def generate_heat_chill_protocol(
        }
    }
    action_sequence.append(heatchill_action)
-
-    debug_print(f"加热冷却协议生成完成: {len(action_sequence)} 个动作, "
-                f"vessel={vessel_id}, temp={final_temp}°C, time={final_time}s")
-
+    debug_print("✅ 加热动作已添加 🔥✨")
+    
+    # 显示时间调整信息
+    if original_time != final_time:
+        debug_print(f"  🎭 模拟优化说明: 原计划 {original_time/60:.1f}分钟，实际模拟 {final_time/60:.1f}分钟 ⚡")
+    
+    # 🎊 总结
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 加热冷却协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 加热容器: {vessel_id}")
+    debug_print(f"🌡️ 目标温度: {final_temp}°C")
+    debug_print(f"⏰ 加热时间: {final_time}s ({final_time/60:.1f}分钟)")
+    debug_print("🎊" * 20)
+    
    return action_sequence

 def generate_heat_chill_to_temp_protocol(
@@ -126,7 +255,7 @@ def generate_heat_chill_to_temp_protocol(
 ) -> List[Dict[str, Any]]:
    """生成加热到指定温度的协议（简化版）"""
    vessel_id, _ = get_vessel(vessel)
-    debug_print(f"生成加热到温度协议: {vessel_id} → {temp}°C")
+    debug_print(f"🌡️ 生成加热到温度协议: {vessel_id} → {temp}°C")
    return generate_heat_chill_protocol(G, vessel, temp, time, **kwargs)

 def generate_heat_chill_start_protocol(
@@ -137,19 +266,21 @@ def generate_heat_chill_start_protocol(
    **kwargs
 ) -> List[Dict[str, Any]]:
    """生成开始加热操作的协议序列"""
-
+    
    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, _ = get_vessel(vessel)
-
-    debug_print(f"生成启动加热协议: vessel={vessel_id}, temp={temp}°C")
-
+    
+    debug_print("🔥 开始生成启动加热协议 ✨")
+    debug_print(f"🥽 vessel: {vessel} (ID: {vessel_id}), 🌡️ temp: {temp}°C")
+    
    # 基础验证
-    if not vessel_id or vessel_id not in G.nodes():
+    if not vessel_id or vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print("❌ 容器验证失败!")
        raise ValueError("vessel 参数无效")
-
+    
    # 查找设备
-    heatchill_id = find_connected_heatchill(G, vessel_id)
-
+    heatchill_id = find_connected_heatchill(G, vessel_id)  # 🔧 使用 vessel_id
+    
    # 生成动作
    action_sequence = [{
        "device_id": heatchill_id,
@@ -160,8 +291,8 @@ def generate_heat_chill_start_protocol(
            "vessel": {"id": vessel_id},
        }
    }]
-
-    debug_print(f"启动加热协议生成完成")
+    
+    debug_print(f"✅ 启动加热协议生成完成 🎯")
    return action_sequence

 def generate_heat_chill_stop_protocol(
@@ -170,19 +301,21 @@ def generate_heat_chill_stop_protocol(
    **kwargs
 ) -> List[Dict[str, Any]]:
    """生成停止加热操作的协议序列"""
-
+    
    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, _ = get_vessel(vessel)
-
-    debug_print(f"生成停止加热协议: vessel={vessel_id}")
-
+    
+    debug_print("🛑 开始生成停止加热协议 ✨")
+    debug_print(f"🥽 vessel: {vessel} (ID: {vessel_id})")
+    
    # 基础验证
-    if not vessel_id or vessel_id not in G.nodes():
+    if not vessel_id or vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print("❌ 容器验证失败!")
        raise ValueError("vessel 参数无效")
-
+    
    # 查找设备
-    heatchill_id = find_connected_heatchill(G, vessel_id)
-
+    heatchill_id = find_connected_heatchill(G, vessel_id)  # 🔧 使用 vessel_id
+    
    # 生成动作
    action_sequence = [{
        "device_id": heatchill_id,
@@ -190,6 +323,6 @@ def generate_heat_chill_stop_protocol(
        "action_kwargs": {
        }
    }]
-
-    debug_print(f"停止加热协议生成完成")
+    
+    debug_print(f"✅ 停止加热协议生成完成 🎯")
    return action_sequence
--- a/unilabos/compile/hydrogenate_protocol.py
+++ b/unilabos/compile/hydrogenate_protocol.py
@@ -1,50 +1,105 @@
 import networkx as nx
 from typing import List, Dict, Any, Optional
 from .utils.vessel_parser import get_vessel
-from .utils.logger_util import debug_print
-from .utils.unit_parser import parse_temperature_input, parse_time_input
+
+
+def parse_temperature(temp_str: str) -> float:
+    """
+    解析温度字符串，支持多种格式
+    
+    Args:
+        temp_str: 温度字符串（如 "45 °C", "45°C", "45"）
+    
+    Returns:
+        float: 温度值（摄氏度）
+    """
+    try:
+        # 移除常见的温度单位和符号
+        temp_clean = temp_str.replace("°C", "").replace("°", "").replace("C", "").strip()
+        return float(temp_clean)
+    except ValueError:
+        print(f"HYDROGENATE: 无法解析温度 '{temp_str}'，使用默认温度 25°C")
+        return 25.0
+
+
+def parse_time(time_str: str) -> float:
+    """
+    解析时间字符串，支持多种格式
+    
+    Args:
+        time_str: 时间字符串（如 "2 h", "120 min", "7200 s"）
+    
+    Returns:
+        float: 时间值（秒）
+    """
+    try:
+        time_clean = time_str.lower().strip()
+        
+        # 处理小时
+        if "h" in time_clean:
+            hours = float(time_clean.replace("h", "").strip())
+            return hours * 3600.0
+        
+        # 处理分钟
+        if "min" in time_clean:
+            minutes = float(time_clean.replace("min", "").strip())
+            return minutes * 60.0
+        
+        # 处理秒
+        if "s" in time_clean:
+            seconds = float(time_clean.replace("s", "").strip())
+            return seconds
+        
+        # 默认按小时处理
+        return float(time_clean) * 3600.0
+    
+    except ValueError:
+        print(f"HYDROGENATE: 无法解析时间 '{time_str}'，使用默认时间 2小时")
+        return 7200.0  # 2小时


 def find_associated_solenoid_valve(G: nx.DiGraph, device_id: str) -> Optional[str]:
    """查找与指定设备相关联的电磁阀"""
    solenoid_valves = [
-        node for node in G.nodes()
+        node for node in G.nodes() 
        if ('solenoid' in (G.nodes[node].get('class') or '').lower()
            or 'solenoid_valve' in node)
    ]
-
+    
    # 通过网络连接查找直接相连的电磁阀
    for solenoid in solenoid_valves:
        if G.has_edge(device_id, solenoid) or G.has_edge(solenoid, device_id):
            return solenoid
-
+    
    # 通过命名规则查找关联的电磁阀
    device_type = ""
    if 'gas' in device_id.lower():
        device_type = "gas"
    elif 'h2' in device_id.lower() or 'hydrogen' in device_id.lower():
        device_type = "gas"
-
+    
    if device_type:
        for solenoid in solenoid_valves:
            if device_type in solenoid.lower():
                return solenoid
-
+    
    return None


 def find_connected_device(G: nx.DiGraph, vessel: str, device_type: str) -> str:
    """
    查找与容器相连的指定类型设备
-
+    
    Args:
        G: 网络图
        vessel: 容器名称
        device_type: 设备类型 ('heater', 'stirrer', 'gas_source')
-
+    
    Returns:
        str: 设备ID，如果没有则返回None
    """
+    print(f"HYDROGENATE: 正在查找与容器 '{vessel}' 相连的 {device_type}...")
+    
    # 根据设备类型定义搜索关键词
    if device_type == 'heater':
        keywords = ['heater', 'heat', 'heatchill']
@@ -57,38 +112,40 @@ def find_connected_device(G: nx.DiGraph, vessel: str, device_type: str) -> str:
        device_class = 'virtual_gas_source'
    else:
        return None
-
+    
    # 查找设备节点
    device_nodes = []
    for node in G.nodes():
        node_data = G.nodes[node]
        node_name = node.lower()
        node_class = node_data.get('class', '').lower()
-
+        
+        # 通过名称匹配
        if any(keyword in node_name for keyword in keywords):
            device_nodes.append(node)
+        # 通过类型匹配
        elif device_class in node_class:
            device_nodes.append(node)
-
-    debug_print(f"找到的{device_type}节点: {device_nodes}")
-
+    
+    print(f"HYDROGENATE: 找到的{device_type}节点: {device_nodes}")
+    
    # 检查是否有设备与目标容器相连
    for device in device_nodes:
        if G.has_edge(device, vessel) or G.has_edge(vessel, device):
-            debug_print(f"找到与容器 '{vessel}' 相连的{device_type}: {device}")
+            print(f"HYDROGENATE: 找到与容器 '{vessel}' 相连的{device_type}: {device}")
            return device
-
+    
    # 如果没有直接连接，查找距离最近的设备
    for device in device_nodes:
        try:
            path = nx.shortest_path(G, source=device, target=vessel)
            if len(path) <= 3:  # 最多2个中间节点
-                debug_print(f"找到距离较近的{device_type}: {device}")
+                print(f"HYDROGENATE: 找到距离较近的{device_type}: {device}")
                return device
        except nx.NetworkXNoPath:
            continue
-
-    debug_print(f"未找到与容器 '{vessel}' 相连的{device_type}")
+    
+    print(f"HYDROGENATE: 未找到与容器 '{vessel}' 相连的{device_type}")
    return None


@@ -101,31 +158,36 @@ def generate_hydrogenate_protocol(
 ) -> List[Dict[str, Any]]:
    """
    生成氢化反应协议序列 - 支持vessel字典
-
+    
    Args:
        G: 有向图，节点为容器和设备
        vessel: 反应容器字典（从XDL传入）
        temp: 反应温度（如 "45 °C"）
        time: 反应时间（如 "2 h"）
        **kwargs: 其他可选参数，但不使用
-
+    
    Returns:
        List[Dict[str, Any]]: 动作序列
    """
-
+    
    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, vessel_data = get_vessel(vessel)
-
+    
    action_sequence = []
-
+    
    # 解析参数
-    temperature = parse_temperature_input(temp)
-    reaction_time = parse_time_input(time)
-
-    debug_print(f"开始生成氢化反应协议: vessel={vessel_id}, "
-                f"temp={temperature}°C, time={reaction_time/3600:.1f}h")
-
-    # 记录氢化前的容器状态
+    temperature = parse_temperature(temp)
+    reaction_time = parse_time(time)
+    
+    print("🧪" * 20)
+    print(f"HYDROGENATE: 开始生成氢化反应协议（支持vessel字典）✨")
+    print(f"📝 输入参数:")
+    print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    print(f"  🌡️ 反应温度: {temperature}°C")
+    print(f"  ⏰ 反应时间: {reaction_time/3600:.1f} 小时")
+    print("🧪" * 20)
+    
+    # 🔧 新增：记录氢化前的容器状态（可选，氢化反应通常不改变体积）
    original_liquid_volume = 0.0
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
@@ -133,36 +195,47 @@ def generate_hydrogenate_protocol(
            original_liquid_volume = current_volume[0]
        elif isinstance(current_volume, (int, float)):
            original_liquid_volume = current_volume
-
+    print(f"📊 氢化前液体体积: {original_liquid_volume:.2f}mL")
+    
    # 1. 验证目标容器存在
-    if vessel_id not in G.nodes():
-        debug_print(f"⚠️ 容器 '{vessel_id}' 不存在于系统中，跳过氢化反应")
+    print("📍 步骤1: 验证目标容器...")
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        print(f"⚠️ HYDROGENATE: 警告 - 容器 '{vessel_id}' 不存在于系统中，跳过氢化反应")
        return action_sequence
-
+    print(f"✅ 容器 '{vessel_id}' 验证通过")
+    
    # 2. 查找相连的设备
-    heater_id = find_connected_device(G, vessel_id, 'heater')
-    stirrer_id = find_connected_device(G, vessel_id, 'stirrer')
-    gas_source_id = find_connected_device(G, vessel_id, 'gas_source')
-
-    debug_print(f"设备配置: heater={heater_id or '未找到'}, "
-                f"stirrer={stirrer_id or '未找到'}, gas={gas_source_id or '未找到'}")
-
+    print("📍 步骤2: 查找相连设备...")
+    heater_id = find_connected_device(G, vessel_id, 'heater')  # 🔧 使用 vessel_id
+    stirrer_id = find_connected_device(G, vessel_id, 'stirrer')  # 🔧 使用 vessel_id
+    gas_source_id = find_connected_device(G, vessel_id, 'gas_source')  # 🔧 使用 vessel_id
+    
+    print(f"🔧 设备配置:")
+    print(f"  🔥 加热器: {heater_id or '未找到'}")
+    print(f"  🌪️ 搅拌器: {stirrer_id or '未找到'}")
+    print(f"  💨 气源: {gas_source_id or '未找到'}")
+    
    # 3. 启动搅拌器
+    print("📍 步骤3: 启动搅拌器...")
    if stirrer_id:
+        print(f"🌪️ 启动搅拌器 {stirrer_id}")
        action_sequence.append({
            "device_id": stirrer_id,
            "action_name": "start_stir",
            "action_kwargs": {
-                "vessel": {"id": vessel_id},
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
                "stir_speed": 300.0,
                "purpose": "氢化反应: 开始搅拌"
            }
        })
+        print("✅ 搅拌器启动动作已添加")
    else:
-        debug_print(f"⚠️ 未找到搅拌器，继续执行")
-
+        print(f"⚠️ HYDROGENATE: 警告 - 未找到搅拌器，继续执行")
+    
    # 4. 启动气源（氢气）
+    print("📍 步骤4: 启动氢气源...")
    if gas_source_id:
+        print(f"💨 启动气源 {gas_source_id} (氢气)")
        action_sequence.append({
            "device_id": gas_source_id,
            "action_name": "set_status",
@@ -170,10 +243,11 @@ def generate_hydrogenate_protocol(
                "string": "ON"
            }
        })
-
+        
        # 查找相关的电磁阀
        gas_solenoid = find_associated_solenoid_valve(G, gas_source_id)
        if gas_solenoid:
+            print(f"🚪 开启气源电磁阀 {gas_solenoid}")
            action_sequence.append({
                "device_id": gas_solenoid,
                "action_name": "set_valve_position",
@@ -181,10 +255,12 @@ def generate_hydrogenate_protocol(
                    "command": "OPEN"
                }
            })
+        print("✅ 氢气源启动动作已添加")
    else:
-        debug_print(f"⚠️ 未找到气源，继续执行")
-
+        print(f"⚠️ HYDROGENATE: 警告 - 未找到气源，继续执行")
+    
    # 5. 等待气体稳定
+    print("📍 步骤5: 等待气体环境稳定...")
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {
@@ -192,19 +268,22 @@ def generate_hydrogenate_protocol(
            "description": "等待氢气环境稳定"
        }
    })
-
+    print("✅ 气体稳定等待动作已添加")
+    
    # 6. 启动加热器
+    print("📍 步骤6: 启动加热反应...")
    if heater_id:
+        print(f"🔥 启动加热器 {heater_id} 到 {temperature}°C")
        action_sequence.append({
            "device_id": heater_id,
            "action_name": "heat_chill_start",
            "action_kwargs": {
-                "vessel": {"id": vessel_id},
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
                "temp": temperature,
                "purpose": f"氢化反应: 加热到 {temperature}°C"
            }
        })
-
+        
        # 等待温度稳定
        action_sequence.append({
            "action_name": "wait",
@@ -213,38 +292,52 @@ def generate_hydrogenate_protocol(
                "description": f"等待温度稳定到 {temperature}°C"
            }
        })
-
-        # 模拟运行时间优化
+        
+        # 🕐 模拟运行时间优化
+        print("  ⏰ 检查模拟运行时间限制...")
        original_reaction_time = reaction_time
-        simulation_time_limit = 60.0
-
+        simulation_time_limit = 60.0  # 模拟运行时间限制：60秒
+        
        if reaction_time > simulation_time_limit:
            reaction_time = simulation_time_limit
-            debug_print(f"模拟运行优化: {original_reaction_time}s → {reaction_time}s")
-
+            print(f"  🎮 模拟运行优化: {original_reaction_time}s → {reaction_time}s (限制为{simulation_time_limit}s)")
+            print(f"  📊 时间缩短: {original_reaction_time/3600:.2f}小时 → {reaction_time/60:.1f}分钟")
+        else:
+            print(f"  ✅ 时间在限制内: {reaction_time}s ({reaction_time/60:.1f}分钟) 保持不变")
+        
        # 保持反应温度
        action_sequence.append({
            "device_id": heater_id,
            "action_name": "heat_chill",
            "action_kwargs": {
-                "vessel": {"id": vessel_id},
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
                "temp": temperature,
                "time": reaction_time,
                "purpose": f"氢化反应: 保持 {temperature}°C，反应 {reaction_time/60:.1f}分钟" + (f" (模拟时间)" if original_reaction_time != reaction_time else "")
            }
        })
-
+        
+        # 显示时间调整信息
+        if original_reaction_time != reaction_time:
+            print(f"  🎭 模拟优化说明: 原计划 {original_reaction_time/3600:.2f}小时，实际模拟 {reaction_time/60:.1f}分钟")
+        
+        print("✅ 加热反应动作已添加")
+            
    else:
-        debug_print(f"⚠️ 未找到加热器，使用室温反应")
-
-        # 室温反应也需要时间优化
+        print(f"⚠️ HYDROGENATE: 警告 - 未找到加热器，使用室温反应")
+        
+        # 🕐 室温反应也需要时间优化
+        print("  ⏰ 检查室温反应模拟时间限制...")
        original_reaction_time = reaction_time
-        simulation_time_limit = 60.0
-
+        simulation_time_limit = 60.0  # 模拟运行时间限制：60秒
+        
        if reaction_time > simulation_time_limit:
            reaction_time = simulation_time_limit
-            debug_print(f"室温反应时间优化: {original_reaction_time}s → {reaction_time}s")
-
+            print(f"  🎮 室温反应时间优化: {original_reaction_time}s → {reaction_time}s")
+            print(f"  📊 时间缩短: {original_reaction_time/3600:.2f}小时 → {reaction_time/60:.1f}分钟")
+        else:
+            print(f"  ✅ 室温反应时间在限制内: {reaction_time}s 保持不变")
+        
        # 室温反应，只等待时间
        action_sequence.append({
            "action_name": "wait",
@@ -253,19 +346,28 @@ def generate_hydrogenate_protocol(
                "description": f"室温氢化反应 {reaction_time/60:.1f}分钟" + (f" (模拟时间)" if original_reaction_time != reaction_time else "")
            }
        })
-
+        
+        # 显示时间调整信息
+        if original_reaction_time != reaction_time:
+            print(f"  🎭 室温反应优化说明: 原计划 {original_reaction_time/3600:.2f}小时，实际模拟 {reaction_time/60:.1f}分钟")
+        
+        print("✅ 室温反应等待动作已添加")
+    
    # 7. 停止加热
+    print("📍 步骤7: 停止加热...")
    if heater_id:
        action_sequence.append({
            "device_id": heater_id,
            "action_name": "heat_chill_stop",
            "action_kwargs": {
-                "vessel": {"id": vessel_id},
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
                "purpose": "氢化反应完成，停止加热"
            }
        })
-
+        print("✅ 停止加热动作已添加")
+    
    # 8. 等待冷却
+    print("📍 步骤8: 等待冷却...")
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {
@@ -273,12 +375,15 @@ def generate_hydrogenate_protocol(
            "description": "等待反应混合物冷却"
        }
    })
-
+    print("✅ 冷却等待动作已添加")
+    
    # 9. 停止气源
+    print("📍 步骤9: 停止氢气源...")
    if gas_source_id:
        # 先关闭电磁阀
        gas_solenoid = find_associated_solenoid_valve(G, gas_source_id)
        if gas_solenoid:
+            print(f"🚪 关闭气源电磁阀 {gas_solenoid}")
            action_sequence.append({
                "device_id": gas_solenoid,
                "action_name": "set_valve_position",
@@ -286,7 +391,7 @@ def generate_hydrogenate_protocol(
                    "command": "CLOSED"
                }
            })
-
+        
        # 再关闭气源
        action_sequence.append({
            "device_id": gas_source_id,
@@ -295,24 +400,59 @@ def generate_hydrogenate_protocol(
                "string": "OFF"
            }
        })
-
+        print("✅ 氢气源停止动作已添加")
+    
    # 10. 停止搅拌
+    print("📍 步骤10: 停止搅拌...")
    if stirrer_id:
        action_sequence.append({
            "device_id": stirrer_id,
            "action_name": "stop_stir",
            "action_kwargs": {
-                "vessel": {"id": vessel_id},
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
                "purpose": "氢化反应完成，停止搅拌"
            }
        })
-
-    # 氢化完成后的状态（氢化反应通常不改变体积）
-    final_liquid_volume = original_liquid_volume
-
+        print("✅ 停止搅拌动作已添加")
+    
+    # 🔧 新增：氢化完成后的状态（氢化反应通常不改变体积）
+    final_liquid_volume = original_liquid_volume  # 氢化反应体积基本不变
+    
    # 总结
-    debug_print(f"氢化反应协议生成完成: {len(action_sequence)} 个动作, "
-                f"vessel={vessel_id}, temp={temperature}°C, time={reaction_time/60:.1f}min, "
-                f"volume={original_liquid_volume:.2f}→{final_liquid_volume:.2f}mL")
-
+    print("🎊" * 20)
+    print(f"🎉 氢化反应协议生成完成! ✨")
+    print(f"📊 总动作数: {len(action_sequence)} 个")
+    print(f"🥽 反应容器: {vessel_id}")
+    print(f"🌡️ 反应温度: {temperature}°C")
+    print(f"⏰ 反应时间: {reaction_time/60:.1f}分钟")
+    print(f"⏱️ 预计总时间: {(reaction_time + 450)/3600:.1f} 小时")
+    print(f"📊 体积状态:")
+    print(f"  - 反应前体积: {original_liquid_volume:.2f}mL")
+    print(f"  - 反应后体积: {final_liquid_volume:.2f}mL (氢化反应体积基本不变)")
+    print("🎊" * 20)
+    
    return action_sequence
+
+
+# 测试函数
+def test_hydrogenate_protocol():
+    """测试氢化反应协议"""
+    print("🧪 === HYDROGENATE PROTOCOL 测试 === ✨")
+    
+    # 测试温度解析
+    test_temps = ["45 °C", "45°C", "45", "25 C", "invalid"]
+    for temp in test_temps:
+        parsed = parse_temperature(temp)
+        print(f"温度 '{temp}' -> {parsed}°C")
+    
+    # 测试时间解析
+    test_times = ["2 h", "120 min", "7200 s", "2", "invalid"]
+    for time in test_times:
+        parsed = parse_time(time)
+        print(f"时间 '{time}' -> {parsed/3600:.1f} 小时")
+    
+    print("✅ 测试完成 🎉")
+
+
+if __name__ == "__main__":
+    test_hydrogenate_protocol()
--- a/unilabos/compile/pump_protocol.py
+++ b/unilabos/compile/pump_protocol.py
@@ -2,18 +2,99 @@ import traceback
 import numpy as np
 import networkx as nx
 import asyncio
-import time as time_module  # 重命名time模块
+import time as time_module  # 🔧 重命名time模块
 from typing import List, Dict, Any
 import logging
 import sys

-from .utils.logger_util import debug_print
-from .utils.vessel_parser import get_vessel
-from .utils.resource_helper import get_resource_liquid_volume
+from unilabos.compile.utils.vessel_parser import get_vessel

 logger = logging.getLogger(__name__)


+def debug_print(message):
+    """强制输出调试信息"""
+    output = f"[TRANSFER] {message}"
+    logger.info(output)
+
+
+def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
+    """
+    从容器节点的数据中获取液体体积
+    """
+    debug_print(f"🔍 开始读取容器 '{vessel}' 的液体体积...")
+
+    if vessel not in G.nodes():
+        logger.error(f"❌ 容器 '{vessel}' 不存在于系统图中")
+        debug_print(f"  - 系统中的容器: {list(G.nodes())}")
+        return 0.0
+
+    vessel_data = G.nodes[vessel].get('data', {})
+    debug_print(f"📋 容器 '{vessel}' 的数据结构: {vessel_data}")
+
+    total_volume = 0.0
+
+    # 方法1：检查 'liquid' 字段（列表格式）
+    debug_print("🔍 方法1: 检查 'liquid' 字段...")
+    if 'liquid' in vessel_data:
+        liquids = vessel_data['liquid']
+        debug_print(f"  - liquid 字段类型: {type(liquids)}")
+        debug_print(f"  - liquid 字段内容: {liquids}")
+
+        if isinstance(liquids, list):
+            debug_print(f"  - liquid 是列表，包含 {len(liquids)} 个元素")
+            for i, liquid in enumerate(liquids):
+                debug_print(f"    液体 {i + 1}: {liquid}")
+                if isinstance(liquid, dict):
+                    volume_keys = ['liquid_volume', 'volume', 'amount', 'quantity']
+                    for key in volume_keys:
+                        if key in liquid:
+                            try:
+                                vol = float(liquid[key])
+                                total_volume += vol
+                                debug_print(f"    ✅ 从 '{key}' 读取体积: {vol}mL")
+                                break
+                            except (ValueError, TypeError) as e:
+                                logger.warning(f"    ⚠️ 无法转换 '{key}': {liquid[key]} -> {str(e)}")
+                                continue
+        else:
+            debug_print(f"  - liquid 不是列表: {type(liquids)}")
+    else:
+        debug_print("  - 没有 'liquid' 字段")
+
+    # 方法2：检查直接的体积字段
+    debug_print("🔍 方法2: 检查直接体积字段...")
+    volume_keys = ['total_volume', 'volume', 'liquid_volume', 'amount', 'current_volume']
+    for key in volume_keys:
+        if key in vessel_data:
+            try:
+                vol = float(vessel_data[key])
+                total_volume = max(total_volume, vol)  # 取最大值
+                debug_print(f"  ✅ 从容器数据 '{key}' 读取体积: {vol}mL")
+                break
+            except (ValueError, TypeError) as e:
+                logger.warning(f"  ⚠️ 无法转换 '{key}': {vessel_data[key]} -> {str(e)}")
+                continue
+
+    # 方法3：检查 'state' 或 'status' 字段
+    debug_print("🔍 方法3: 检查 'state' 字段...")
+    if 'state' in vessel_data and isinstance(vessel_data['state'], dict):
+        state = vessel_data['state']
+        debug_print(f"  - state 字段内容: {state}")
+        if 'volume' in state:
+            try:
+                vol = float(state['volume'])
+                total_volume = max(total_volume, vol)
+                debug_print(f"  ✅ 从容器状态读取体积: {vol}mL")
+            except (ValueError, TypeError) as e:
+                logger.warning(f"  ⚠️ 无法转换 state.volume: {state['volume']} -> {str(e)}")
+    else:
+        debug_print("  - 没有 'state' 字段或不是字典")
+
+    debug_print(f"📊 容器 '{vessel}' 最终检测体积: {total_volume}mL")
+    return total_volume
+
+
 def is_integrated_pump(node_class: str, node_name: str = "") -> bool:
    """
    判断是否为泵阀一体设备
@@ -41,77 +122,108 @@ def is_integrated_pump(node_class: str, node_name: str = "") -> bool:

 def find_connected_pump(G, valve_node):
    """
-    查找与阀门相连的泵节点
-    区分电磁阀和多通阀，电磁阀不参与泵查找
+    查找与阀门相连的泵节点 - 修复版本
+    🔧 修复：区分电磁阀和多通阀，电磁阀不参与泵查找
    """
-    # 检查节点类型，电磁阀不应该查找泵
+    debug_print(f"🔍 查找与阀门 {valve_node} 相连的泵...")
+
+    # 🔧 关键修复：检查节点类型，电磁阀不应该查找泵
    node_data = G.nodes.get(valve_node, {})
    node_class = node_data.get("class", "") or ""

+    debug_print(f"  - 阀门类型: {node_class}")
+
    # 如果是电磁阀，不应该查找泵（电磁阀只是开关）
    if ("solenoid" in node_class.lower() or "solenoid_valve" in valve_node.lower()):
+        debug_print(f"  ⚠️ {valve_node} 是电磁阀，不应该查找泵节点")
        raise ValueError(f"电磁阀 {valve_node} 不应该参与泵查找逻辑")

    # 只有多通阀等复杂阀门才需要查找连接的泵
    if ("multiway" in node_class.lower() or "valve" in node_class.lower()):
+        debug_print(f"  - {valve_node} 是多通阀，查找连接的泵...")
        # 方法1：直接相邻的泵
        for neighbor in G.neighbors(valve_node):
            neighbor_class = G.nodes[neighbor].get("class", "") or ""
+            # 排除非 电磁阀 和 泵 的邻居
+            debug_print(f"    - 检查邻居 {neighbor}, class: {neighbor_class}")
            if "pump" in neighbor_class.lower():
+                debug_print(f"    ✅ 找到直接相连的泵: {neighbor}")
                return neighbor

        # 方法2：通过路径查找泵（最多2跳）
-        pump_nodes = [
-            node_id for node_id in G.nodes()
-            if "pump" in (G.nodes[node_id].get("class", "") or "").lower()
-        ]
+        debug_print(f"    - 未找到直接相连的泵，尝试路径查找...")

+        # 获取所有泵节点
+        pump_nodes = []
+        for node_id in G.nodes():
+            node_class = G.nodes[node_id].get("class", "") or ""
+            if "pump" in node_class.lower():
+                pump_nodes.append(node_id)
+
+        debug_print(f"    - 系统中的泵节点: {pump_nodes}")
+
+        # 查找到泵的最短路径
        for pump_node in pump_nodes:
            try:
                if nx.has_path(G, valve_node, pump_node):
                    path = nx.shortest_path(G, valve_node, pump_node)
-                    if len(path) - 1 <= 2:  # 最多允许2跳
+                    path_length = len(path) - 1
+                    debug_print(f"    - 到泵 {pump_node} 的路径: {path}, 距离: {path_length}")
+
+                    if path_length <= 2:  # 最多允许2跳
+                        debug_print(f"    ✅ 通过路径找到泵: {pump_node}")
                        return pump_node
            except nx.NetworkXNoPath:
                continue

+    # 最终失败
+    debug_print(f"  ❌ 完全找不到泵节点")
    raise ValueError(f"未找到与阀 {valve_node} 相连的泵节点")


 def build_pump_valve_maps(G, pump_backbone):
    """
-    构建泵-阀门映射
-    过滤掉电磁阀，只处理需要泵的多通阀
+    构建泵-阀门映射 - 修复版本
+    🔧 修复：过滤掉电磁阀，只处理需要泵的多通阀
    """
    pumps_from_node = {}
    valve_from_node = {}

-    # 过滤掉电磁阀
+    debug_print(f"🔧 构建泵-阀门映射，原始骨架: {pump_backbone}")
+
+    # 🔧 关键修复：过滤掉电磁阀
    filtered_backbone = []
    for node in pump_backbone:
        node_data = G.nodes.get(node, {})
        node_class = node_data.get("class", "") or ""

+        # 跳过电磁阀
        if ("solenoid" in node_class.lower() or "solenoid_valve" in node.lower()):
+            debug_print(f"  - 跳过电磁阀: {node}")
            continue

        filtered_backbone.append(node)

+    debug_print(f"🔧 过滤后的骨架: {filtered_backbone}")
+
    for node in filtered_backbone:
        node_data = G.nodes.get(node, {})
        node_class = node_data.get("class", "") or ""
        if is_integrated_pump(node_class, node):
            pumps_from_node[node] = node
            valve_from_node[node] = node
+            debug_print(f"  - 集成泵-阀: {node}")
        else:
            try:
                pump_node = find_connected_pump(G, node)
                pumps_from_node[node] = pump_node
                valve_from_node[node] = node
-            except ValueError:
+                debug_print(f"  - 阀门 {node} -> 泵 {pump_node}")
+            except ValueError as e:
+                debug_print(f"  - 跳过节点 {node}: {str(e)}")
                continue

-    debug_print(f"泵-阀映射: pumps={pumps_from_node}, valves={valve_from_node}")
+    debug_print(f"🔧 最终映射: pumps={pumps_from_node}, valves={valve_from_node}")
    return pumps_from_node, valve_from_node


@@ -124,8 +236,8 @@ def generate_pump_protocol(
        transfer_flowrate: float = 0.5,
 ) -> List[Dict[str, Any]]:
    """
-    生成泵操作的动作序列
-    正确处理包含电磁阀的路径
+    生成泵操作的动作序列 - 修复版本
+    🔧 修复：正确处理包含电磁阀的路径
    """
    pump_action_sequence = []
    nodes = G.nodes(data=True)
@@ -144,6 +256,7 @@ def generate_pump_protocol(
        logger.warning(f"transfer_flowrate <= 0，使用默认值 {transfer_flowrate}mL/s")

    # 验证容器存在
+    debug_print(f"🔍 验证源容器 '{from_vessel_id}' 和目标容器 '{to_vessel_id}' 是否存在...")
    if from_vessel_id not in G.nodes():
        logger.error(f"源容器 '{from_vessel_id}' 不存在")
        return pump_action_sequence
@@ -159,24 +272,28 @@ def generate_pump_protocol(
        logger.error(f"无法找到从 '{from_vessel_id}' 到 '{to_vessel_id}' 的路径")
        return pump_action_sequence

-    # 正确构建泵骨架，排除容器和电磁阀
+    # 🔧 关键修复：正确构建泵骨架，排除容器和电磁阀
    pump_backbone = []
    for node in shortest_path:
+        # 跳过起始和结束容器
        if node == from_vessel_id or node == to_vessel_id:
            continue

+        # 跳过电磁阀（电磁阀不参与泵操作）
        node_data = G.nodes.get(node, {})
        node_class = node_data.get("class", "") or ""
        if ("solenoid" in node_class.lower() or "solenoid_valve" in node.lower()):
+            debug_print(f"PUMP_TRANSFER: 跳过电磁阀 {node}")
            continue

+        # 只包含多通阀和泵
        if ("multiway" in node_class.lower() or "valve" in node_class.lower() or "pump" in node_class.lower()):
            pump_backbone.append(node)

-    debug_print(f"PUMP_TRANSFER: 泵骨架: {pump_backbone}")
+    debug_print(f"PUMP_TRANSFER: 过滤后的泵骨架: {pump_backbone}")

    if not pump_backbone:
-        debug_print("PUMP_TRANSFER: 没有泵骨架节点")
+        debug_print("PUMP_TRANSFER: 没有泵骨架节点，可能是直接容器连接或只有电磁阀")
        return pump_action_sequence

    if transfer_flowrate == 0:
@@ -192,7 +309,7 @@ def generate_pump_protocol(
        debug_print("PUMP_TRANSFER: 没有可用的泵映射")
        return pump_action_sequence

-    # 安全地获取最小转移体积
+    # 🔧 修复：安全地获取最小转移体积
    try:
        min_transfer_volumes = []
        for node in pump_backbone:
@@ -222,19 +339,19 @@ def generate_pump_protocol(
    volume_left = volume
    debug_print(f"PUMP_TRANSFER: 需要 {repeats} 次转移，单次最大体积 {min_transfer_volume} mL")

-    # 只在开头打印总体概览
+    # 🆕 只在开头打印总体概览
    if repeats > 1:
-        debug_print(f"分批转移: 总体积 {volume:.2f}mL, {repeats} 次, 单次最大 {min_transfer_volume} mL")
-        logger.info(f"分批转移: 总体积 {volume:.2f}mL, {repeats} 次转移")
+        debug_print(f"🔄 分批转移概览: 总体积 {volume:.2f}mL，需要 {repeats} 次转移")
+        logger.info(f"🔄 分批转移概览: 总体积 {volume:.2f}mL，需要 {repeats} 次转移")

-    # 创建一个自定义的wait动作，用于在执行时打印日志
+    # 🔧 创建一个自定义的wait动作，用于在执行时打印日志
    def create_progress_log_action(message: str) -> Dict[str, Any]:
        """创建一个特殊的等待动作，在执行时打印进度日志"""
        return {
            "action_name": "wait",
            "action_kwargs": {
-                "time": 0.1,
-                "progress_message": message
+                "time": 0.1,  # 很短的等待时间
+                "progress_message": message  # 自定义字段，用于进度日志
            }
        }

@@ -242,12 +359,12 @@ def generate_pump_protocol(
    for i in range(repeats):
        current_volume = min(volume_left, min_transfer_volume)

+        # 🆕 在每次循环开始时添加进度日志
        if repeats > 1:
-            pump_action_sequence.append(create_progress_log_action(
-                f"第 {i + 1}/{repeats} 次转移: {current_volume:.2f}mL ({from_vessel_id} -> {to_vessel_id})"
-            ))
+            start_message = f"🚀 准备开始第 {i + 1}/{repeats} 次转移: {current_volume:.2f}mL ({from_vessel_id} → {to_vessel_id}) 🚰"
+            pump_action_sequence.append(create_progress_log_action(start_message))

-        # 安全地获取边数据
+        # 🔧 修复：安全地获取边数据
        def get_safe_edge_data(node_a, node_b, key):
            try:
                edge_data = G.get_edge_data(node_a, node_b)
@@ -350,13 +467,13 @@ def generate_pump_protocol(
                ])
                pump_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 3}})

-        # 在每次循环结束时添加完成日志
+        # 🆕 在每次循环结束时添加完成日志
        if repeats > 1:
            remaining_volume = volume_left - current_volume
            if remaining_volume > 0:
-                end_message = f"第 {i + 1}/{repeats} 次完成, 剩余 {remaining_volume:.2f}mL"
+                end_message = f"✅ 第 {i + 1}/{repeats} 次转移完成! 剩余 {remaining_volume:.2f}mL 待转移 ⏳"
            else:
-                end_message = f"第 {i + 1}/{repeats} 次完成, 全部 {volume:.2f}mL 转移完毕"
+                end_message = f"🎉 第 {i + 1}/{repeats} 次转移完成! 全部 {volume:.2f}mL 转移完毕 ✨"

            pump_action_sequence.append(create_progress_log_action(end_message))

@@ -398,205 +515,300 @@ def generate_pump_protocol_with_rinsing(
    to_vessel_id, _ = get_vessel(to_vessel)

    with generate_pump_protocol_with_rinsing._lock:
-        debug_print(f"PUMP_TRANSFER: {from_vessel_id} -> {to_vessel_id}, volume={volume}, flowrate={flowrate}")
+        debug_print("=" * 60)
+        debug_print(f"PUMP_TRANSFER: 🚀 开始生成协议 (同步版本)")
+        debug_print(f"  📍 路径: {from_vessel_id} -> {to_vessel_id}")
+        debug_print(f"  🕐 时间戳: {time_module.time()}")
+        debug_print(f"  🔒 获得执行锁")
+        debug_print("=" * 60)

        # 短暂延迟，避免快速重复调用
        time_module.sleep(0.01)

+        debug_print("🔍 步骤1: 开始体积处理...")
+
        # 1. 处理体积参数
        final_volume = volume
+        debug_print(f"📋 初始设置: final_volume = {final_volume}")

-        # 如果volume为0，从容器读取实际体积
+        # 🔧 修复：如果volume为0（ROS2传入的空值），从容器读取实际体积
        if volume == 0.0:
+            debug_print("🎯 检测到 volume=0.0，开始自动体积检测...")

-            actual_volume = get_resource_liquid_volume(G.nodes.get(from_vessel_id, {}))
+            # 直接从源容器读取实际体积
+            actual_volume = get_vessel_liquid_volume(G, from_vessel_id)
+            debug_print(f"📖 从容器 '{from_vessel_id}' 读取到体积: {actual_volume}mL")

            if actual_volume > 0:
                final_volume = actual_volume
+                debug_print(f"✅ 成功设置体积为: {final_volume}mL")
            else:
-                final_volume = 10.0
-                logger.warning(f"无法从容器读取体积，使用默认值: {final_volume}mL")
+                final_volume = 10.0  # 如果读取失败，使用默认值
+                logger.warning(f"⚠️ 无法从容器读取体积，使用默认值: {final_volume}mL")
+        else:
+            debug_print(f"📌 体积非零，直接使用: {final_volume}mL")
+
        # 处理 amount 参数
        if amount and amount.strip():
+            debug_print(f"🔍 检测到 amount 参数: '{amount}'，开始解析...")
            parsed_volume = _parse_amount_to_volume(amount)
+            debug_print(f"📖 从 amount 解析得到体积: {parsed_volume}mL")

            if parsed_volume > 0:
                final_volume = parsed_volume
+                debug_print(f"✅ 使用从 amount 解析的体积: {final_volume}mL")
            elif parsed_volume == 0.0 and amount.lower().strip() == "all":
-                actual_volume = get_resource_liquid_volume(G.nodes.get(from_vessel_id, {}))
+                debug_print("🎯 检测到 amount='all'，从容器读取全部体积...")
+                actual_volume = get_vessel_liquid_volume(G, from_vessel_id)
                if actual_volume > 0:
                    final_volume = actual_volume
+                    debug_print(f"✅ amount='all'，设置体积为: {final_volume}mL")

        # 最终体积验证
+        debug_print(f"🔍 步骤2: 最终体积验证...")
        if final_volume <= 0:
-            logger.error(f"体积无效: {final_volume}mL")
+            logger.error(f"❌ 体积无效: {final_volume}mL")
            final_volume = 10.0
-            logger.warning(f"强制设置为默认值: {final_volume}mL")
+            logger.warning(f"⚠️ 强制设置为默认值: {final_volume}mL")

-        debug_print(f"最终体积: {final_volume}mL")
+        debug_print(f"✅ 最终确定体积: {final_volume}mL")

        # 2. 处理流速参数
+        debug_print(f"🔍 步骤3: 处理流速参数...")
+        debug_print(f"  - 原始 flowrate: {flowrate}")
+        debug_print(f"  - 原始 transfer_flowrate: {transfer_flowrate}")
+
        final_flowrate = flowrate if flowrate > 0 else 2.5
        final_transfer_flowrate = transfer_flowrate if transfer_flowrate > 0 else 0.5

        if flowrate <= 0:
-            logger.warning(f"flowrate <= 0，修正为: {final_flowrate}mL/s")
+            logger.warning(f"⚠️ flowrate <= 0，修正为: {final_flowrate}mL/s")
        if transfer_flowrate <= 0:
-            logger.warning(f"transfer_flowrate <= 0，修正为: {final_transfer_flowrate}mL/s")
+            logger.warning(f"⚠️ transfer_flowrate <= 0，修正为: {final_transfer_flowrate}mL/s")
+
+        debug_print(f"✅ 修正后流速: flowrate={final_flowrate}mL/s, transfer_flowrate={final_transfer_flowrate}mL/s")

        # 3. 根据时间计算流速
        if time > 0 and final_volume > 0:
+            debug_print(f"🔍 步骤4: 根据时间计算流速...")
            calculated_flowrate = final_volume / time
+            debug_print(f"  - 计算得到流速: {calculated_flowrate}mL/s")

            if flowrate <= 0 or flowrate == 2.5:
                final_flowrate = min(calculated_flowrate, 10.0)
+                debug_print(f"  - 调整 flowrate 为: {final_flowrate}mL/s")
            if transfer_flowrate <= 0 or transfer_flowrate == 0.5:
                final_transfer_flowrate = min(calculated_flowrate, 5.0)
+                debug_print(f"  - 调整 transfer_flowrate 为: {final_transfer_flowrate}mL/s")

        # 4. 根据速度规格调整
        if rate_spec:
+            debug_print(f"🔍 步骤5: 根据速度规格调整...")
+            debug_print(f"  - 速度规格: '{rate_spec}'")
+
            if rate_spec == "dropwise":
                final_flowrate = min(final_flowrate, 0.1)
                final_transfer_flowrate = min(final_transfer_flowrate, 0.1)
+                debug_print(f"  - dropwise模式，流速调整为: {final_flowrate}mL/s")
            elif rate_spec == "slowly":
                final_flowrate = min(final_flowrate, 0.5)
                final_transfer_flowrate = min(final_transfer_flowrate, 0.3)
+                debug_print(f"  - slowly模式，流速调整为: {final_flowrate}mL/s")
            elif rate_spec == "quickly":
                final_flowrate = max(final_flowrate, 5.0)
                final_transfer_flowrate = max(final_transfer_flowrate, 2.0)
-            debug_print(f"速度规格 '{rate_spec}': flowrate={final_flowrate}, transfer={final_transfer_flowrate}")
+                debug_print(f"  - quickly模式，流速调整为: {final_flowrate}mL/s")

    # 5. 处理冲洗参数
+    debug_print(f"🔍 步骤6: 处理冲洗参数...")
    final_rinsing_solvent = rinsing_solvent
    final_rinsing_volume = rinsing_volume if rinsing_volume > 0 else 5.0
    final_rinsing_repeats = rinsing_repeats if rinsing_repeats > 0 else 2

    if rinsing_volume <= 0:
-        logger.warning(f"rinsing_volume <= 0，修正为: {final_rinsing_volume}mL")
+        logger.warning(f"⚠️ rinsing_volume <= 0，修正为: {final_rinsing_volume}mL")
    if rinsing_repeats <= 0:
-        logger.warning(f"rinsing_repeats <= 0，修正为: {final_rinsing_repeats}次")
+        logger.warning(f"⚠️ rinsing_repeats <= 0，修正为: {final_rinsing_repeats}次")

    # 根据物理属性调整冲洗参数
    if viscous or solid:
        final_rinsing_repeats = max(final_rinsing_repeats, 3)
        final_rinsing_volume = max(final_rinsing_volume, 10.0)
+        debug_print(f"🧪 粘稠/固体物质，调整冲洗参数：{final_rinsing_repeats}次，{final_rinsing_volume}mL")

    # 参数总结
-    debug_print(f"最终参数: volume={final_volume}mL, flowrate={final_flowrate}mL/s, "
-                f"transfer_flowrate={final_transfer_flowrate}mL/s, "
-                f"rinsing={final_rinsing_solvent}/{final_rinsing_volume}mL/{final_rinsing_repeats}次")
+    debug_print("📊 最终参数总结:")
+    debug_print(f"  - 体积: {final_volume}mL")
+    debug_print(f"  - 流速: {final_flowrate}mL/s")
+    debug_print(f"  - 转移流速: {final_transfer_flowrate}mL/s")
+    debug_print(f"  - 冲洗溶剂: '{final_rinsing_solvent}'")
+    debug_print(f"  - 冲洗体积: {final_rinsing_volume}mL")
+    debug_print(f"  - 冲洗次数: {final_rinsing_repeats}次")
+
+    # ========== 执行基础转移 ==========
+
+    debug_print("🔧 步骤7: 开始执行基础转移...")

-    # 执行基础转移
    try:
+        debug_print(f"  - 调用 generate_pump_protocol...")
+        debug_print(
+            f"  - 参数: G, '{from_vessel_id}', '{to_vessel_id}', {final_volume}, {final_flowrate}, {final_transfer_flowrate}")

        pump_action_sequence = generate_pump_protocol(
            G, from_vessel_id, to_vessel_id, final_volume,
            final_flowrate, final_transfer_flowrate
        )

-        debug_print(f"基础转移生成了 {len(pump_action_sequence)} 个动作")
+        debug_print(f"  - generate_pump_protocol 返回结果:")
+        debug_print(f"    - 动作序列长度: {len(pump_action_sequence)}")
+        debug_print(f"    - 动作序列是否为空: {len(pump_action_sequence) == 0}")

        if not pump_action_sequence:
-            debug_print("基础转移协议为空")
+            debug_print("❌ 基础转移协议生成为空，可能是路径问题")
+            debug_print(f"  - 源容器存在: {from_vessel_id in G.nodes()}")
+            debug_print(f"  - 目标容器存在: {to_vessel_id in G.nodes()}")

            if from_vessel_id in G.nodes() and to_vessel_id in G.nodes():
                try:
                    path = nx.shortest_path(G, source=from_vessel_id, target=to_vessel_id)
-                    debug_print(f"路径存在: {path}")
-                except Exception:
-                    pass
+                    debug_print(f"  - 路径存在: {path}")
+                except Exception as path_error:
+                    debug_print(f"  - 无法找到路径: {str(path_error)}")

            return [
                {
                    "device_id": "system",
                    "action_name": "log_message",
                    "action_kwargs": {
-                        "message": f"路径问题，无法转移: {final_volume}mL 从 {from_vessel_id} 到 {to_vessel_id}"
+                        "message": f"⚠️ 路径问题，无法转移: {final_volume}mL 从 {from_vessel_id} 到 {to_vessel_id}"
                    }
                }
            ]

+        debug_print(f"✅ 基础转移生成了 {len(pump_action_sequence)} 个动作")
+
+        # 打印前几个动作用于调试
+        if len(pump_action_sequence) > 0:
+            debug_print("🔍 前几个动作预览:")
+            for i, action in enumerate(pump_action_sequence[:3]):
+                debug_print(f"  动作 {i + 1}: {action}")
+            if len(pump_action_sequence) > 3:
+                debug_print(f"  ... 还有 {len(pump_action_sequence) - 3} 个动作")
+
    except Exception as e:
-        debug_print(f"基础转移失败: {str(e)}\n{traceback.format_exc()}")
+        debug_print(f"❌ 基础转移失败: {str(e)}")
+        import traceback
+        debug_print(f"详细错误: {traceback.format_exc()}")
        return [
            {
                "device_id": "system",
                "action_name": "log_message",
                "action_kwargs": {
-                    "message": f"转移失败: {final_volume}mL 从 {from_vessel_id} 到 {to_vessel_id}, 错误: {str(e)}"
+                    "message": f"❌ 转移失败: {final_volume}mL 从 {from_vessel_id} 到 {to_vessel_id}, 错误: {str(e)}"
                }
            }
        ]

-    # 执行冲洗操作
+    # ========== 执行冲洗操作 ==========
+
+    debug_print("🔧 步骤8: 检查冲洗操作...")
+
    if final_rinsing_solvent and final_rinsing_solvent.strip() and final_rinsing_repeats > 0:
+        debug_print(f"🧽 开始冲洗操作，溶剂: '{final_rinsing_solvent}'")

        try:
            if final_rinsing_solvent.strip() != "air":
+                debug_print("  - 执行液体冲洗...")
                rinsing_actions = _generate_rinsing_sequence(
                    G, from_vessel_id, to_vessel_id, final_rinsing_solvent,
                    final_rinsing_volume, final_rinsing_repeats,
                    final_flowrate, final_transfer_flowrate
                )
                pump_action_sequence.extend(rinsing_actions)
+                debug_print(f"  - 添加了 {len(rinsing_actions)} 个冲洗动作")
            else:
+                debug_print("  - 执行空气冲洗...")
                air_rinsing_actions = _generate_air_rinsing_sequence(
                    G, from_vessel_id, to_vessel_id, final_rinsing_volume, final_rinsing_repeats,
                    final_flowrate, final_transfer_flowrate
                )
                pump_action_sequence.extend(air_rinsing_actions)
+                debug_print(f"  - 添加了 {len(air_rinsing_actions)} 个空气冲洗动作")
        except Exception as e:
-            debug_print(f"冲洗操作失败: {str(e)}")
+            debug_print(f"⚠️ 冲洗操作失败: {str(e)}，跳过冲洗")
    else:
-        debug_print(f"跳过冲洗 (solvent='{final_rinsing_solvent}', repeats={final_rinsing_repeats})")
+        debug_print(f"⏭️ 跳过冲洗操作")
+        debug_print(f"  - 溶剂: '{final_rinsing_solvent}'")
+        debug_print(f"  - 次数: {final_rinsing_repeats}")
+        debug_print(f"  - 条件满足: {bool(final_rinsing_solvent and final_rinsing_solvent.strip() and final_rinsing_repeats > 0)}")

-    # 最终结果
-    debug_print(f"PUMP_TRANSFER 完成: {from_vessel_id} -> {to_vessel_id}, "
-                f"volume={final_volume}mL, 动作数={len(pump_action_sequence)}")
+    # ========== 最终结果 ==========
+
+    debug_print("=" * 60)
+    debug_print(f"🎉 PUMP_TRANSFER: 协议生成完成")
+    debug_print(f"  📊 总动作数: {len(pump_action_sequence)}")
+    debug_print(f"  📋 最终体积: {final_volume}mL")
+    debug_print(f"  🚀 执行路径: {from_vessel_id} -> {to_vessel_id}")

    # 最终验证
    if len(pump_action_sequence) == 0:
+        debug_print("🚨 协议生成结果为空！这是异常情况")
        return [
            {
                "device_id": "system",
                "action_name": "log_message",
                "action_kwargs": {
-                    "message": "协议生成失败: 无法生成任何动作序列"
+                    "message": f"🚨 协议生成失败: 无法生成任何动作序列"
                }
            }
        ]

+    debug_print("=" * 60)
    return pump_action_sequence


 def _parse_amount_to_volume(amount: str) -> float:
    """解析 amount 字符串为体积"""
+    debug_print(f"🔍 解析 amount: '{amount}'")
+
    if not amount:
+        debug_print("  - amount 为空，返回 0.0")
        return 0.0

    amount = amount.lower().strip()
+    debug_print(f"  - 处理后的 amount: '{amount}'")

    # 处理特殊关键词
    if amount == "all":
+        debug_print("  - 检测到 'all'，返回 0.0（需要后续处理）")
        return 0.0  # 返回0.0，让调用者处理

    # 提取数字
    import re
    numbers = re.findall(r'[\d.]+', amount)
+    debug_print(f"  - 提取到的数字: {numbers}")

    if numbers:
        volume = float(numbers[0])
+        debug_print(f"  - 基础体积: {volume}")

        # 单位转换
        if 'ml' in amount or 'milliliter' in amount:
+            debug_print(f"  - 单位: mL，最终体积: {volume}")
            return volume
        elif 'l' in amount and 'ml' not in amount:
-            return volume * 1000
+            final_volume = volume * 1000
+            debug_print(f"  - 单位: L，最终体积: {final_volume}mL")
+            return final_volume
        elif 'μl' in amount or 'microliter' in amount:
-            return volume / 1000
+            final_volume = volume / 1000
+            debug_print(f"  - 单位: μL，最终体积: {final_volume}mL")
+            return final_volume
        else:
-            return volume  # 默认mL
+            debug_print(f"  - 无单位，假设为 mL: {volume}")
+            return volume

+    debug_print("  - 无法解析，返回 0.0")
    return 0.0


--- a/unilabos/compile/recrystallize_protocol.py
+++ b/unilabos/compile/recrystallize_protocol.py
@@ -4,64 +4,76 @@ import logging
 from typing import List, Dict, Any, Tuple, Union
 from .utils.vessel_parser import get_vessel, find_solvent_vessel
 from .utils.unit_parser import parse_volume_input
-from .utils.logger_util import debug_print
 from .pump_protocol import generate_pump_protocol_with_rinsing

 logger = logging.getLogger(__name__)

+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[RECRYSTALLIZE] {message}")
+

 def parse_ratio(ratio_str: str) -> Tuple[float, float]:
    """
    解析比例字符串，支持多种格式
-
+    
    Args:
        ratio_str: 比例字符串（如 "1:1", "3:7", "50:50"）
-
+    
    Returns:
        Tuple[float, float]: 比例元组 (ratio1, ratio2)
    """
+    debug_print(f"⚖️ 开始解析比例: '{ratio_str}' 📊")
+    
    try:
+        # 处理 "1:1", "3:7", "50:50" 等格式
        if ":" in ratio_str:
            parts = ratio_str.split(":")
            if len(parts) == 2:
                ratio1 = float(parts[0])
                ratio2 = float(parts[1])
+                debug_print(f"✅ 冒号格式解析成功: {ratio1}:{ratio2} 🎯")
                return ratio1, ratio2
-
+        
+        # 处理 "1-1", "3-7" 等格式
        if "-" in ratio_str:
            parts = ratio_str.split("-")
            if len(parts) == 2:
                ratio1 = float(parts[0])
                ratio2 = float(parts[1])
+                debug_print(f"✅ 横线格式解析成功: {ratio1}:{ratio2} 🎯")
                return ratio1, ratio2
-
+        
+        # 处理 "1,1", "3,7" 等格式
        if "," in ratio_str:
            parts = ratio_str.split(",")
            if len(parts) == 2:
                ratio1 = float(parts[0])
                ratio2 = float(parts[1])
+                debug_print(f"✅ 逗号格式解析成功: {ratio1}:{ratio2} 🎯")
                return ratio1, ratio2
-
-        debug_print(f"无法解析比例 '{ratio_str}'，使用默认比例 1:1")
+        
+        # 默认 1:1
+        debug_print(f"⚠️ 无法解析比例 '{ratio_str}'，使用默认比例 1:1 🎭")
        return 1.0, 1.0
-
+    
    except ValueError:
-        debug_print(f"比例解析错误 '{ratio_str}'，使用默认比例 1:1")
+        debug_print(f"❌ 比例解析错误 '{ratio_str}'，使用默认比例 1:1 🎭")
        return 1.0, 1.0


 def generate_recrystallize_protocol(
    G: nx.DiGraph,
-    vessel: dict,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
    ratio: str,
    solvent1: str,
    solvent2: str,
-    volume: Union[str, float],
+    volume: Union[str, float],  # 支持字符串和数值
    **kwargs
 ) -> List[Dict[str, Any]]:
    """
    生成重结晶协议序列 - 支持vessel字典和体积运算
-
+    
    Args:
        G: 有向图，节点为容器和设备
        vessel: 目标容器字典（从XDL传入）
@@ -70,18 +82,28 @@ def generate_recrystallize_protocol(
        solvent2: 第二种溶剂名称
        volume: 总体积（支持 "100 mL", "50", "2.5 L" 等）
        **kwargs: 其他可选参数
-
+    
    Returns:
        List[Dict[str, Any]]: 动作序列
    """
-
+    
+    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, vessel_data = get_vessel(vessel)
-
+    
    action_sequence = []
-
-    debug_print(f"开始生成重结晶协议: vessel={vessel_id}, ratio={ratio}, solvent1={solvent1}, solvent2={solvent2}, volume={volume}")
-
-    # 记录重结晶前的容器状态
+    
+    debug_print("💎" * 20)
+    debug_print("🚀 开始生成重结晶协议（支持vessel字典和体积运算）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  ⚖️ 比例: {ratio}")
+    debug_print(f"  🧪 溶剂1: {solvent1}")
+    debug_print(f"  🧪 溶剂2: {solvent2}")
+    debug_print(f"  💧 总体积: {volume} (类型: {type(volume)})")
+    debug_print("💎" * 20)
+    
+    # 🔧 新增：记录重结晶前的容器状态
+    debug_print("🔍 记录重结晶前容器状态...")
    original_liquid_volume = 0.0
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
@@ -89,73 +111,102 @@ def generate_recrystallize_protocol(
            original_liquid_volume = current_volume[0]
        elif isinstance(current_volume, (int, float)):
            original_liquid_volume = current_volume
-
+    debug_print(f"📊 重结晶前液体体积: {original_liquid_volume:.2f}mL")
+    
    # 1. 验证目标容器存在
-    if vessel_id not in G.nodes():
+    debug_print("📍 步骤1: 验证目标容器... 🔧")
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print(f"❌ 目标容器 '{vessel_id}' 不存在于系统中! 😱")
        raise ValueError(f"目标容器 '{vessel_id}' 不存在于系统中")
-
+    debug_print(f"✅ 目标容器 '{vessel_id}' 验证通过 🎯")
+    
    # 2. 解析体积（支持单位）
+    debug_print("📍 步骤2: 解析体积（支持单位）... 💧")
    final_volume = parse_volume_input(volume, "mL")
-    debug_print(f"体积解析: {volume} -> {final_volume}mL")
-
+    debug_print(f"🎯 体积解析完成: {volume} → {final_volume}mL ✨")
+    
    # 3. 解析比例
+    debug_print("📍 步骤3: 解析比例... ⚖️")
    ratio1, ratio2 = parse_ratio(ratio)
    total_ratio = ratio1 + ratio2
-
+    debug_print(f"🎯 比例解析完成: {ratio1}:{ratio2} (总比例: {total_ratio}) ✨")
+    
    # 4. 计算各溶剂体积
+    debug_print("📍 步骤4: 计算各溶剂体积... 🧮")
    volume1 = final_volume * (ratio1 / total_ratio)
    volume2 = final_volume * (ratio2 / total_ratio)
-
-    debug_print(f"溶剂体积: {solvent1}={volume1:.2f}mL, {solvent2}={volume2:.2f}mL")
-
+    
+    debug_print(f"🧪 {solvent1} 体积: {volume1:.2f} mL ({ratio1}/{total_ratio} × {final_volume})")
+    debug_print(f"🧪 {solvent2} 体积: {volume2:.2f} mL ({ratio2}/{total_ratio} × {final_volume})")
+    debug_print(f"✅ 体积计算完成: 总计 {volume1 + volume2:.2f} mL 🎯")
+    
    # 5. 查找溶剂容器
+    debug_print("📍 步骤5: 查找溶剂容器... 🔍")
    try:
+        debug_print(f"  🔍 查找溶剂1容器...")
        solvent1_vessel = find_solvent_vessel(G, solvent1)
+        debug_print(f"  🎉 找到溶剂1容器: {solvent1_vessel} ✨")
    except ValueError as e:
+        debug_print(f"  ❌ 溶剂1容器查找失败: {str(e)} 😭")
        raise ValueError(f"无法找到溶剂1 '{solvent1}': {str(e)}")
-
+    
    try:
+        debug_print(f"  🔍 查找溶剂2容器...")
        solvent2_vessel = find_solvent_vessel(G, solvent2)
+        debug_print(f"  🎉 找到溶剂2容器: {solvent2_vessel} ✨")
    except ValueError as e:
+        debug_print(f"  ❌ 溶剂2容器查找失败: {str(e)} 😭")
        raise ValueError(f"无法找到溶剂2 '{solvent2}': {str(e)}")
-
+    
    # 6. 验证路径存在
+    debug_print("📍 步骤6: 验证传输路径... 🛤️")
    try:
-        path1 = nx.shortest_path(G, source=solvent1_vessel, target=vessel_id)
+        path1 = nx.shortest_path(G, source=solvent1_vessel, target=vessel_id)  # 🔧 使用 vessel_id
+        debug_print(f"  🛤️ 溶剂1路径: {' → '.join(path1)} ✅")
    except nx.NetworkXNoPath:
+        debug_print(f"  ❌ 溶剂1路径不可达: {solvent1_vessel} → {vessel_id} 😞")
        raise ValueError(f"从溶剂1容器 '{solvent1_vessel}' 到目标容器 '{vessel_id}' 没有可用路径")
-
+    
    try:
-        path2 = nx.shortest_path(G, source=solvent2_vessel, target=vessel_id)
+        path2 = nx.shortest_path(G, source=solvent2_vessel, target=vessel_id)  # 🔧 使用 vessel_id
+        debug_print(f"  🛤️ 溶剂2路径: {' → '.join(path2)} ✅")
    except nx.NetworkXNoPath:
+        debug_print(f"  ❌ 溶剂2路径不可达: {solvent2_vessel} → {vessel_id} 😞")
        raise ValueError(f"从溶剂2容器 '{solvent2_vessel}' 到目标容器 '{vessel_id}' 没有可用路径")
-
+    
    # 7. 添加第一种溶剂
+    debug_print("📍 步骤7: 添加第一种溶剂... 🧪")
+    debug_print(f"  🚰 开始添加溶剂1: {solvent1} ({volume1:.2f} mL)")
+    
    try:
        pump_actions1 = generate_pump_protocol_with_rinsing(
            G=G,
            from_vessel=solvent1_vessel,
-            to_vessel=vessel_id,
-            volume=volume1,
+            to_vessel=vessel_id,  # 🔧 使用 vessel_id
+            volume=volume1,             # 使用解析后的体积
            amount="",
            time=0.0,
            viscous=False,
-            rinsing_solvent="",
+            rinsing_solvent="",  # 重结晶不需要清洗
            rinsing_volume=0.0,
            rinsing_repeats=0,
            solid=False,
-            flowrate=2.0,
+            flowrate=2.0,  # 正常流速
            transfer_flowrate=0.5
        )
-
+        
        action_sequence.extend(pump_actions1)
-
+        debug_print(f"  ✅ 溶剂1泵送动作已添加: {len(pump_actions1)} 个动作 🚰✨")
+        
    except Exception as e:
+        debug_print(f"  ❌ 溶剂1泵协议生成失败: {str(e)} 😭")
        raise ValueError(f"生成溶剂1泵协议时出错: {str(e)}")
-
-    # 更新容器体积 - 添加溶剂1后
+    
+    # 🔧 新增：更新容器体积 - 添加溶剂1后
+    debug_print("  🔧 更新容器体积 - 添加溶剂1后...")
    new_volume_after_solvent1 = original_liquid_volume + volume1
-
+    
+    # 更新vessel字典中的体积
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
        if isinstance(current_volume, list):
@@ -165,14 +216,15 @@ def generate_recrystallize_protocol(
                vessel["data"]["liquid_volume"] = [new_volume_after_solvent1]
        else:
            vessel["data"]["liquid_volume"] = new_volume_after_solvent1
-
+    
+    # 同时更新图中的容器数据
    if vessel_id in G.nodes():
        if 'data' not in G.nodes[vessel_id]:
            G.nodes[vessel_id]['data'] = {}
-
+        
        vessel_node_data = G.nodes[vessel_id]['data']
        current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
-
+        
        if isinstance(current_node_volume, list):
            if len(current_node_volume) > 0:
                G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume_after_solvent1
@@ -180,42 +232,53 @@ def generate_recrystallize_protocol(
                G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume_after_solvent1]
        else:
            G.nodes[vessel_id]['data']['liquid_volume'] = new_volume_after_solvent1
-
+    
+    debug_print(f"  📊 体积更新: {original_liquid_volume:.2f}mL + {volume1:.2f}mL = {new_volume_after_solvent1:.2f}mL")
+    
    # 8. 等待溶剂1稳定
+    debug_print("  ⏳ 添加溶剂1稳定等待...")
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {
-            "time": 5.0,
+            "time": 5.0,  # 缩短等待时间
            "description": f"等待溶剂1 {solvent1} 稳定"
        }
    })
-
+    debug_print("  ✅ 溶剂1稳定等待已添加 ⏰✨")
+    
    # 9. 添加第二种溶剂
+    debug_print("📍 步骤8: 添加第二种溶剂... 🧪")
+    debug_print(f"  🚰 开始添加溶剂2: {solvent2} ({volume2:.2f} mL)")
+    
    try:
        pump_actions2 = generate_pump_protocol_with_rinsing(
            G=G,
            from_vessel=solvent2_vessel,
-            to_vessel=vessel_id,
-            volume=volume2,
+            to_vessel=vessel_id,  # 🔧 使用 vessel_id
+            volume=volume2,             # 使用解析后的体积
            amount="",
            time=0.0,
            viscous=False,
-            rinsing_solvent="",
+            rinsing_solvent="",  # 重结晶不需要清洗
            rinsing_volume=0.0,
            rinsing_repeats=0,
            solid=False,
-            flowrate=2.0,
+            flowrate=2.0,  # 正常流速
            transfer_flowrate=0.5
        )
-
+        
        action_sequence.extend(pump_actions2)
-
+        debug_print(f"  ✅ 溶剂2泵送动作已添加: {len(pump_actions2)} 个动作 🚰✨")
+        
    except Exception as e:
+        debug_print(f"  ❌ 溶剂2泵协议生成失败: {str(e)} 😭")
        raise ValueError(f"生成溶剂2泵协议时出错: {str(e)}")
-
-    # 更新容器体积 - 添加溶剂2后
+    
+    # 🔧 新增：更新容器体积 - 添加溶剂2后
+    debug_print("  🔧 更新容器体积 - 添加溶剂2后...")
    final_liquid_volume = new_volume_after_solvent1 + volume2
-
+    
+    # 更新vessel字典中的体积
    if "data" in vessel and "liquid_volume" in vessel["data"]:
        current_volume = vessel["data"]["liquid_volume"]
        if isinstance(current_volume, list):
@@ -225,14 +288,15 @@ def generate_recrystallize_protocol(
                vessel["data"]["liquid_volume"] = [final_liquid_volume]
        else:
            vessel["data"]["liquid_volume"] = final_liquid_volume
-
+    
+    # 同时更新图中的容器数据
    if vessel_id in G.nodes():
        if 'data' not in G.nodes[vessel_id]:
            G.nodes[vessel_id]['data'] = {}
-
+        
        vessel_node_data = G.nodes[vessel_id]['data']
        current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
-
+        
        if isinstance(current_node_volume, list):
            if len(current_node_volume) > 0:
                G.nodes[vessel_id]['data']['liquid_volume'][0] = final_liquid_volume
@@ -240,25 +304,36 @@ def generate_recrystallize_protocol(
                G.nodes[vessel_id]['data']['liquid_volume'] = [final_liquid_volume]
        else:
            G.nodes[vessel_id]['data']['liquid_volume'] = final_liquid_volume
-
+    
+    debug_print(f"  📊 最终体积: {new_volume_after_solvent1:.2f}mL + {volume2:.2f}mL = {final_liquid_volume:.2f}mL")
+    
    # 10. 等待溶剂2稳定
+    debug_print("  ⏳ 添加溶剂2稳定等待...")
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {
-            "time": 5.0,
+            "time": 5.0,  # 缩短等待时间
            "description": f"等待溶剂2 {solvent2} 稳定"
        }
    })
-
+    debug_print("  ✅ 溶剂2稳定等待已添加 ⏰✨")
+    
    # 11. 等待重结晶完成
-    original_crystallize_time = 600.0
-    simulation_time_limit = 60.0
+    debug_print("📍 步骤9: 等待重结晶完成... 💎")
+    
+    # 模拟运行时间优化
+    debug_print("  ⏱️ 检查模拟运行时间限制...")
+    original_crystallize_time = 600.0  # 原始重结晶时间
+    simulation_time_limit = 60.0  # 模拟运行时间限制：60秒

    final_crystallize_time = min(original_crystallize_time, simulation_time_limit)
-
+    
    if original_crystallize_time > simulation_time_limit:
-        debug_print(f"模拟运行优化: {original_crystallize_time}s -> {final_crystallize_time}s")
-
+        debug_print(f"  🎮 模拟运行优化: {original_crystallize_time}s → {final_crystallize_time}s ⚡")
+        debug_print(f"  📊 时间缩短: {original_crystallize_time/60:.1f}分钟 → {final_crystallize_time/60:.1f}分钟 🚀")
+    else:
+        debug_print(f"  ✅ 时间在限制内: {final_crystallize_time}s 保持不变 🎯")
+    
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {
@@ -266,28 +341,50 @@ def generate_recrystallize_protocol(
            "description": f"等待重结晶完成（{solvent1}:{solvent2} = {ratio}，总体积 {final_volume}mL）" + (f" (模拟时间)" if original_crystallize_time != final_crystallize_time else "")
        }
    })
-
-    debug_print(f"重结晶协议生成完成: {len(action_sequence)} 个动作, 容器={vessel_id}, 体积变化: {original_liquid_volume:.2f} -> {final_liquid_volume:.2f}mL")
-
+    debug_print(f"  ✅ 重结晶等待已添加: {final_crystallize_time}s 💎✨")
+    
+    # 显示时间调整信息
+    if original_crystallize_time != final_crystallize_time:
+        debug_print(f"  🎭 模拟优化说明: 原计划 {original_crystallize_time/60:.1f}分钟，实际模拟 {final_crystallize_time/60:.1f}分钟 ⚡")
+    
+    # 总结
+    debug_print("💎" * 20)
+    debug_print(f"🎉 重结晶协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 目标容器: {vessel_id}")
+    debug_print(f"💧 总体积变化:")
+    debug_print(f"  - 原始体积: {original_liquid_volume:.2f}mL")
+    debug_print(f"  - 添加溶剂: {final_volume:.2f}mL")
+    debug_print(f"  - 最终体积: {final_liquid_volume:.2f}mL")
+    debug_print(f"⚖️ 溶剂比例: {solvent1}:{solvent2} = {ratio1}:{ratio2}")
+    debug_print(f"🧪 溶剂1: {solvent1} ({volume1:.2f}mL)")
+    debug_print(f"🧪 溶剂2: {solvent2} ({volume2:.2f}mL)")
+    debug_print(f"⏱️ 预计总时间: {(final_crystallize_time + 10)/60:.1f} 分钟 ⌛")
+    debug_print("💎" * 20)
+    
    return action_sequence


 # 测试函数
 def test_recrystallize_protocol():
    """测试重结晶协议"""
-    debug_print("=== RECRYSTALLIZE PROTOCOL 测试 ===")
-
+    debug_print("🧪 === RECRYSTALLIZE PROTOCOL 测试 === ✨")
+    
+    # 测试体积解析
+    debug_print("💧 测试体积解析...")
    test_volumes = ["100 mL", "2.5 L", "500", "50.5", "?", "invalid"]
    for vol in test_volumes:
        parsed = parse_volume_input(vol)
-        debug_print(f"体积 '{vol}' -> {parsed}mL")
-
+        debug_print(f"  📊 体积 '{vol}' -> {parsed}mL")
+    
+    # 测试比例解析
+    debug_print("⚖️ 测试比例解析...")
    test_ratios = ["1:1", "3:7", "50:50", "1-1", "2,8", "invalid"]
    for ratio in test_ratios:
        r1, r2 = parse_ratio(ratio)
-        debug_print(f"比例 '{ratio}' -> {r1}:{r2}")
-
-    debug_print("测试完成")
+        debug_print(f"  📊 比例 '{ratio}' -> {r1}:{r2}")
+    
+    debug_print("✅ 测试完成 🎉")

 if __name__ == "__main__":
-    test_recrystallize_protocol()
+    test_recrystallize_protocol()
--- a/unilabos/compile/reset_handling_protocol.py
+++ b/unilabos/compile/reset_handling_protocol.py
@@ -1,87 +1,253 @@
 import networkx as nx
 import logging
+import sys
 from typing import List, Dict, Any, Optional
-from .utils.logger_util import debug_print, action_log
-from .utils.vessel_parser import find_solvent_vessel
 from .pump_protocol import generate_pump_protocol_with_rinsing

 # 设置日志
 logger = logging.getLogger(__name__)

-create_action_log = action_log
+# 确保输出编码为UTF-8
+if hasattr(sys.stdout, 'reconfigure'):
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except:
+        pass
+
+def debug_print(message):
+    """调试输出函数 - 支持中文"""
+    try:
+        # 确保消息是字符串格式
+        safe_message = str(message)
+        print(f"[重置处理] {safe_message}", flush=True)
+        logger.info(f"[重置处理] {safe_message}")
+    except UnicodeEncodeError:
+        # 如果编码失败，尝试替换不支持的字符
+        safe_message = str(message).encode('utf-8', errors='replace').decode('utf-8')
+        print(f"[重置处理] {safe_message}", flush=True)
+        logger.info(f"[重置处理] {safe_message}")
+    except Exception as e:
+        # 最后的安全措施
+        fallback_message = f"日志输出错误: {repr(message)}"
+        print(f"[重置处理] {fallback_message}", flush=True)
+        logger.info(f"[重置处理] {fallback_message}")
+
+def create_action_log(message: str, emoji: str = "📝") -> Dict[str, Any]:
+    """创建一个动作日志 - 支持中文和emoji"""
+    try:
+        full_message = f"{emoji} {message}"
+        debug_print(full_message)
+        logger.info(full_message)
+        
+        return {
+            "action_name": "wait",
+            "action_kwargs": {
+                "time": 0.1,
+                "log_message": full_message,
+                "progress_message": full_message
+            }
+        }
+    except Exception as e:
+        # 如果emoji有问题，使用纯文本
+        safe_message = f"[日志] {message}"
+        debug_print(safe_message)
+        logger.info(safe_message)
+        
+        return {
+            "action_name": "wait", 
+            "action_kwargs": {
+                "time": 0.1,
+                "log_message": safe_message,
+                "progress_message": safe_message
+            }
+        }
+
+def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
+    """
+    查找溶剂容器，支持多种匹配模式
+    
+    Args:
+        G: 网络图
+        solvent: 溶剂名称（如 "methanol", "ethanol", "water"）
+    
+    Returns:
+        str: 溶剂容器ID
+    """
+    debug_print(f"🔍 正在查找溶剂 '{solvent}' 的容器...")
+    
+    # 构建可能的容器名称
+    possible_names = [
+        f"flask_{solvent}",           # flask_methanol
+        f"bottle_{solvent}",          # bottle_methanol
+        f"reagent_{solvent}",         # reagent_methanol
+        f"reagent_bottle_{solvent}",  # reagent_bottle_methanol
+        f"{solvent}_flask",           # methanol_flask
+        f"{solvent}_bottle",          # methanol_bottle
+        f"{solvent}",                 # methanol
+        f"vessel_{solvent}",          # vessel_methanol
+    ]
+    
+    debug_print(f"🎯 候选容器名称: {possible_names[:3]}... (共{len(possible_names)}个)")
+    
+    # 第一步：通过容器名称匹配
+    debug_print("📋 方法1: 精确名称匹配...")
+    for vessel_name in possible_names:
+        if vessel_name in G.nodes():
+            debug_print(f"✅ 通过名称匹配找到容器: {vessel_name}")
+            return vessel_name
+    debug_print("⚠️ 精确名称匹配失败，尝试模糊匹配...")
+    
+    # 第二步：通过模糊匹配
+    debug_print("📋 方法2: 模糊名称匹配...")
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            node_name = G.nodes[node_id].get('name', '').lower()
+            
+            # 检查是否包含溶剂名称
+            if solvent.lower() in node_id.lower() or solvent.lower() in node_name:
+                debug_print(f"✅ 通过模糊匹配找到容器: {node_id}")
+                return node_id
+    debug_print("⚠️ 模糊匹配失败，尝试液体类型匹配...")
+    
+    # 第三步：通过液体类型匹配
+    debug_print("📋 方法3: 液体类型匹配...")
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            vessel_data = G.nodes[node_id].get('data', {})
+            liquids = vessel_data.get('liquid', [])
+            
+            for liquid in liquids:
+                if isinstance(liquid, dict):
+                    liquid_type = (liquid.get('liquid_type') or liquid.get('name', '')).lower()
+                    reagent_name = vessel_data.get('reagent_name', '').lower()
+                    
+                    if solvent.lower() in liquid_type or solvent.lower() in reagent_name:
+                        debug_print(f"✅ 通过液体类型匹配找到容器: {node_id}")
+                        return node_id
+    
+    # 列出可用容器帮助调试
+    debug_print("📊 显示可用容器信息...")
+    available_containers = []
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            vessel_data = G.nodes[node_id].get('data', {})
+            liquids = vessel_data.get('liquid', [])
+            liquid_types = [liquid.get('liquid_type', '') or liquid.get('name', '') 
+                           for liquid in liquids if isinstance(liquid, dict)]
+            
+            available_containers.append({
+                'id': node_id,
+                'name': G.nodes[node_id].get('name', ''),
+                'liquids': liquid_types,
+                'reagent_name': vessel_data.get('reagent_name', '')
+            })
+    
+    debug_print(f"📋 可用容器列表 (共{len(available_containers)}个):")
+    for i, container in enumerate(available_containers[:5]):  # 只显示前5个
+        debug_print(f"  {i+1}. 🥽 {container['id']}: {container['name']}")
+        debug_print(f"     💧 液体: {container['liquids']}")
+        debug_print(f"     🧪 试剂: {container['reagent_name']}")
+    
+    if len(available_containers) > 5:
+        debug_print(f"    ... 还有 {len(available_containers)-5} 个容器")
+    
+    debug_print(f"❌ 找不到溶剂 '{solvent}' 对应的容器")
+    raise ValueError(f"找不到溶剂 '{solvent}' 对应的容器。尝试了: {possible_names[:3]}...")

 def generate_reset_handling_protocol(
    G: nx.DiGraph,
    solvent: str,
-    vessel: Optional[str] = None,
-    **kwargs
+    vessel: Optional[str] = None,  # 🆕 新增可选vessel参数
+    **kwargs  # 接收其他可能的参数但不使用
 ) -> List[Dict[str, Any]]:
    """
    生成重置处理协议序列 - 支持自定义容器
-
+    
    Args:
        G: 有向图，节点为容器和设备
        solvent: 溶剂名称（从XDL传入）
        vessel: 目标容器名称（可选，默认为 "main_reactor"）
        **kwargs: 其他可选参数，但不使用
-
+    
    Returns:
        List[Dict[str, Any]]: 动作序列
    """
    action_sequence = []
+    
+    # 🔧 修改：支持自定义vessel参数
+    target_vessel = vessel if vessel is not None else "main_reactor"  # 默认目标容器
+    volume = 50.0  # 默认体积 50 mL

-    target_vessel = vessel if vessel is not None else "main_reactor"
-    volume = 50.0
-
-    debug_print(f"开始生成重置处理协议: solvent={solvent}, vessel={target_vessel}, volume={volume}mL")
-
+    debug_print("=" * 60)
+    debug_print("🚀 开始生成重置处理协议")
+    debug_print(f"📋 输入参数:")
+    debug_print(f"  🧪 溶剂: {solvent}")
+    debug_print(f"  🥽 目标容器: {target_vessel} {'(默认)' if vessel is None else '(指定)'}")
+    debug_print(f"  💧 体积: {volume} mL")
+    debug_print(f"  ⚙️ 其他参数: {kwargs}")
+    debug_print("=" * 60)
+    
    # 添加初始日志
-    action_sequence.append(action_log(f"开始重置处理操作 - 容器: {target_vessel}", "🎬"))
-    action_sequence.append(action_log(f"使用溶剂: {solvent}", "🧪"))
-    action_sequence.append(action_log(f"重置体积: {volume}mL", "💧"))
-
+    action_sequence.append(create_action_log(f"开始重置处理操作 - 容器: {target_vessel}", "🎬"))
+    action_sequence.append(create_action_log(f"使用溶剂: {solvent}", "🧪"))
+    action_sequence.append(create_action_log(f"重置体积: {volume}mL", "💧"))
+    
    if vessel is None:
-        action_sequence.append(action_log("使用默认目标容器: main_reactor", "⚙️"))
+        action_sequence.append(create_action_log("使用默认目标容器: main_reactor", "⚙️"))
    else:
-        action_sequence.append(action_log(f"使用指定目标容器: {vessel}", "🎯"))
-
+        action_sequence.append(create_action_log(f"使用指定目标容器: {vessel}", "🎯"))
+    
    # 1. 验证目标容器存在
-    action_sequence.append(action_log("正在验证目标容器...", "🔍"))
-
+    debug_print("🔍 步骤1: 验证目标容器...")
+    action_sequence.append(create_action_log("正在验证目标容器...", "🔍"))
+    
    if target_vessel not in G.nodes():
-        action_sequence.append(action_log(f"目标容器 '{target_vessel}' 不存在", "❌"))
+        debug_print(f"❌ 目标容器 '{target_vessel}' 不存在于系统中!")
+        action_sequence.append(create_action_log(f"目标容器 '{target_vessel}' 不存在", "❌"))
        raise ValueError(f"目标容器 '{target_vessel}' 不存在于系统中")
-
-    action_sequence.append(action_log(f"目标容器验证通过: {target_vessel}", "✅"))
-
+    
+    debug_print(f"✅ 目标容器 '{target_vessel}' 验证通过")
+    action_sequence.append(create_action_log(f"目标容器验证通过: {target_vessel}", "✅"))
+    
    # 2. 查找溶剂容器
-    action_sequence.append(action_log("正在查找溶剂容器...", "🔍"))
-
+    debug_print("🔍 步骤2: 查找溶剂容器...")
+    action_sequence.append(create_action_log("正在查找溶剂容器...", "🔍"))
+    
    try:
        solvent_vessel = find_solvent_vessel(G, solvent)
-        debug_print(f"找到溶剂容器: {solvent_vessel}")
-        action_sequence.append(action_log(f"找到溶剂容器: {solvent_vessel}", "✅"))
+        debug_print(f"✅ 找到溶剂容器: {solvent_vessel}")
+        action_sequence.append(create_action_log(f"找到溶剂容器: {solvent_vessel}", "✅"))
    except ValueError as e:
-        action_sequence.append(action_log(f"溶剂容器查找失败: {str(e)}", "❌"))
+        debug_print(f"❌ 溶剂容器查找失败: {str(e)}")
+        action_sequence.append(create_action_log(f"溶剂容器查找失败: {str(e)}", "❌"))
        raise ValueError(f"无法找到溶剂 '{solvent}': {str(e)}")
-
+    
    # 3. 验证路径存在
-    action_sequence.append(action_log("正在验证传输路径...", "🛤️"))
-
+    debug_print("🔍 步骤3: 验证传输路径...")
+    action_sequence.append(create_action_log("正在验证传输路径...", "🛤️"))
+    
    try:
        path = nx.shortest_path(G, source=solvent_vessel, target=target_vessel)
-        action_sequence.append(action_log(f"传输路径: {' → '.join(path)}", "🛤️"))
+        debug_print(f"✅ 找到路径: {' → '.join(path)}")
+        action_sequence.append(create_action_log(f"传输路径: {' → '.join(path)}", "🛤️"))
    except nx.NetworkXNoPath:
-        action_sequence.append(action_log(f"路径不可达: {solvent_vessel} → {target_vessel}", "❌"))
+        debug_print(f"❌ 路径不可达: {solvent_vessel} → {target_vessel}")
+        action_sequence.append(create_action_log(f"路径不可达: {solvent_vessel} → {target_vessel}", "❌"))
        raise ValueError(f"从溶剂容器 '{solvent_vessel}' 到目标容器 '{target_vessel}' 没有可用路径")
-
+    
    # 4. 使用pump_protocol转移溶剂
-    action_sequence.append(action_log("开始溶剂转移操作...", "🚰"))
-    action_sequence.append(action_log(f"转移: {solvent_vessel} → {target_vessel} ({volume}mL)", "🚛"))
-
+    debug_print("🔍 步骤4: 转移溶剂...")
+    action_sequence.append(create_action_log("开始溶剂转移操作...", "🚰"))
+    
+    debug_print(f"🚛 开始转移: {solvent_vessel} → {target_vessel}")
+    debug_print(f"💧 转移体积: {volume} mL")
+    action_sequence.append(create_action_log(f"转移: {solvent_vessel} → {target_vessel} ({volume}mL)", "🚛"))
+    
    try:
-        action_sequence.append(action_log("正在生成泵送协议...", "🔄"))
-
+        debug_print("🔄 生成泵送协议...")
+        action_sequence.append(create_action_log("正在生成泵送协议...", "🔄"))
+        
        pump_actions = generate_pump_protocol_with_rinsing(
            G=G,
            from_vessel=solvent_vessel,
@@ -90,34 +256,41 @@ def generate_reset_handling_protocol(
            amount="",
            time=0.0,
            viscous=False,
-            rinsing_solvent="",
+            rinsing_solvent="",  # 重置处理不需要清洗
            rinsing_volume=0.0,
            rinsing_repeats=0,
            solid=False,
-            flowrate=2.5,
-            transfer_flowrate=0.5
+            flowrate=2.5,  # 正常流速
+            transfer_flowrate=0.5  # 正常转移流速
        )
-
+        
        action_sequence.extend(pump_actions)
-        debug_print(f"泵送协议已添加: {len(pump_actions)} 个动作")
-        action_sequence.append(action_log(f"泵送协议完成 ({len(pump_actions)} 个操作)", "✅"))
-
+        debug_print(f"✅ 泵送协议已添加: {len(pump_actions)} 个动作")
+        action_sequence.append(create_action_log(f"泵送协议完成 ({len(pump_actions)} 个操作)", "✅"))
+        
    except Exception as e:
-        action_sequence.append(action_log(f"泵送协议生成失败: {str(e)}", "❌"))
+        debug_print(f"❌ 泵送协议生成失败: {str(e)}")
+        action_sequence.append(create_action_log(f"泵送协议生成失败: {str(e)}", "❌"))
        raise ValueError(f"生成泵协议时出错: {str(e)}")
-
+    
    # 5. 等待溶剂稳定
-    action_sequence.append(action_log("等待溶剂稳定...", "⏳"))
-
-    original_wait_time = 10.0
-    simulation_time_limit = 5.0
+    debug_print("🔍 步骤5: 等待溶剂稳定...")
+    action_sequence.append(create_action_log("等待溶剂稳定...", "⏳"))
+    
+    # 模拟运行时间优化
+    debug_print("⏱️ 检查模拟运行时间限制...")
+    original_wait_time = 10.0  # 原始等待时间
+    simulation_time_limit = 5.0  # 模拟运行时间限制：5秒
+    
    final_wait_time = min(original_wait_time, simulation_time_limit)
-
+    
    if original_wait_time > simulation_time_limit:
-        action_sequence.append(action_log(f"时间优化: {original_wait_time}s → {final_wait_time}s", "⚡"))
+        debug_print(f"🎮 模拟运行优化: {original_wait_time}s → {final_wait_time}s")
+        action_sequence.append(create_action_log(f"时间优化: {original_wait_time}s → {final_wait_time}s", "⚡"))
    else:
-        action_sequence.append(action_log(f"等待时间: {final_wait_time}s", "⏰"))
-
+        debug_print(f"✅ 时间在限制内: {final_wait_time}s 保持不变")
+        action_sequence.append(create_action_log(f"等待时间: {final_wait_time}s", "⏰"))
+    
    action_sequence.append({
        "action_name": "wait",
        "action_kwargs": {
@@ -125,50 +298,90 @@ def generate_reset_handling_protocol(
            "description": f"等待溶剂 {solvent} 在容器 {target_vessel} 中稳定" + (f" (模拟时间)" if original_wait_time != final_wait_time else "")
        }
    })
-
+    debug_print(f"✅ 稳定等待已添加: {final_wait_time}s")
+    
+    # 显示时间调整信息
    if original_wait_time != final_wait_time:
-        action_sequence.append(action_log("应用模拟时间优化", "🎭"))
-
+        debug_print(f"🎭 模拟优化说明: 原计划 {original_wait_time}s，实际模拟 {final_wait_time}s")
+        action_sequence.append(create_action_log("应用模拟时间优化", "🎭"))
+    
    # 总结
-    debug_print(f"重置处理协议生成完成: {len(action_sequence)} 个动作, {solvent_vessel} -> {target_vessel}, {volume}mL")
-
+    debug_print("=" * 60)
+    debug_print(f"🎉 重置处理协议生成完成!")
+    debug_print(f"📊 总结信息:")
+    debug_print(f"  📋 总动作数: {len(action_sequence)} 个")
+    debug_print(f"  🧪 溶剂: {solvent}")
+    debug_print(f"  🥽 源容器: {solvent_vessel}")
+    debug_print(f"  🥽 目标容器: {target_vessel} {'(默认)' if vessel is None else '(指定)'}")
+    debug_print(f"  💧 转移体积: {volume} mL")
+    debug_print(f"  ⏱️ 预计总时间: {(final_wait_time + 5):.0f} 秒")
+    debug_print(f"  🎯 操作结果: 已添加 {volume} mL {solvent} 到 {target_vessel}")
+    debug_print("=" * 60)
+    
+    # 添加完成日志
    summary_msg = f"重置处理完成: {target_vessel} (使用 {volume}mL {solvent})"
    if vessel is None:
        summary_msg += " [默认容器]"
    else:
        summary_msg += " [指定容器]"
-
-    action_sequence.append(action_log(summary_msg, "🎉"))
-
+    
+    action_sequence.append(create_action_log(summary_msg, "🎉"))
+    
    return action_sequence

 # === 便捷函数 ===

 def reset_main_reactor(G: nx.DiGraph, solvent: str = "methanol", **kwargs) -> List[Dict[str, Any]]:
    """重置主反应器 (默认行为)"""
+    debug_print(f"🔄 重置主反应器，使用溶剂: {solvent}")
    return generate_reset_handling_protocol(G, solvent=solvent, vessel=None, **kwargs)

 def reset_custom_vessel(G: nx.DiGraph, vessel: str, solvent: str = "methanol", **kwargs) -> List[Dict[str, Any]]:
    """重置指定容器"""
+    debug_print(f"🔄 重置指定容器: {vessel}，使用溶剂: {solvent}")
    return generate_reset_handling_protocol(G, solvent=solvent, vessel=vessel, **kwargs)

 def reset_with_water(G: nx.DiGraph, vessel: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]:
    """使用水重置容器"""
+    target = vessel or "main_reactor"
+    debug_print(f"💧 使用水重置容器: {target}")
    return generate_reset_handling_protocol(G, solvent="water", vessel=vessel, **kwargs)

 def reset_with_methanol(G: nx.DiGraph, vessel: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]:
    """使用甲醇重置容器"""
+    target = vessel or "main_reactor"
+    debug_print(f"🧪 使用甲醇重置容器: {target}")
    return generate_reset_handling_protocol(G, solvent="methanol", vessel=vessel, **kwargs)

 def reset_with_ethanol(G: nx.DiGraph, vessel: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]:
    """使用乙醇重置容器"""
+    target = vessel or "main_reactor"
+    debug_print(f"🧪 使用乙醇重置容器: {target}")
    return generate_reset_handling_protocol(G, solvent="ethanol", vessel=vessel, **kwargs)

 # 测试函数
 def test_reset_handling_protocol():
    """测试重置处理协议"""
-    debug_print("=== 重置处理协议测试 ===")
-    debug_print("测试完成")
+    debug_print("=== 重置处理协议增强中文版测试 ===")
+    
+    # 测试溶剂名称
+    debug_print("🧪 测试常用溶剂名称...")
+    test_solvents = ["methanol", "ethanol", "water", "acetone", "dmso"]
+    for solvent in test_solvents:
+        debug_print(f"  🔍 测试溶剂: {solvent}")
+    
+    # 测试容器参数
+    debug_print("🥽 测试容器参数...")
+    test_cases = [
+        {"solvent": "methanol", "vessel": None, "desc": "默认容器"},
+        {"solvent": "ethanol", "vessel": "reactor_2", "desc": "指定容器"},
+        {"solvent": "water", "vessel": "flask_1", "desc": "自定义容器"}
+    ]
+    
+    for case in test_cases:
+        debug_print(f"  🧪 测试案例: {case['desc']} - {case['solvent']} -> {case['vessel'] or 'main_reactor'}")
+    
+    debug_print("✅ 测试完成")

 if __name__ == "__main__":
-    test_reset_handling_protocol()
+    test_reset_handling_protocol()
--- a/unilabos/compile/run_column_protocol.py
+++ b/unilabos/compile/run_column_protocol.py
@@ -2,54 +2,60 @@ from typing import List, Dict, Any, Union
 import networkx as nx
 import logging
 import re
-from .utils.vessel_parser import get_vessel, find_solvent_vessel
-from .utils.resource_helper import get_resource_id, get_resource_data, get_resource_liquid_volume, update_vessel_volume
-from .utils.logger_util import debug_print
+from .utils.vessel_parser import get_vessel
 from .pump_protocol import generate_pump_protocol_with_rinsing

 logger = logging.getLogger(__name__)

+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[RUN_COLUMN] {message}")
+
 def parse_percentage(pct_str: str) -> float:
    """
    解析百分比字符串为数值
-
+    
    Args:
        pct_str: 百分比字符串（如 "40 %", "40%", "40"）
-
+    
    Returns:
        float: 百分比数值（0-100）
    """
    if not pct_str or not pct_str.strip():
        return 0.0
-
+    
    pct_str = pct_str.strip().lower()
-
+    debug_print(f"🔍 解析百分比: '{pct_str}'")
+    
    # 移除百分号和空格
    pct_clean = re.sub(r'[%\s]', '', pct_str)
-
+    
+    # 提取数字
    match = re.search(r'([0-9]*\.?[0-9]+)', pct_clean)
    if match:
        value = float(match.group(1))
+        debug_print(f"✅ 百分比解析结果: {value}%")
        return value
-
-    debug_print(f"无法解析百分比: '{pct_str}'，返回0.0")
+    
+    debug_print(f"⚠️ 无法解析百分比: '{pct_str}'，返回0.0")
    return 0.0

 def parse_ratio(ratio_str: str) -> tuple:
    """
    解析比例字符串为两个数值
-
+    
    Args:
        ratio_str: 比例字符串（如 "5:95", "1:1", "40:60"）
-
+    
    Returns:
-        tuple: (ratio1, ratio2) 两个比例值（百分比）
+        tuple: (ratio1, ratio2) 两个比例值
    """
    if not ratio_str or not ratio_str.strip():
-        return (50.0, 50.0)
-
+        return (50.0, 50.0)  # 默认1:1
+    
    ratio_str = ratio_str.strip()
-
+    debug_print(f"🔍 解析比例: '{ratio_str}'")
+    
    # 支持多种分隔符：: / -
    if ':' in ratio_str:
        parts = ratio_str.split(':')
@@ -60,82 +66,101 @@ def parse_ratio(ratio_str: str) -> tuple:
    elif 'to' in ratio_str.lower():
        parts = ratio_str.lower().split('to')
    else:
-        debug_print(f"无法解析比例格式: '{ratio_str}'，使用默认1:1")
+        debug_print(f"⚠️ 无法解析比例格式: '{ratio_str}'，使用默认1:1")
        return (50.0, 50.0)
-
+    
    if len(parts) >= 2:
        try:
            ratio1 = float(parts[0].strip())
            ratio2 = float(parts[1].strip())
            total = ratio1 + ratio2
-
+            
+            # 转换为百分比
            pct1 = (ratio1 / total) * 100
            pct2 = (ratio2 / total) * 100
-
+            
+            debug_print(f"✅ 比例解析结果: {ratio1}:{ratio2} -> {pct1:.1f}%:{pct2:.1f}%")
            return (pct1, pct2)
        except ValueError as e:
-            debug_print(f"比例数值转换失败: {str(e)}")
-
-    debug_print(f"比例解析失败，使用默认1:1")
+            debug_print(f"⚠️ 比例数值转换失败: {str(e)}")
+    
+    debug_print(f"⚠️ 比例解析失败，使用默认1:1")
    return (50.0, 50.0)

 def parse_rf_value(rf_str: str) -> float:
    """
    解析Rf值字符串
-
+    
    Args:
        rf_str: Rf值字符串（如 "0.3", "0.45", "?"）
-
+    
    Returns:
        float: Rf值（0-1）
    """
    if not rf_str or not rf_str.strip():
-        return 0.3
-
+        return 0.3  # 默认Rf值
+    
    rf_str = rf_str.strip().lower()
-
+    debug_print(f"🔍 解析Rf值: '{rf_str}'")
+    
+    # 处理未知Rf值
    if rf_str in ['?', 'unknown', 'tbd', 'to be determined']:
-        return 0.3
-
+        default_rf = 0.3
+        debug_print(f"❓ 检测到未知Rf值，使用默认值: {default_rf}")
+        return default_rf
+    
+    # 提取数字
    match = re.search(r'([0-9]*\.?[0-9]+)', rf_str)
    if match:
        value = float(match.group(1))
+        # 确保Rf值在0-1范围内
        if value > 1.0:
-            value = value / 100.0
-        value = max(0.0, min(1.0, value))
+            value = value / 100.0  # 可能是百分比形式
+        value = max(0.0, min(1.0, value))  # 限制在0-1范围
+        debug_print(f"✅ Rf值解析结果: {value}")
        return value
-
+    
+    debug_print(f"⚠️ 无法解析Rf值: '{rf_str}'，使用默认值0.3")
    return 0.3

 def find_column_device(G: nx.DiGraph) -> str:
    """查找柱层析设备"""
+    debug_print("🔍 查找柱层析设备...")
+    
+    # 查找虚拟柱设备
    for node in G.nodes():
        node_data = G.nodes[node]
        node_class = node_data.get('class', '') or ''
-
+        
        if 'virtual_column' in node_class.lower() or 'column' in node_class.lower():
-            debug_print(f"找到柱层析设备: {node}")
+            debug_print(f"🎉 找到柱层析设备: {node} ✨")
            return node
-
+    
+    # 如果没有找到，尝试创建虚拟设备名称
    possible_names = ['column_1', 'virtual_column_1', 'chromatography_column_1']
    for name in possible_names:
        if name in G.nodes():
-            debug_print(f"找到柱设备: {name}")
+            debug_print(f"🎉 找到柱设备: {name} ✨")
            return name
-
-    debug_print("未找到柱层析设备，将使用pump protocol直接转移")
+    
+    debug_print("⚠️ 未找到柱层析设备，将使用pump protocol直接转移")
    return ""

 def find_column_vessel(G: nx.DiGraph, column: str) -> str:
    """查找柱容器"""
+    debug_print(f"🔍 查找柱容器: '{column}'")
+    
+    # 直接检查column参数是否是容器
    if column in G.nodes():
        node_type = G.nodes[column].get('type', '')
        if node_type == 'container':
+            debug_print(f"🎉 找到柱容器: {column} ✨")
            return column
-
+    
+    # 尝试常见的命名规则
    possible_names = [
        f"column_{column}",
-        f"{column}_column",
+        f"{column}_column", 
        f"vessel_{column}",
        f"{column}_vessel",
        "column_vessel",
@@ -144,25 +169,211 @@ def find_column_vessel(G: nx.DiGraph, column: str) -> str:
        "preparative_column",
        "column"
    ]
-
+    
    for vessel_name in possible_names:
        if vessel_name in G.nodes():
            node_type = G.nodes[vessel_name].get('type', '')
            if node_type == 'container':
+                debug_print(f"🎉 找到柱容器: {vessel_name} ✨")
                return vessel_name
-
+    
+    debug_print(f"⚠️ 未找到柱容器，将直接在源容器中进行分离")
    return ""

+def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
+    """查找溶剂容器 - 增强版"""
+    if not solvent or not solvent.strip():
+        return ""
+    
+    solvent = solvent.strip().replace(' ', '_').lower()
+    debug_print(f"🔍 查找溶剂容器: '{solvent}'")
+    
+    # 🔧 方法1：直接搜索 data.reagent_name
+    for node in G.nodes():
+        node_data = G.nodes[node].get('data', {})
+        node_type = G.nodes[node].get('type', '')
+        
+        # 只搜索容器类型的节点
+        if node_type == 'container':
+            reagent_name = node_data.get('reagent_name', '').lower()
+            reagent_config = G.nodes[node].get('config', {}).get('reagent', '').lower()
+            
+            # 检查 data.reagent_name 和 config.reagent
+            if reagent_name == solvent or reagent_config == solvent:
+                debug_print(f"🎉 通过reagent_name找到溶剂容器: {node} (reagent: {reagent_name or reagent_config}) ✨")
+                return node
+            
+            # 模糊匹配 reagent_name
+            if solvent in reagent_name or reagent_name in solvent:
+                debug_print(f"🎉 通过reagent_name模糊匹配到溶剂容器: {node} (reagent: {reagent_name}) ✨")
+                return node
+            
+            if solvent in reagent_config or reagent_config in solvent:
+                debug_print(f"🎉 通过config.reagent模糊匹配到溶剂容器: {node} (reagent: {reagent_config}) ✨")
+                return node
+    
+    # 🔧 方法2：常见的溶剂容器命名规则
+    possible_names = [
+        f"flask_{solvent}",
+        f"bottle_{solvent}",
+        f"reagent_{solvent}",
+        f"{solvent}_bottle",
+        f"{solvent}_flask",
+        f"solvent_{solvent}",
+        f"reagent_bottle_{solvent}"
+    ]
+    
+    for vessel_name in possible_names:
+        if vessel_name in G.nodes():
+            node_type = G.nodes[vessel_name].get('type', '')
+            if node_type == 'container':
+                debug_print(f"🎉 通过命名规则找到溶剂容器: {vessel_name} ✨")
+                return vessel_name
+    
+    # 🔧 方法3：节点名称模糊匹配
+    for node in G.nodes():
+        node_type = G.nodes[node].get('type', '')
+        if node_type == 'container':
+            if ('flask_' in node or 'bottle_' in node or 'reagent_' in node) and solvent in node.lower():
+                debug_print(f"🎉 通过节点名称模糊匹配到溶剂容器: {node} ✨")
+                return node
+    
+    # 🔧 方法4：特殊溶剂名称映射
+    solvent_mapping = {
+        'dmf': ['dmf', 'dimethylformamide', 'n,n-dimethylformamide'],
+        'ethyl_acetate': ['ethyl_acetate', 'ethylacetate', 'etoac', 'ea'],
+        'hexane': ['hexane', 'hexanes', 'n-hexane'],
+        'methanol': ['methanol', 'meoh', 'ch3oh'],
+        'water': ['water', 'h2o', 'distilled_water'],
+        'acetone': ['acetone', 'ch3coch3', '2-propanone'],
+        'dichloromethane': ['dichloromethane', 'dcm', 'ch2cl2', 'methylene_chloride'],
+        'chloroform': ['chloroform', 'chcl3', 'trichloromethane']
+    }
+    
+    # 查找映射的同义词
+    for canonical_name, synonyms in solvent_mapping.items():
+        if solvent in synonyms:
+            debug_print(f"🔍 检测到溶剂同义词: '{solvent}' -> '{canonical_name}'")
+            return find_solvent_vessel(G, canonical_name)  # 递归搜索
+    
+    debug_print(f"⚠️ 未找到溶剂 '{solvent}' 的容器")
+    return ""
+
+def get_vessel_liquid_volume(vessel: dict) -> float:
+    """
+    获取容器中的液体体积 - 支持vessel字典
+    
+    Args:
+        vessel: 容器字典
+        
+    Returns:
+        float: 液体体积（mL）
+    """
+    if not vessel or "data" not in vessel:
+        debug_print(f"⚠️ 容器数据为空，返回 0.0mL")
+        return 0.0
+    
+    vessel_data = vessel["data"]
+    vessel_id = vessel.get("id", "unknown")
+    
+    debug_print(f"🔍 读取容器 '{vessel_id}' 体积数据: {vessel_data}")
+    
+    # 检查liquid_volume字段
+    if "liquid_volume" in vessel_data:
+        liquid_volume = vessel_data["liquid_volume"]
+        
+        # 处理列表格式
+        if isinstance(liquid_volume, list):
+            if len(liquid_volume) > 0:
+                volume = liquid_volume[0]
+                if isinstance(volume, (int, float)):
+                    debug_print(f"✅ 容器 '{vessel_id}' 体积: {volume}mL (列表格式)")
+                    return float(volume)
+        
+        # 处理直接数值格式
+        elif isinstance(liquid_volume, (int, float)):
+            debug_print(f"✅ 容器 '{vessel_id}' 体积: {liquid_volume}mL (数值格式)")
+            return float(liquid_volume)
+    
+    # 检查其他可能的体积字段
+    volume_keys = ['current_volume', 'total_volume', 'volume']
+    for key in volume_keys:
+        if key in vessel_data:
+            try:
+                volume = float(vessel_data[key])
+                if volume > 0:
+                    debug_print(f"✅ 容器 '{vessel_id}' 体积: {volume}mL (字段: {key})")
+                    return volume
+            except (ValueError, TypeError):
+                continue
+    
+    debug_print(f"⚠️ 无法获取容器 '{vessel_id}' 的体积，返回默认值 50.0mL")
+    return 50.0
+
+def update_vessel_volume(vessel: dict, G: nx.DiGraph, new_volume: float, description: str = "") -> None:
+    """
+    更新容器体积（同时更新vessel字典和图节点）
+    
+    Args:
+        vessel: 容器字典
+        G: 网络图
+        new_volume: 新体积
+        description: 更新描述
+    """
+    vessel_id = vessel.get("id", "unknown")
+    
+    if description:
+        debug_print(f"🔧 更新容器体积 - {description}")
+    
+    # 更新vessel字典中的体积
+    if "data" in vessel:
+        if "liquid_volume" in vessel["data"]:
+            current_volume = vessel["data"]["liquid_volume"]
+            if isinstance(current_volume, list):
+                if len(current_volume) > 0:
+                    vessel["data"]["liquid_volume"][0] = new_volume
+                else:
+                    vessel["data"]["liquid_volume"] = [new_volume]
+            else:
+                vessel["data"]["liquid_volume"] = new_volume
+        else:
+            vessel["data"]["liquid_volume"] = new_volume
+    else:
+        vessel["data"] = {"liquid_volume": new_volume}
+    
+    # 同时更新图中的容器数据
+    if vessel_id in G.nodes():
+        if 'data' not in G.nodes[vessel_id]:
+            G.nodes[vessel_id]['data'] = {}
+        
+        vessel_node_data = G.nodes[vessel_id]['data']
+        current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+        
+        if isinstance(current_node_volume, list):
+            if len(current_node_volume) > 0:
+                G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume
+            else:
+                G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume]
+        else:
+            G.nodes[vessel_id]['data']['liquid_volume'] = new_volume
+    
+    debug_print(f"📊 容器 '{vessel_id}' 体积已更新为: {new_volume:.2f}mL")
+
 def calculate_solvent_volumes(total_volume: float, pct1: float, pct2: float) -> tuple:
    """根据百分比计算溶剂体积"""
    volume1 = (total_volume * pct1) / 100.0
    volume2 = (total_volume * pct2) / 100.0
+    
+    debug_print(f"🧮 溶剂体积计算: 总体积{total_volume}mL")
+    debug_print(f"  - 溶剂1: {pct1}% = {volume1}mL")
+    debug_print(f"  - 溶剂2: {pct2}% = {volume2}mL")
+    
    return (volume1, volume2)

 def generate_run_column_protocol(
    G: nx.DiGraph,
-    from_vessel: dict,
-    to_vessel: dict,
+    from_vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    to_vessel: dict,    # 🔧 修改：从字符串改为字典类型
    column: str,
    rf: str = "",
    pct1: str = "",
@@ -174,7 +385,7 @@ def generate_run_column_protocol(
 ) -> List[Dict[str, Any]]:
    """
    生成柱层析分离的协议序列 - 支持vessel字典和体积运算
-
+    
    Args:
        G: 有向图，节点为设备和容器，边为流体管道
        from_vessel: 源容器字典（从XDL传入）
@@ -187,112 +398,173 @@ def generate_run_column_protocol(
        solvent2: 第二种溶剂名称（可选）
        ratio: 溶剂比例（如 "5:95"，可选，优先级高于pct1/pct2）
        **kwargs: 其他可选参数
-
+    
    Returns:
        List[Dict[str, Any]]: 柱层析分离操作的动作序列
    """
-
+    
+    # 🔧 核心修改：从字典中提取容器ID
    from_vessel_id, _ = get_vessel(from_vessel)
    to_vessel_id, _ = get_vessel(to_vessel)

-    debug_print(f"开始生成柱层析协议: {from_vessel_id} -> {to_vessel_id}, column={column}")
-
+    debug_print("🏛️" * 20)
+    debug_print("🚀 开始生成柱层析协议（支持vessel字典和体积运算）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 from_vessel: {from_vessel} (ID: {from_vessel_id})")
+    debug_print(f"  🥽 to_vessel: {to_vessel} (ID: {to_vessel_id})")
+    debug_print(f"  🏛️ column: '{column}'")
+    debug_print(f"  📊 rf: '{rf}'")
+    debug_print(f"  🧪 溶剂配比: pct1='{pct1}', pct2='{pct2}', ratio='{ratio}'")
+    debug_print(f"  🧪 溶剂名称: solvent1='{solvent1}', solvent2='{solvent2}'")
+    debug_print("🏛️" * 20)
+    
    action_sequence = []
-
-    # 记录柱层析前的容器状态
-    original_from_volume = get_resource_liquid_volume(from_vessel)
-    original_to_volume = get_resource_liquid_volume(to_vessel)
-
+    
+    # 🔧 新增：记录柱层析前的容器状态
+    debug_print("🔍 记录柱层析前容器状态...")
+    original_from_volume = get_vessel_liquid_volume(from_vessel)
+    original_to_volume = get_vessel_liquid_volume(to_vessel)
+    
+    debug_print(f"📊 柱层析前状态:")
+    debug_print(f"  - 源容器 {from_vessel_id}: {original_from_volume:.2f}mL")
+    debug_print(f"  - 目标容器 {to_vessel_id}: {original_to_volume:.2f}mL")
+    
    # === 参数验证 ===
-    if not from_vessel_id:
+    debug_print("📍 步骤1: 参数验证...")
+    
+    if not from_vessel_id:  # 🔧 使用 from_vessel_id
        raise ValueError("from_vessel 参数不能为空")
-    if not to_vessel_id:
+    if not to_vessel_id:    # 🔧 使用 to_vessel_id
        raise ValueError("to_vessel 参数不能为空")
    if not column:
        raise ValueError("column 参数不能为空")
-
-    if from_vessel_id not in G.nodes():
+    
+    if from_vessel_id not in G.nodes():  # 🔧 使用 from_vessel_id
        raise ValueError(f"源容器 '{from_vessel_id}' 不存在于系统中")
-    if to_vessel_id not in G.nodes():
+    if to_vessel_id not in G.nodes():    # 🔧 使用 to_vessel_id
        raise ValueError(f"目标容器 '{to_vessel_id}' 不存在于系统中")
-
+    
+    debug_print("✅ 基本参数验证通过")
+    
    # === 参数解析 ===
+    debug_print("📍 步骤2: 参数解析...")
+    
+    # 解析Rf值
    final_rf = parse_rf_value(rf)
-
+    debug_print(f"🎯 最终Rf值: {final_rf}")
+    
+    # 解析溶剂比例（ratio优先级高于pct1/pct2）
    if ratio and ratio.strip():
        final_pct1, final_pct2 = parse_ratio(ratio)
+        debug_print(f"📊 使用ratio参数: {final_pct1:.1f}% : {final_pct2:.1f}%")
    else:
        final_pct1 = parse_percentage(pct1) if pct1 else 50.0
        final_pct2 = parse_percentage(pct2) if pct2 else 50.0
-
+        
+        # 如果百分比和不是100%，进行归一化
        total_pct = final_pct1 + final_pct2
        if total_pct == 0:
            final_pct1, final_pct2 = 50.0, 50.0
        elif total_pct != 100.0:
            final_pct1 = (final_pct1 / total_pct) * 100
            final_pct2 = (final_pct2 / total_pct) * 100
-
+        
+        debug_print(f"📊 使用百分比参数: {final_pct1:.1f}% : {final_pct2:.1f}%")
+    
+    # 设置默认溶剂（如果未指定）
    final_solvent1 = solvent1.strip() if solvent1 else "ethyl_acetate"
    final_solvent2 = solvent2.strip() if solvent2 else "hexane"
-
-    debug_print(f"参数: rf={final_rf}, 溶剂={final_solvent1}:{final_solvent2} = {final_pct1:.1f}%:{final_pct2:.1f}%")
-
+    
+    debug_print(f"🧪 最终溶剂: {final_solvent1} : {final_solvent2}")
+    
    # === 查找设备和容器 ===
+    debug_print("📍 步骤3: 查找设备和容器...")
+    
+    # 查找柱层析设备
    column_device_id = find_column_device(G)
+    
+    # 查找柱容器
    column_vessel = find_column_vessel(G, column)
+    
+    # 查找溶剂容器
    solvent1_vessel = find_solvent_vessel(G, final_solvent1)
    solvent2_vessel = find_solvent_vessel(G, final_solvent2)
-
+    
+    debug_print(f"🔧 设备映射:")
+    debug_print(f"  - 柱设备: '{column_device_id}'")
+    debug_print(f"  - 柱容器: '{column_vessel}'")
+    debug_print(f"  - 溶剂1容器: '{solvent1_vessel}'")
+    debug_print(f"  - 溶剂2容器: '{solvent2_vessel}'")
+    
    # === 获取源容器体积 ===
+    debug_print("📍 步骤4: 获取源容器体积...")
+    
    source_volume = original_from_volume
    if source_volume <= 0:
-        source_volume = 50.0
-
+        source_volume = 50.0  # 默认体积
+        debug_print(f"⚠️ 无法获取源容器体积，使用默认值: {source_volume}mL")
+    else:
+        debug_print(f"✅ 源容器体积: {source_volume}mL")
+    
    # === 计算溶剂体积 ===
+    debug_print("📍 步骤5: 计算溶剂体积...")
+    
+    # 洗脱溶剂通常是样品体积的2-5倍
    total_elution_volume = source_volume * 3.0
    solvent1_volume, solvent2_volume = calculate_solvent_volumes(
        total_elution_volume, final_pct1, final_pct2
    )
-
+    
    # === 执行柱层析流程 ===
+    debug_print("📍 步骤6: 执行柱层析流程...")
+    
+    # 🔧 新增：体积变化跟踪变量
    current_from_volume = source_volume
    current_to_volume = original_to_volume
    current_column_volume = 0.0
-
+    
    try:
-        # 步骤1: 样品上柱
-        if column_vessel and column_vessel != from_vessel_id:
+        # 步骤6.1: 样品上柱（如果有独立的柱容器）
+        if column_vessel and column_vessel != from_vessel_id:  # 🔧 使用 from_vessel_id
+            debug_print(f"📍 6.1: 样品上柱 - {source_volume}mL 从 {from_vessel_id} 到 {column_vessel}")
+            
            try:
                sample_transfer_actions = generate_pump_protocol_with_rinsing(
                    G=G,
-                    from_vessel=from_vessel_id,
+                    from_vessel=from_vessel_id,  # 🔧 使用 from_vessel_id
                    to_vessel=column_vessel,
                    volume=source_volume,
-                    flowrate=1.0,
+                    flowrate=1.0,  # 慢速上柱
                    transfer_flowrate=0.5,
-                    rinsing_solvent="",
+                    rinsing_solvent="",  # 暂不冲洗
                    rinsing_volume=0.0,
                    rinsing_repeats=0
                )
                action_sequence.extend(sample_transfer_actions)
-
-                current_from_volume = 0.0
-                current_column_volume = source_volume
-
+                debug_print(f"✅ 样品上柱完成，添加了 {len(sample_transfer_actions)} 个动作")
+                
+                # 🔧 新增：更新体积 - 样品转移到柱上
+                current_from_volume = 0.0  # 源容器体积变为0
+                current_column_volume = source_volume  # 柱容器体积增加
+                
                update_vessel_volume(from_vessel, G, current_from_volume, "样品上柱后，源容器清空")
-
+                
+                # 如果柱容器在图中，也更新其体积
                if column_vessel in G.nodes():
                    if 'data' not in G.nodes[column_vessel]:
                        G.nodes[column_vessel]['data'] = {}
                    G.nodes[column_vessel]['data']['liquid_volume'] = current_column_volume
-
+                    debug_print(f"📊 柱容器 '{column_vessel}' 体积更新为: {current_column_volume:.2f}mL")
+                
            except Exception as e:
-                debug_print(f"样品上柱失败: {str(e)}")
-
-        # 步骤2: 添加洗脱溶剂1
+                debug_print(f"⚠️ 样品上柱失败: {str(e)}")
+        
+        # 步骤6.2: 添加洗脱溶剂1（如果有溶剂容器）
        if solvent1_vessel and solvent1_volume > 0:
+            debug_print(f"📍 6.2: 添加洗脱溶剂1 - {solvent1_volume:.1f}mL {final_solvent1}")
+            
            try:
-                target_vessel = column_vessel if column_vessel else from_vessel_id
+                target_vessel = column_vessel if column_vessel else from_vessel_id  # 🔧 使用 from_vessel_id
                solvent1_transfer_actions = generate_pump_protocol_with_rinsing(
                    G=G,
                    from_vessel=solvent1_vessel,
@@ -302,22 +574,27 @@ def generate_run_column_protocol(
                    transfer_flowrate=1.0
                )
                action_sequence.extend(solvent1_transfer_actions)
-
+                debug_print(f"✅ 溶剂1添加完成，添加了 {len(solvent1_transfer_actions)} 个动作")
+                
+                # 🔧 新增：更新体积 - 添加溶剂1
                if target_vessel == column_vessel:
                    current_column_volume += solvent1_volume
                    if column_vessel in G.nodes():
                        G.nodes[column_vessel]['data']['liquid_volume'] = current_column_volume
+                        debug_print(f"📊 柱容器体积增加: +{solvent1_volume:.2f}mL = {current_column_volume:.2f}mL")
                elif target_vessel == from_vessel_id:
                    current_from_volume += solvent1_volume
                    update_vessel_volume(from_vessel, G, current_from_volume, "添加溶剂1后")
-
+                
            except Exception as e:
-                debug_print(f"溶剂1添加失败: {str(e)}")
-
-        # 步骤3: 添加洗脱溶剂2
+                debug_print(f"⚠️ 溶剂1添加失败: {str(e)}")
+        
+        # 步骤6.3: 添加洗脱溶剂2（如果有溶剂容器）
        if solvent2_vessel and solvent2_volume > 0:
+            debug_print(f"📍 6.3: 添加洗脱溶剂2 - {solvent2_volume:.1f}mL {final_solvent2}")
+            
            try:
-                target_vessel = column_vessel if column_vessel else from_vessel_id
+                target_vessel = column_vessel if column_vessel else from_vessel_id  # 🔧 使用 from_vessel_id
                solvent2_transfer_actions = generate_pump_protocol_with_rinsing(
                    G=G,
                    from_vessel=solvent2_vessel,
@@ -327,26 +604,31 @@ def generate_run_column_protocol(
                    transfer_flowrate=1.0
                )
                action_sequence.extend(solvent2_transfer_actions)
-
+                debug_print(f"✅ 溶剂2添加完成，添加了 {len(solvent2_transfer_actions)} 个动作")
+                
+                # 🔧 新增：更新体积 - 添加溶剂2
                if target_vessel == column_vessel:
                    current_column_volume += solvent2_volume
                    if column_vessel in G.nodes():
                        G.nodes[column_vessel]['data']['liquid_volume'] = current_column_volume
+                        debug_print(f"📊 柱容器体积增加: +{solvent2_volume:.2f}mL = {current_column_volume:.2f}mL")
                elif target_vessel == from_vessel_id:
                    current_from_volume += solvent2_volume
                    update_vessel_volume(from_vessel, G, current_from_volume, "添加溶剂2后")
-
+                
            except Exception as e:
-                debug_print(f"溶剂2添加失败: {str(e)}")
-
-        # 步骤4: 使用柱层析设备执行分离
+                debug_print(f"⚠️ 溶剂2添加失败: {str(e)}")
+        
+        # 步骤6.4: 使用柱层析设备执行分离（如果有设备）
        if column_device_id:
+            debug_print(f"📍 6.4: 使用柱层析设备执行分离")
+            
            column_separation_action = {
                "device_id": column_device_id,
                "action_name": "run_column",
                "action_kwargs": {
-                    "from_vessel": from_vessel_id,
-                    "to_vessel": to_vessel_id,
+                    "from_vessel": from_vessel_id,  # 🔧 使用 from_vessel_id
+                    "to_vessel": to_vessel_id,      # 🔧 使用 to_vessel_id
                    "column": column,
                    "rf": rf,
                    "pct1": pct1,
@@ -357,65 +639,85 @@ def generate_run_column_protocol(
                }
            }
            action_sequence.append(column_separation_action)
-
-            separation_time = max(30, min(120, int(total_elution_volume / 2)))
+            debug_print(f"✅ 柱层析设备动作已添加")
+            
+            # 等待分离完成
+            separation_time = max(30, min(120, int(total_elution_volume / 2)))  # 30-120秒，基于体积
            action_sequence.append({
                "action_name": "wait",
                "action_kwargs": {"time": separation_time}
            })
-
-        # 步骤5: 产物收集
-        if column_vessel and column_vessel != to_vessel_id:
+            debug_print(f"✅ 等待分离完成: {separation_time}秒")
+        
+        # 步骤6.5: 产物收集（从柱容器到目标容器）
+        if column_vessel and column_vessel != to_vessel_id:  # 🔧 使用 to_vessel_id
+            debug_print(f"📍 6.5: 产物收集 - 从 {column_vessel} 到 {to_vessel_id}")
+            
            try:
+                # 估算产物体积（原始样品体积的70-90%，收率考虑）
                product_volume = source_volume * 0.8
-
+                
                product_transfer_actions = generate_pump_protocol_with_rinsing(
                    G=G,
                    from_vessel=column_vessel,
-                    to_vessel=to_vessel_id,
+                    to_vessel=to_vessel_id,  # 🔧 使用 to_vessel_id
                    volume=product_volume,
                    flowrate=1.5,
                    transfer_flowrate=0.8
                )
                action_sequence.extend(product_transfer_actions)
-
+                debug_print(f"✅ 产物收集完成，添加了 {len(product_transfer_actions)} 个动作")
+                
+                # 🔧 新增：更新体积 - 产物收集到目标容器
                current_to_volume += product_volume
-                current_column_volume -= product_volume
-
+                current_column_volume -= product_volume  # 柱容器体积减少
+                
                update_vessel_volume(to_vessel, G, current_to_volume, "产物收集后")
-
+                
+                # 更新柱容器体积
                if column_vessel in G.nodes():
                    G.nodes[column_vessel]['data']['liquid_volume'] = max(0.0, current_column_volume)
-
+                    debug_print(f"📊 柱容器体积减少: -{product_volume:.2f}mL = {current_column_volume:.2f}mL")
+                
            except Exception as e:
-                debug_print(f"产物收集失败: {str(e)}")
-
-        # 步骤6: 简化模式 - 直接转移
+                debug_print(f"⚠️ 产物收集失败: {str(e)}")
+        
+        # 步骤6.6: 如果没有独立的柱设备和容器，执行简化的直接转移
        if not column_device_id and not column_vessel:
+            debug_print(f"📍 6.6: 简化模式 - 直接转移 {source_volume}mL 从 {from_vessel_id} 到 {to_vessel_id}")
+            
            try:
                direct_transfer_actions = generate_pump_protocol_with_rinsing(
                    G=G,
-                    from_vessel=from_vessel_id,
-                    to_vessel=to_vessel_id,
+                    from_vessel=from_vessel_id,  # 🔧 使用 from_vessel_id
+                    to_vessel=to_vessel_id,      # 🔧 使用 to_vessel_id
                    volume=source_volume,
                    flowrate=2.0,
                    transfer_flowrate=1.0
                )
                action_sequence.extend(direct_transfer_actions)
-
-                current_from_volume = 0.0
-                current_to_volume += source_volume
-
+                debug_print(f"✅ 直接转移完成，添加了 {len(direct_transfer_actions)} 个动作")
+                
+                # 🔧 新增：更新体积 - 直接转移
+                current_from_volume = 0.0  # 源容器清空
+                current_to_volume += source_volume  # 目标容器增加
+                
                update_vessel_volume(from_vessel, G, current_from_volume, "直接转移后，源容器清空")
                update_vessel_volume(to_vessel, G, current_to_volume, "直接转移后，目标容器增加")
-
+                
            except Exception as e:
-                debug_print(f"直接转移失败: {str(e)}")
-
+                debug_print(f"⚠️ 直接转移失败: {str(e)}")
+        
    except Exception as e:
-        debug_print(f"协议生成失败: {str(e)}")
-
+        debug_print(f"❌ 协议生成失败: {str(e)} 😭")
+        
+        # 不添加不确定的动作，直接让action_sequence保持为空列表
+        # action_sequence 已经在函数开始时初始化为 []
+    
+    # 确保至少有一个有效的动作，如果完全失败就返回空列表
    if not action_sequence:
+        debug_print("⚠️ 没有生成任何有效动作")
+        # 可以选择返回空列表或添加一个基本的等待动作
        action_sequence.append({
            "action_name": "wait",
            "action_kwargs": {
@@ -423,50 +725,83 @@ def generate_run_column_protocol(
                "description": "柱层析协议执行完成"
            }
        })
-
-    final_from_volume = get_resource_liquid_volume(from_vessel)
-    final_to_volume = get_resource_liquid_volume(to_vessel)
-
-    debug_print(f"柱层析协议生成完成: {len(action_sequence)} 个动作, {from_vessel_id} -> {to_vessel_id}, 收集={final_to_volume - original_to_volume:.2f}mL")
-
+    
+    # 🔧 新增：柱层析完成后的最终状态报告
+    final_from_volume = get_vessel_liquid_volume(from_vessel)
+    final_to_volume = get_vessel_liquid_volume(to_vessel)
+    
+    # 🎊 总结
+    debug_print("🏛️" * 20)
+    debug_print(f"🎉 柱层析协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 路径: {from_vessel_id} → {to_vessel_id}")
+    debug_print(f"🏛️ 柱子: {column}")
+    debug_print(f"🧪 溶剂: {final_solvent1}:{final_solvent2} = {final_pct1:.1f}%:{final_pct2:.1f}%")
+    debug_print(f"📊 体积变化统计:")
+    debug_print(f"  源容器 {from_vessel_id}:")
+    debug_print(f"    - 柱层析前: {original_from_volume:.2f}mL")
+    debug_print(f"    - 柱层析后: {final_from_volume:.2f}mL")
+    debug_print(f"  目标容器 {to_vessel_id}:")
+    debug_print(f"    - 柱层析前: {original_to_volume:.2f}mL")
+    debug_print(f"    - 柱层析后: {final_to_volume:.2f}mL")
+    debug_print(f"    - 收集体积: {final_to_volume - original_to_volume:.2f}mL")
+    debug_print(f"⏱️ 预计总时间: {len(action_sequence) * 5:.0f} 秒 ⌛")
+    debug_print("🏛️" * 20)
+    
    return action_sequence

-# 便捷函数
-def generate_ethyl_acetate_hexane_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict,
+# 🔧 新增：便捷函数
+def generate_ethyl_acetate_hexane_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
                                                 column: str, ratio: str = "30:70") -> List[Dict[str, Any]]:
    """乙酸乙酯-己烷柱层析（常用组合）"""
-    return generate_run_column_protocol(G, from_vessel, to_vessel, column,
+    from_vessel_id = from_vessel["id"]
+    to_vessel_id = to_vessel["id"]
+    debug_print(f"🧪⛽ 乙酸乙酯-己烷柱层析: {from_vessel_id} → {to_vessel_id} @ {ratio}")
+    return generate_run_column_protocol(G, from_vessel, to_vessel, column, 
                                      solvent1="ethyl_acetate", solvent2="hexane", ratio=ratio)

-def generate_methanol_dcm_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict,
+def generate_methanol_dcm_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
                                        column: str, ratio: str = "5:95") -> List[Dict[str, Any]]:
    """甲醇-二氯甲烷柱层析"""
-    return generate_run_column_protocol(G, from_vessel, to_vessel, column,
+    from_vessel_id = from_vessel["id"]
+    to_vessel_id = to_vessel["id"]
+    debug_print(f"🧪🧪 甲醇-DCM柱层析: {from_vessel_id} → {to_vessel_id} @ {ratio}")
+    return generate_run_column_protocol(G, from_vessel, to_vessel, column, 
                                      solvent1="methanol", solvent2="dichloromethane", ratio=ratio)

-def generate_gradient_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict,
-                                    column: str, start_ratio: str = "10:90",
+def generate_gradient_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
+                                    column: str, start_ratio: str = "10:90", 
                                    end_ratio: str = "50:50") -> List[Dict[str, Any]]:
    """梯度洗脱柱层析（中等比例）"""
+    from_vessel_id, _ = get_vessel(from_vessel)
+    to_vessel_id, _ = get_vessel(to_vessel)
+    debug_print(f"📈 梯度柱层析: {from_vessel_id} → {to_vessel_id} ({start_ratio} → {end_ratio})")
+    # 使用中间比例作为近似
    return generate_run_column_protocol(G, from_vessel, to_vessel, column, ratio="30:70")

-def generate_polar_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict,
+def generate_polar_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
                                 column: str) -> List[Dict[str, Any]]:
    """极性化合物柱层析（高极性溶剂比例）"""
-    return generate_run_column_protocol(G, from_vessel, to_vessel, column,
+    from_vessel_id, _ = get_vessel(from_vessel)
+    to_vessel_id, _ = get_vessel(to_vessel)
+    debug_print(f"⚡ 极性化合物柱层析: {from_vessel_id} → {to_vessel_id}")
+    return generate_run_column_protocol(G, from_vessel, to_vessel, column, 
                                      solvent1="ethyl_acetate", solvent2="hexane", ratio="70:30")

-def generate_nonpolar_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict,
+def generate_nonpolar_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
                                    column: str) -> List[Dict[str, Any]]:
    """非极性化合物柱层析（低极性溶剂比例）"""
-    return generate_run_column_protocol(G, from_vessel, to_vessel, column,
+    from_vessel_id, _ = get_vessel(from_vessel)
+    to_vessel_id, _ = get_vessel(to_vessel)
+    debug_print(f"🛢️ 非极性化合物柱层析: {from_vessel_id} → {to_vessel_id}")
+    return generate_run_column_protocol(G, from_vessel, to_vessel, column, 
                                      solvent1="ethyl_acetate", solvent2="hexane", ratio="5:95")

 # 测试函数
 def test_run_column_protocol():
    """测试柱层析协议"""
-    debug_print("=== RUN COLUMN PROTOCOL 测试 ===")
-    debug_print("测试完成")
+    debug_print("🧪 === RUN COLUMN PROTOCOL 测试 === ✨")
+    debug_print("✅ 测试完成 🎉")

 if __name__ == "__main__":
    test_run_column_protocol()
--- a/unilabos/compile/separate_protocol.py
+++ b/unilabos/compile/separate_protocol.py
@@ -1,11 +1,41 @@
+from functools import partial
+
 import networkx as nx
+import re
+import logging
+import sys
 from typing import List, Dict, Any, Union
-from .utils.vessel_parser import get_vessel, find_solvent_vessel, find_connected_stirrer
-from .utils.resource_helper import get_resource_liquid_volume, update_vessel_volume
-from .utils.logger_util import debug_print, action_log
-from .utils.unit_parser import parse_volume_input
+from .utils.vessel_parser import get_vessel
+from .utils.logger_util import action_log
 from .pump_protocol import generate_pump_protocol_with_rinsing

+logger = logging.getLogger(__name__)
+
+# 确保输出编码为UTF-8
+if hasattr(sys.stdout, 'reconfigure'):
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except:
+        pass
+
+def debug_print(message):
+    """调试输出函数 - 支持中文"""
+    try:
+        # 确保消息是字符串格式
+        safe_message = str(message)
+        logger.info(f"[SEPARATE] {safe_message}")
+    except UnicodeEncodeError:
+        # 如果编码失败，尝试替换不支持的字符
+        safe_message = str(message).encode('utf-8', errors='replace').decode('utf-8')
+        logger.info(f"[SEPARATE] {safe_message}")
+    except Exception as e:
+        # 最后的安全措施
+        fallback_message = f"日志输出错误: {repr(message)}"
+        logger.info(f"[SEPARATE] {fallback_message}")
+
+create_action_log = partial(action_log, prefix="[SEPARATE]")
+

 def generate_separate_protocol(
    G: nx.DiGraph,
@@ -63,33 +93,45 @@ def generate_separate_protocol(
    # 🔧 核心修改：从字典中提取容器ID
    vessel_id, vessel_data = get_vessel(vessel)

-    debug_print(f"开始生成分离协议: vessel={vessel_id}, purpose={purpose}, "
-                f"product_phase={product_phase}, solvent={solvent}, "
-                f"volume={volume}, repeats={repeats}")
+    debug_print("🌀" * 20)
+    debug_print("🚀 开始生成分离协议（支持vessel字典和体积运算）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  🎯 分离目的: '{purpose}'")
+    debug_print(f"  📊 产物相: '{product_phase}'")
+    debug_print(f"  💧 溶剂: '{solvent}'")
+    debug_print(f"  📏 体积: {volume} (类型: {type(volume)})")
+    debug_print(f"  🔄 重复次数: {repeats}")
+    debug_print(f"  🎯 产物容器: '{product_vessel}'")
+    debug_print(f"  🗑️ 废液容器: '{waste_vessel}'")
+    debug_print(f"  📦 其他参数: {kwargs}")
+    debug_print("🌀" * 20)

    action_sequence = []

-    # 记录分离前的容器状态
-    original_liquid_volume = get_resource_liquid_volume(vessel)
-    debug_print(f"分离前液体体积: {original_liquid_volume:.2f}mL")
+    # 🔧 新增：记录分离前的容器状态
+    debug_print("🔍 记录分离前容器状态...")
+    original_liquid_volume = get_vessel_liquid_volume(vessel)
+    debug_print(f"📊 分离前液体体积: {original_liquid_volume:.2f}mL")

    # === 参数验证和标准化 ===
-    action_sequence.append(action_log(f"开始分离操作 - 容器: {vessel_id}", "🎬", prefix="[SEPARATE]"))
-    action_sequence.append(action_log(f"分离目的: {purpose}", "🧪", prefix="[SEPARATE]"))
-    action_sequence.append(action_log(f"产物相: {product_phase}", "📊", prefix="[SEPARATE]"))
+    debug_print("🔍 步骤1: 参数验证和标准化...")
+    action_sequence.append(create_action_log(f"开始分离操作 - 容器: {vessel_id}", "🎬"))
+    action_sequence.append(create_action_log(f"分离目的: {purpose}", "🧪"))
+    action_sequence.append(create_action_log(f"产物相: {product_phase}", "📊"))

    # 统一容器参数 - 支持字典和字符串
-    final_vessel_id = vessel_id
+    def extract_vessel_id(vessel_param):
+        if isinstance(vessel_param, dict):
+            return vessel_param.get("id", "")
+        elif isinstance(vessel_param, str):
+            return vessel_param
+        else:
+            return ""

-    to_vessel_result = get_vessel(to_vessel) if to_vessel else None
-    if to_vessel_result is None or to_vessel_result[0] == "":
-        to_vessel_result = get_vessel(product_vessel) if product_vessel else None
-    final_to_vessel_id = to_vessel_result[0] if to_vessel_result else ""
-
-    waste_vessel_result = get_vessel(waste_phase_to_vessel) if waste_phase_to_vessel else None
-    if waste_vessel_result is None or waste_vessel_result[0] == "":
-        waste_vessel_result = get_vessel(waste_vessel) if waste_vessel else None
-    final_waste_vessel_id = waste_vessel_result[0] if waste_vessel_result else ""
+    final_vessel_id, _ = vessel_id
+    final_to_vessel_id, _ = get_vessel(to_vessel) or get_vessel(product_vessel)
+    final_waste_vessel_id, _ = get_vessel(waste_phase_to_vessel) or get_vessel(waste_vessel)

    # 统一体积参数
    final_volume = parse_volume_input(volume or solvent_volume)
@@ -99,12 +141,16 @@ def generate_separate_protocol(
        repeats = 1
        debug_print(f"⚠️ 重复次数参数 <= 0，自动设置为 1")

-    debug_print(f"标准化参数: vessel={final_vessel_id}, to={final_to_vessel_id}, "
-                f"waste={final_waste_vessel_id}, volume={final_volume}mL, repeats={repeats}")
+    debug_print(f"🔧 标准化后的参数:")
+    debug_print(f"  🥼 分离容器: '{final_vessel_id}'")
+    debug_print(f"  🎯 产物容器: '{final_to_vessel_id}'")
+    debug_print(f"  🗑️ 废液容器: '{final_waste_vessel_id}'")
+    debug_print(f"  📏 溶剂体积: {final_volume}mL")
+    debug_print(f"  🔄 重复次数: {repeats}")

-    action_sequence.append(action_log(f"分离容器: {final_vessel_id}", "🧪", prefix="[SEPARATE]"))
-    action_sequence.append(action_log(f"溶剂体积: {final_volume}mL", "📏", prefix="[SEPARATE]"))
-    action_sequence.append(action_log(f"重复次数: {repeats}", "🔄", prefix="[SEPARATE]"))
+    action_sequence.append(create_action_log(f"分离容器: {final_vessel_id}", "🧪"))
+    action_sequence.append(create_action_log(f"溶剂体积: {final_volume}mL", "📏"))
+    action_sequence.append(create_action_log(f"重复次数: {repeats}", "🔄"))

    # 验证必需参数
    if not purpose:
@@ -114,68 +160,72 @@ def generate_separate_protocol(
    if purpose not in ["wash", "extract", "separate"]:
        debug_print(f"⚠️ 未知的分离目的 '{purpose}'，使用默认值 'separate'")
        purpose = "separate"
-        action_sequence.append(action_log(f"未知目的，使用: {purpose}", "⚠️", prefix="[SEPARATE]"))
+        action_sequence.append(create_action_log(f"未知目的，使用: {purpose}", "⚠️"))
    if product_phase not in ["top", "bottom"]:
        debug_print(f"⚠️ 未知的产物相 '{product_phase}'，使用默认值 'top'")
        product_phase = "top"
-        action_sequence.append(action_log(f"未知相别，使用: {product_phase}", "⚠️", prefix="[SEPARATE]"))
+        action_sequence.append(create_action_log(f"未知相别，使用: {product_phase}", "⚠️"))

-    action_sequence.append(action_log("参数验证通过", "✅", prefix="[SEPARATE]"))
+    debug_print("✅ 参数验证通过")
+    action_sequence.append(create_action_log("参数验证通过", "✅"))

    # === 查找设备 ===
-    action_sequence.append(action_log("正在查找相关设备...", "🔍", prefix="[SEPARATE]"))
+    debug_print("🔍 步骤2: 查找设备...")
+    action_sequence.append(create_action_log("正在查找相关设备...", "🔍"))

    # 查找分离器设备
-    separator_device = find_separator_device(G, final_vessel_id)
+    separator_device = find_separator_device(G, final_vessel_id)  # 🔧 使用 final_vessel_id
    if separator_device:
-        action_sequence.append(action_log(f"找到分离器设备: {separator_device}", "🧪", prefix="[SEPARATE]"))
+        action_sequence.append(create_action_log(f"找到分离器设备: {separator_device}", "🧪"))
    else:
        debug_print("⚠️ 未找到分离器设备，可能无法执行分离")
-        action_sequence.append(action_log("未找到分离器设备", "⚠️", prefix="[SEPARATE]"))
+        action_sequence.append(create_action_log("未找到分离器设备", "⚠️"))

    # 查找搅拌器
-    stirrer_device = find_connected_stirrer(G, final_vessel_id)
+    stirrer_device = find_connected_stirrer(G, final_vessel_id)  # 🔧 使用 final_vessel_id
    if stirrer_device:
-        action_sequence.append(action_log(f"找到搅拌器: {stirrer_device}", "🌪️", prefix="[SEPARATE]"))
+        action_sequence.append(create_action_log(f"找到搅拌器: {stirrer_device}", "🌪️"))
    else:
-        action_sequence.append(action_log("未找到搅拌器", "⚠️", prefix="[SEPARATE]"))
+        action_sequence.append(create_action_log("未找到搅拌器", "⚠️"))

    # 查找溶剂容器（如果需要）
    solvent_vessel = ""
    if solvent and solvent.strip():
-        try:
-            solvent_vessel = find_solvent_vessel(G, solvent)
-        except ValueError:
-            solvent_vessel = ""
+        solvent_vessel = find_solvent_vessel(G, solvent)
        if solvent_vessel:
-            action_sequence.append(action_log(f"找到溶剂容器: {solvent_vessel}", "💧", prefix="[SEPARATE]"))
+            action_sequence.append(create_action_log(f"找到溶剂容器: {solvent_vessel}", "💧"))
        else:
-            action_sequence.append(action_log(f"未找到溶剂容器: {solvent}", "⚠️", prefix="[SEPARATE]"))
+            action_sequence.append(create_action_log(f"未找到溶剂容器: {solvent}", "⚠️"))

-    debug_print(f"设备配置: separator={separator_device}, stirrer={stirrer_device}, solvent_vessel={solvent_vessel}")
+    debug_print(f"📊 设备配置:")
+    debug_print(f"  🧪 分离器设备: '{separator_device}'")
+    debug_print(f"  🌪️ 搅拌器设备: '{stirrer_device}'")
+    debug_print(f"  💧 溶剂容器: '{solvent_vessel}'")

    # === 执行分离流程 ===
-    action_sequence.append(action_log("开始分离工作流程", "🎯", prefix="[SEPARATE]"))
+    debug_print("🔍 步骤3: 执行分离流程...")
+    action_sequence.append(create_action_log("开始分离工作流程", "🎯"))

-    # 体积变化跟踪变量
+    # 🔧 新增：体积变化跟踪变量
    current_volume = original_liquid_volume

    try:
        for repeat_idx in range(repeats):
            cycle_num = repeat_idx + 1
-            debug_print(f"分离循环 {cycle_num}/{repeats} 开始")
-            action_sequence.append(action_log(f"分离循环 {cycle_num}/{repeats} 开始", "🔄", prefix="[SEPARATE]"))
+            debug_print(f"🔄 第{cycle_num}轮: 开始分离循环 {cycle_num}/{repeats}")
+            action_sequence.append(create_action_log(f"分离循环 {cycle_num}/{repeats} 开始", "🔄"))

            # 步骤3.1: 添加溶剂（如果需要）
            if solvent_vessel and final_volume > 0:
-                action_sequence.append(action_log(f"向分离容器添加 {final_volume}mL {solvent}", "💧", prefix="[SEPARATE]"))
+                debug_print(f"🔄 第{cycle_num}轮 步骤1: 添加溶剂 {solvent} ({final_volume}mL)")
+                action_sequence.append(create_action_log(f"向分离容器添加 {final_volume}mL {solvent}", "💧"))

                try:
                    # 使用pump protocol添加溶剂
                    pump_actions = generate_pump_protocol_with_rinsing(
                        G=G,
                        from_vessel=solvent_vessel,
-                        to_vessel=final_vessel_id,
+                        to_vessel=final_vessel_id,  # 🔧 使用 final_vessel_id
                        volume=final_volume,
                        amount="",
                        time=0.0,
@@ -192,27 +242,30 @@ def generate_separate_protocol(
                        **kwargs
                    )
                    action_sequence.extend(pump_actions)
-                    action_sequence.append(action_log(f"溶剂转移完成 ({len(pump_actions)} 个操作)", "✅", prefix="[SEPARATE]"))
+                    debug_print(f"✅ 溶剂添加完成，添加了 {len(pump_actions)} 个动作")
+                    action_sequence.append(create_action_log(f"溶剂转移完成 ({len(pump_actions)} 个操作)", "✅"))

-                    # 更新体积 - 添加溶剂后
+                    # 🔧 新增：更新体积 - 添加溶剂后
                    current_volume += final_volume
                    update_vessel_volume(vessel, G, current_volume, f"添加{final_volume}mL {solvent}后")

                except Exception as e:
                    debug_print(f"❌ 溶剂添加失败: {str(e)}")
-                    action_sequence.append(action_log(f"溶剂添加失败: {str(e)}", "❌", prefix="[SEPARATE]"))
+                    action_sequence.append(create_action_log(f"溶剂添加失败: {str(e)}", "❌"))
            else:
-                action_sequence.append(action_log("无需添加溶剂", "⏭️", prefix="[SEPARATE]"))
+                debug_print(f"🔄 第{cycle_num}轮 步骤1: 无需添加溶剂")
+                action_sequence.append(create_action_log("无需添加溶剂", "⏭️"))

            # 步骤3.2: 启动搅拌（如果有搅拌器）
            if stirrer_device and stir_time > 0:
-                action_sequence.append(action_log(f"开始搅拌: {stir_speed}rpm，持续 {stir_time}s", "🌪️", prefix="[SEPARATE]"))
+                debug_print(f"🔄 第{cycle_num}轮 步骤2: 开始搅拌 ({stir_speed}rpm，持续 {stir_time}s)")
+                action_sequence.append(create_action_log(f"开始搅拌: {stir_speed}rpm，持续 {stir_time}s", "🌪️"))

                action_sequence.append({
                    "device_id": stirrer_device,
                    "action_name": "start_stir",
                    "action_kwargs": {
-                        "vessel": {"id": final_vessel_id},
+                        "vessel": {"id": final_vessel_id},  # 🔧 使用 final_vessel_id
                        "stir_speed": stir_speed,
                        "purpose": f"分离混合 - {purpose}"
                    }
@@ -220,37 +273,43 @@ def generate_separate_protocol(

                # 搅拌等待
                stir_minutes = stir_time / 60
-                action_sequence.append(action_log(f"搅拌中，持续 {stir_minutes:.1f} 分钟", "⏱️", prefix="[SEPARATE]"))
+                action_sequence.append(create_action_log(f"搅拌中，持续 {stir_minutes:.1f} 分钟", "⏱️"))
                action_sequence.append({
                    "action_name": "wait",
                    "action_kwargs": {"time": stir_time}
                })

                # 停止搅拌
-                action_sequence.append(action_log("停止搅拌器", "🛑", prefix="[SEPARATE]"))
+                action_sequence.append(create_action_log("停止搅拌器", "🛑"))
                action_sequence.append({
                    "device_id": stirrer_device,
                    "action_name": "stop_stir",
-                    "action_kwargs": {"vessel": final_vessel_id}
+                    "action_kwargs": {"vessel": final_vessel_id}  # 🔧 使用 final_vessel_id
                })

            else:
-                action_sequence.append(action_log("无需搅拌", "⏭️", prefix="[SEPARATE]"))
+                debug_print(f"🔄 第{cycle_num}轮 步骤2: 无需搅拌")
+                action_sequence.append(create_action_log("无需搅拌", "⏭️"))

            # 步骤3.3: 静置分层
            if settling_time > 0:
+                debug_print(f"🔄 第{cycle_num}轮 步骤3: 静置分层 ({settling_time}s)")
                settling_minutes = settling_time / 60
-                action_sequence.append(action_log(f"静置分层 ({settling_minutes:.1f} 分钟)", "⚖️", prefix="[SEPARATE]"))
+                action_sequence.append(create_action_log(f"静置分层 ({settling_minutes:.1f} 分钟)", "⚖️"))
                action_sequence.append({
                    "action_name": "wait",
                    "action_kwargs": {"time": settling_time}
                })
            else:
-                action_sequence.append(action_log("未指定静置时间", "⏭️", prefix="[SEPARATE]"))
+                debug_print(f"🔄 第{cycle_num}轮 步骤3: 未指定静置时间")
+                action_sequence.append(create_action_log("未指定静置时间", "⏭️"))

            # 步骤3.4: 执行分离操作
            if separator_device:
-                action_sequence.append(action_log(f"执行分离: 收集{product_phase}相", "🧪", prefix="[SEPARATE]"))
+                debug_print(f"🔄 第{cycle_num}轮 步骤4: 执行分离操作")
+                action_sequence.append(create_action_log(f"执行分离: 收集{product_phase}相", "🧪"))
+
+                # 🔧 替换为具体的分离操作逻辑（基于old版本）

                # 首先进行分液判断（电导突跃）
                action_sequence.append({
@@ -265,10 +324,11 @@ def generate_separate_protocol(
                phase_volume = current_volume / 2

                # 智能查找分离容器底部
-                separation_vessel_bottom = find_separation_vessel_bottom(G, final_vessel_id)
+                separation_vessel_bottom = find_separation_vessel_bottom(G, final_vessel_id)  # ✅

                if product_phase == "bottom":
-                    action_sequence.append(action_log("收集底相产物", "📦", prefix="[SEPARATE]"))
+                    debug_print(f"🔄 收集底相产物到 {final_to_vessel_id}")
+                    action_sequence.append(create_action_log("收集底相产物", "📦"))

                    # 产物转移到目标瓶
                    if final_to_vessel_id:
@@ -304,7 +364,8 @@ def generate_separate_protocol(
                        action_sequence.extend(pump_actions)

                elif product_phase == "top":
-                    action_sequence.append(action_log("收集上相产物", "📦", prefix="[SEPARATE]"))
+                    debug_print(f"🔄 收集上相产物到 {final_to_vessel_id}")
+                    action_sequence.append(create_action_log("收集上相产物", "📦"))

                    # 弃去下面那一相进废液
                    if final_waste_vessel_id:
@@ -339,9 +400,10 @@ def generate_separate_protocol(
                        )
                        action_sequence.extend(pump_actions)

-                action_sequence.append(action_log("分离操作完成", "✅", prefix="[SEPARATE]"))
+                debug_print(f"✅ 分离操作已完成")
+                action_sequence.append(create_action_log("分离操作完成", "✅"))

-                # 分离后体积估算
+                # 🔧 新增：分离后体积估算
                separated_volume = phase_volume * 0.95  # 假设5%损失，只保留产物相体积
                update_vessel_volume(vessel, G, separated_volume, f"分离操作后（第{cycle_num}轮）")
                current_volume = separated_volume
@@ -349,21 +411,23 @@ def generate_separate_protocol(
                # 收集结果
                if final_to_vessel_id:
                    action_sequence.append(
-                        action_log(f"产物 ({product_phase}相) 收集到: {final_to_vessel_id}", "📦", prefix="[SEPARATE]"))
+                        create_action_log(f"产物 ({product_phase}相) 收集到: {final_to_vessel_id}", "📦"))
                if final_waste_vessel_id:
-                    action_sequence.append(action_log(f"废相收集到: {final_waste_vessel_id}", "🗑️", prefix="[SEPARATE]"))
+                    action_sequence.append(create_action_log(f"废相收集到: {final_waste_vessel_id}", "🗑️"))

            else:
-                action_sequence.append(action_log("无分离器设备可用", "❌", prefix="[SEPARATE]"))
+                debug_print(f"🔄 第{cycle_num}轮 步骤4: 无分离器设备，跳过分离")
+                action_sequence.append(create_action_log("无分离器设备可用", "❌"))
                # 添加等待时间模拟分离
                action_sequence.append({
                    "action_name": "wait",
                    "action_kwargs": {"time": 10.0}
                })

-            # 如果不是最后一次，从中转瓶转移回分液漏斗
+            # 🔧 新增：如果不是最后一次，从中转瓶转移回分液漏斗（基于old版本逻辑）
            if repeat_idx < repeats - 1 and final_to_vessel_id and final_to_vessel_id != final_vessel_id:
-                action_sequence.append(action_log("产物转回分离容器，准备下一轮", "🔄", prefix="[SEPARATE]"))
+                debug_print(f"🔄 第{cycle_num}轮: 产物转移回分离容器准备下一轮")
+                action_sequence.append(create_action_log("产物转回分离容器，准备下一轮", "🔄"))

                pump_actions = generate_pump_protocol_with_rinsing(
                    G=G,
@@ -380,85 +444,368 @@ def generate_separate_protocol(

            # 循环间等待（除了最后一次）
            if repeat_idx < repeats - 1:
-                action_sequence.append(action_log("等待下一次循环...", "⏳", prefix="[SEPARATE]"))
+                debug_print(f"🔄 第{cycle_num}轮: 等待下一次循环...")
+                action_sequence.append(create_action_log("等待下一次循环...", "⏳"))
                action_sequence.append({
                    "action_name": "wait",
                    "action_kwargs": {"time": 5}
                })
            else:
-                action_sequence.append(action_log(f"分离循环 {cycle_num}/{repeats} 完成", "🌟", prefix="[SEPARATE]"))
+                action_sequence.append(create_action_log(f"分离循环 {cycle_num}/{repeats} 完成", "🌟"))

    except Exception as e:
        debug_print(f"❌ 分离工作流程执行失败: {str(e)}")
-        action_sequence.append(action_log(f"分离工作流程失败: {str(e)}", "❌", prefix="[SEPARATE]"))
+        action_sequence.append(create_action_log(f"分离工作流程失败: {str(e)}", "❌"))

-    # 分离完成后的最终状态报告
-    final_liquid_volume = get_resource_liquid_volume(vessel)
+    # 🔧 新增：分离完成后的最终状态报告
+    final_liquid_volume = get_vessel_liquid_volume(vessel)

    # === 最终结果 ===
    total_time = (stir_time + settling_time + 15) * repeats  # 估算总时间

-    debug_print(f"分离协议生成完成: {len(action_sequence)} 个动作, "
-                f"预计 {total_time:.0f}s, 体积 {original_liquid_volume:.2f}→{final_liquid_volume:.2f}mL")
+    debug_print("🌀" * 20)
+    debug_print(f"🎉 分离协议生成完成")
+    debug_print(f"📊 协议统计:")
+    debug_print(f"  📋 总动作数: {len(action_sequence)}")
+    debug_print(f"  ⏱️ 预计总时间: {total_time:.0f}s ({total_time / 60:.1f} 分钟)")
+    debug_print(f"  🥼 分离容器: {final_vessel_id}")
+    debug_print(f"  🎯 分离目的: {purpose}")
+    debug_print(f"  📊 产物相: {product_phase}")
+    debug_print(f"  🔄 重复次数: {repeats}")
+    debug_print(f"💧 体积变化统计:")
+    debug_print(f"  - 分离前体积: {original_liquid_volume:.2f}mL")
+    debug_print(f"  - 分离后体积: {final_liquid_volume:.2f}mL")
+    if solvent:
+        debug_print(f"  💧 溶剂: {solvent} ({final_volume}mL × {repeats}轮 = {final_volume * repeats:.2f}mL)")
+    if final_to_vessel_id:
+        debug_print(f"  🎯 产物容器: {final_to_vessel_id}")
+    if final_waste_vessel_id:
+        debug_print(f"  🗑️ 废液容器: {final_waste_vessel_id}")
+    debug_print("🌀" * 20)

    # 添加完成日志
    summary_msg = f"分离协议完成: {final_vessel_id} ({purpose}，{repeats} 次循环)"
    if solvent:
        summary_msg += f"，使用 {final_volume * repeats:.2f}mL {solvent}"
-    action_sequence.append(action_log(summary_msg, "🎉", prefix="[SEPARATE]"))
+    action_sequence.append(create_action_log(summary_msg, "🎉"))

    return action_sequence

+def parse_volume_input(volume_input: Union[str, float]) -> float:
+    """
+    解析体积输入，支持带单位的字符串
+    
+    Args:
+        volume_input: 体积输入（如 "200 mL", "?", 50.0）
+    
+    Returns:
+        float: 体积（毫升）
+    """
+    if isinstance(volume_input, (int, float)):
+        debug_print(f"📏 体积输入为数值: {volume_input}")
+        return float(volume_input)
+    
+    if not volume_input or not str(volume_input).strip():
+        debug_print(f"⚠️ 体积输入为空，返回 0.0mL")
+        return 0.0
+    
+    volume_str = str(volume_input).lower().strip()
+    debug_print(f"🔍 解析体积输入: '{volume_str}'")
+    
+    # 处理未知体积
+    if volume_str in ['?', 'unknown', 'tbd', 'to be determined', '未知', '待定']:
+        default_volume = 100.0  # 默认100mL
+        debug_print(f"❓ 检测到未知体积，使用默认值: {default_volume}mL")
+        return default_volume
+    
+    # 移除空格并提取数字和单位
+    volume_clean = re.sub(r'\s+', '', volume_str)
+    
+    # 匹配数字和单位的正则表达式
+    match = re.match(r'([0-9]*\.?[0-9]+)\s*(ml|l|μl|ul|microliter|milliliter|liter|毫升|升|微升)?', volume_clean)
+    
+    if not match:
+        debug_print(f"⚠️ 无法解析体积: '{volume_str}'，使用默认值 100mL")
+        return 100.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or 'ml'  # 默认单位为毫升
+    
+    # 转换为毫升
+    if unit in ['l', 'liter', '升']:
+        volume = value * 1000.0  # L -> mL
+        debug_print(f"🔄 体积转换: {value}L -> {volume}mL")
+    elif unit in ['μl', 'ul', 'microliter', '微升']:
+        volume = value / 1000.0  # μL -> mL
+        debug_print(f"🔄 体积转换: {value}μL -> {volume}mL")
+    else:  # ml, milliliter, 毫升 或默认
+        volume = value  # 已经是mL
+        debug_print(f"✅ 体积已为毫升单位: {volume}mL")
+    
+    return volume
+
+def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
+    """查找溶剂容器，支持多种匹配模式"""
+    if not solvent or not solvent.strip():
+        debug_print("⏭️ 未指定溶剂，跳过溶剂容器查找")
+        return ""
+    
+    debug_print(f"🔍 正在查找溶剂 '{solvent}' 的容器...")
+    
+    # 🔧 方法1：直接搜索 data.reagent_name 和 config.reagent
+    debug_print(f"📋 方法1: 搜索试剂字段...")
+    for node in G.nodes():
+        node_data = G.nodes[node].get('data', {})
+        node_type = G.nodes[node].get('type', '')
+        config_data = G.nodes[node].get('config', {})
+        
+        # 只搜索容器类型的节点
+        if node_type == 'container':
+            reagent_name = node_data.get('reagent_name', '').lower()
+            config_reagent = config_data.get('reagent', '').lower()
+            
+            # 精确匹配
+            if reagent_name == solvent.lower() or config_reagent == solvent.lower():
+                debug_print(f"✅ 通过试剂字段精确匹配找到容器: {node}")
+                return node
+            
+            # 模糊匹配
+            if (solvent.lower() in reagent_name and reagent_name) or \
+               (solvent.lower() in config_reagent and config_reagent):
+                debug_print(f"✅ 通过试剂字段模糊匹配找到容器: {node}")
+                return node
+    
+    # 🔧 方法2：常见的容器命名规则
+    debug_print(f"📋 方法2: 使用命名规则...")
+    solvent_clean = solvent.lower().replace(' ', '_').replace('-', '_')
+    possible_names = [
+        f"flask_{solvent_clean}",
+        f"bottle_{solvent_clean}",
+        f"vessel_{solvent_clean}",
+        f"{solvent_clean}_flask",
+        f"{solvent_clean}_bottle",
+        f"solvent_{solvent_clean}",
+        f"reagent_{solvent_clean}",
+        f"reagent_bottle_{solvent_clean}",
+        f"reagent_bottle_1",  # 通用试剂瓶
+        f"reagent_bottle_2",
+        f"reagent_bottle_3"
+    ]
+    
+    debug_print(f"🎯 尝试的容器名称: {possible_names[:5]}... (共 {len(possible_names)} 个)")
+    
+    for name in possible_names:
+        if name in G.nodes():
+            node_type = G.nodes[name].get('type', '')
+            if node_type == 'container':
+                debug_print(f"✅ 通过命名规则找到容器: {name}")
+                return name
+    
+    # 🔧 方法3：使用第一个试剂瓶作为备选
+    debug_print(f"📋 方法3: 查找备用试剂瓶...")
+    for node_id in G.nodes():
+        node_data = G.nodes[node_id]
+        if (node_data.get('type') == 'container' and 
+            ('reagent' in node_id.lower() or 'bottle' in node_id.lower())):
+            debug_print(f"⚠️ 未找到专用容器，使用备用容器: {node_id}")
+            return node_id
+    
+    debug_print(f"❌ 无法找到溶剂 '{solvent}' 的容器")
+    return ""

 def find_separator_device(G: nx.DiGraph, vessel: str) -> str:
    """查找分离器设备，支持多种查找方式"""
+    debug_print(f"🔍 正在查找容器 '{vessel}' 的分离器设备...")
+    
    # 方法1：查找连接到容器的分离器设备
+    debug_print(f"📋 方法1: 检查连接的分离器...")
    separator_nodes = []
    for node in G.nodes():
        node_class = G.nodes[node].get('class', '').lower()
        if 'separator' in node_class:
            separator_nodes.append(node)
+            debug_print(f"📋 发现分离器设备: {node}")
+            
            # 检查是否连接到目标容器
            if G.has_edge(node, vessel) or G.has_edge(vessel, node):
+                debug_print(f"✅ 找到连接的分离器: {node}")
                return node
-
+    
+    debug_print(f"📊 找到的分离器总数: {len(separator_nodes)}")
+    
    # 方法2：根据命名规则查找
+    debug_print(f"📋 方法2: 使用命名规则...")
    possible_names = [
        f"{vessel}_controller",
        f"{vessel}_separator",
        vessel,  # 容器本身可能就是分离器
        "separator_1",
        "virtual_separator",
-        "liquid_handler_1",
+        "liquid_handler_1",  # 液体处理器也可能用于分离
        "controller_1"
    ]
-
+    
+    debug_print(f"🎯 尝试的分离器名称: {possible_names}")
+    
    for name in possible_names:
        if name in G.nodes():
            node_class = G.nodes[name].get('class', '').lower()
            if 'separator' in node_class or 'controller' in node_class:
+                debug_print(f"✅ 通过命名规则找到分离器: {name}")
                return name
-
-    # 方法3：使用第一个可用分离器
+    
+    # 方法3：查找第一个分离器设备
+    debug_print(f"📋 方法3: 使用第一个可用分离器...")
    if separator_nodes:
        debug_print(f"⚠️ 使用第一个分离器设备: {separator_nodes[0]}")
        return separator_nodes[0]
-
+    
    debug_print(f"❌ 未找到分离器设备")
    return ""

+def find_connected_stirrer(G: nx.DiGraph, vessel: str) -> str:
+    """查找连接到指定容器的搅拌器"""
+    debug_print(f"🔍 正在查找与容器 {vessel} 连接的搅拌器...")
+    
+    stirrer_nodes = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'stirrer' in node_class.lower():
+            stirrer_nodes.append(node)
+            debug_print(f"📋 发现搅拌器: {node}")
+    
+    debug_print(f"📊 找到的搅拌器总数: {len(stirrer_nodes)}")
+    
+    # 检查哪个搅拌器与目标容器相连
+    for stirrer in stirrer_nodes:
+        if G.has_edge(stirrer, vessel) or G.has_edge(vessel, stirrer):
+            debug_print(f"✅ 找到连接的搅拌器: {stirrer}")
+            return stirrer
+    
+    # 如果没有连接的搅拌器，返回第一个可用的
+    if stirrer_nodes:
+        debug_print(f"⚠️ 未找到直接连接的搅拌器，使用第一个可用的: {stirrer_nodes[0]}")
+        return stirrer_nodes[0]
+    
+    debug_print("❌ 未找到搅拌器")
+    return ""
+
+def get_vessel_liquid_volume(vessel: dict) -> float:
+    """
+    获取容器中的液体体积 - 支持vessel字典
+    
+    Args:
+        vessel: 容器字典
+        
+    Returns:
+        float: 液体体积（mL）
+    """
+    if not vessel or "data" not in vessel:
+        debug_print(f"⚠️ 容器数据为空，返回 0.0mL")
+        return 0.0
+    
+    vessel_data = vessel["data"]
+    vessel_id = vessel.get("id", "unknown")
+    
+    debug_print(f"🔍 读取容器 '{vessel_id}' 体积数据: {vessel_data}")
+    
+    # 检查liquid_volume字段
+    if "liquid_volume" in vessel_data:
+        liquid_volume = vessel_data["liquid_volume"]
+        
+        # 处理列表格式
+        if isinstance(liquid_volume, list):
+            if len(liquid_volume) > 0:
+                volume = liquid_volume[0]
+                if isinstance(volume, (int, float)):
+                    debug_print(f"✅ 容器 '{vessel_id}' 体积: {volume}mL (列表格式)")
+                    return float(volume)
+        
+        # 处理直接数值格式
+        elif isinstance(liquid_volume, (int, float)):
+            debug_print(f"✅ 容器 '{vessel_id}' 体积: {liquid_volume}mL (数值格式)")
+            return float(liquid_volume)
+    
+    # 检查其他可能的体积字段
+    volume_keys = ['current_volume', 'total_volume', 'volume']
+    for key in volume_keys:
+        if key in vessel_data:
+            try:
+                volume = float(vessel_data[key])
+                if volume > 0:
+                    debug_print(f"✅ 容器 '{vessel_id}' 体积: {volume}mL (字段: {key})")
+                    return volume
+            except (ValueError, TypeError):
+                continue
+    
+    debug_print(f"⚠️ 无法获取容器 '{vessel_id}' 的体积，返回默认值 50.0mL")
+    return 50.0
+
+def update_vessel_volume(vessel: dict, G: nx.DiGraph, new_volume: float, description: str = "") -> None:
+    """
+    更新容器体积（同时更新vessel字典和图节点）
+    
+    Args:
+        vessel: 容器字典
+        G: 网络图
+        new_volume: 新体积
+        description: 更新描述
+    """
+    vessel_id = vessel.get("id", "unknown")
+    
+    if description:
+        debug_print(f"🔧 更新容器体积 - {description}")
+    
+    # 更新vessel字典中的体积
+    if "data" in vessel:
+        if "liquid_volume" in vessel["data"]:
+            current_volume = vessel["data"]["liquid_volume"]
+            if isinstance(current_volume, list):
+                if len(current_volume) > 0:
+                    vessel["data"]["liquid_volume"][0] = new_volume
+                else:
+                    vessel["data"]["liquid_volume"] = [new_volume]
+            else:
+                vessel["data"]["liquid_volume"] = new_volume
+        else:
+            vessel["data"]["liquid_volume"] = new_volume
+    else:
+        vessel["data"] = {"liquid_volume": new_volume}
+    
+    # 同时更新图中的容器数据
+    if vessel_id in G.nodes():
+        if 'data' not in G.nodes[vessel_id]:
+            G.nodes[vessel_id]['data'] = {}
+        
+        vessel_node_data = G.nodes[vessel_id]['data']
+        current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+        
+        if isinstance(current_node_volume, list):
+            if len(current_node_volume) > 0:
+                G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume
+            else:
+                G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume]
+        else:
+            G.nodes[vessel_id]['data']['liquid_volume'] = new_volume
+    
+    debug_print(f"📊 容器 '{vessel_id}' 体积已更新为: {new_volume:.2f}mL")
+

 def find_separation_vessel_bottom(G: nx.DiGraph, vessel_id: str) -> str:
    """
    智能查找分离容器的底部容器（假设为flask或vessel类型）
-
+    
    Args:
        G: 网络图
        vessel_id: 分离容器ID
-
+        
    Returns:
        str: 底部容器ID
    """
+    debug_print(f"🔍 查找分离容器 {vessel_id} 的底部容器...")
+    
    # 方法1：根据命名规则推测
    possible_bottoms = [
        f"{vessel_id}_bottom",
@@ -467,25 +814,32 @@ def find_separation_vessel_bottom(G: nx.DiGraph, vessel_id: str) -> str:
        f"{vessel_id}_flask",
        f"{vessel_id}_vessel"
    ]
-
+    
+    debug_print(f"📋 尝试的底部容器名称: {possible_bottoms}")
+    
    for bottom_id in possible_bottoms:
        if bottom_id in G.nodes():
            node_type = G.nodes[bottom_id].get('type', '')
            if node_type == 'container':
+                debug_print(f"✅ 通过命名规则找到底部容器: {bottom_id}")
                return bottom_id
-
-    # 方法2：查找与分离器相连的容器
+    
+    # 方法2：查找与分离器相连的容器（假设底部容器会与分离器相连）
+    debug_print(f"📋 方法2: 查找连接的容器...")
    for node in G.nodes():
        node_data = G.nodes[node]
        node_class = node_data.get('class', '') or ''
-
+        
        if 'separator' in node_class.lower():
+            # 检查分离器的输入端
            if G.has_edge(node, vessel_id):
                for neighbor in G.neighbors(node):
                    if neighbor != vessel_id:
                        neighbor_type = G.nodes[neighbor].get('type', '')
                        if neighbor_type == 'container':
+                            debug_print(f"✅ 通过连接找到底部容器: {neighbor}")
                            return neighbor
-
+    
    debug_print(f"❌ 无法找到分离容器 {vessel_id} 的底部容器")
    return ""
+
--- a/unilabos/compile/stir_protocol.py
+++ b/unilabos/compile/stir_protocol.py
@@ -1,40 +1,116 @@
 from typing import List, Dict, Any, Union
 import networkx as nx
 import logging
+import re

 from .utils.unit_parser import parse_time_input
-from .utils.resource_helper import get_resource_id, get_resource_display_info
-from .utils.logger_util import debug_print
-from .utils.vessel_parser import find_connected_stirrer

 logger = logging.getLogger(__name__)

+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[STIR] {message}")
+
+
+def find_connected_stirrer(G: nx.DiGraph, vessel: str = None) -> str:
+    """查找与指定容器相连的搅拌设备"""
+    debug_print(f"🔍 查找搅拌设备，目标容器: {vessel} 🥽")
+    
+    # 🔧 查找所有搅拌设备
+    stirrer_nodes = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'stirrer' in node_class.lower() or 'virtual_stirrer' in node_class:
+            stirrer_nodes.append(node)
+            debug_print(f"🎉 找到搅拌设备: {node} 🌪️")
+    
+    # 🔗 检查连接
+    if vessel and stirrer_nodes:
+        for stirrer in stirrer_nodes:
+            if G.has_edge(stirrer, vessel) or G.has_edge(vessel, stirrer):
+                debug_print(f"✅ 搅拌设备 '{stirrer}' 与容器 '{vessel}' 相连 🔗")
+                return stirrer
+    
+    # 🎯 使用第一个可用设备
+    if stirrer_nodes:
+        selected = stirrer_nodes[0]
+        debug_print(f"🔧 使用第一个搅拌设备: {selected} 🌪️")
+        return selected
+    
+    # 🆘 默认设备
+    debug_print("⚠️ 未找到搅拌设备，使用默认设备 🌪️")
+    return "stirrer_1"
+
 def validate_and_fix_params(stir_time: float, stir_speed: float, settling_time: float) -> tuple:
    """验证和修正参数"""
+    # ⏰ 搅拌时间验证
    if stir_time < 0:
-        debug_print(f"搅拌时间 {stir_time}s 无效，修正为 100s")
+        debug_print(f"⚠️ 搅拌时间 {stir_time}s 无效，修正为 100s 🕐")
        stir_time = 100.0
    elif stir_time > 100:  # 限制为100s
-        debug_print(f"搅拌时间 {stir_time}s 过长，仿真运行时修正为 100s")
+        debug_print(f"⚠️ 搅拌时间 {stir_time}s 过长，仿真运行时，修正为 100s 🕐")
        stir_time = 100.0
-
+    else:
+        debug_print(f"✅ 搅拌时间 {stir_time}s ({stir_time/60:.1f}分钟) 有效 ⏰")
+    
+    # 🌪️ 搅拌速度验证
    if stir_speed < 10.0 or stir_speed > 1500.0:
-        debug_print(f"搅拌速度 {stir_speed} RPM 超出范围，修正为 300 RPM")
+        debug_print(f"⚠️ 搅拌速度 {stir_speed} RPM 超出范围，修正为 300 RPM 🌪️")
        stir_speed = 300.0
-
+    else:
+        debug_print(f"✅ 搅拌速度 {stir_speed} RPM 在正常范围内 🌪️")
+    
+    # ⏱️ 沉降时间验证
    if settling_time < 0 or settling_time > 600:  # 限制为10分钟
-        debug_print(f"沉降时间 {settling_time}s 超出范围，修正为 60s")
+        debug_print(f"⚠️ 沉降时间 {settling_time}s 超出范围，修正为 60s ⏱️")
        settling_time = 60.0
-
+    else:
+        debug_print(f"✅ 沉降时间 {settling_time}s 在正常范围内 ⏱️")
+    
    return stir_time, stir_speed, settling_time

-def extract_vessel_id(vessel) -> str:
-    """从vessel参数中提取vessel_id，兼容 str / dict / ResourceDictInstance"""
-    return get_resource_id(vessel)
+def extract_vessel_id(vessel: Union[str, dict]) -> str:
+    """
+    从vessel参数中提取vessel_id
+    
+    Args:
+        vessel: vessel字典或vessel_id字符串
+        
+    Returns:
+        str: vessel_id
+    """
+    if isinstance(vessel, dict):
+        vessel_id = list(vessel.values())[0].get("id", "")
+        debug_print(f"🔧 从vessel字典提取ID: {vessel_id}")
+        return vessel_id
+    elif isinstance(vessel, str):
+        debug_print(f"🔧 vessel参数为字符串: {vessel}")
+        return vessel
+    else:
+        debug_print(f"⚠️ 无效的vessel参数类型: {type(vessel)}")
+        return ""

-def get_vessel_display_info(vessel) -> str:
-    """获取容器的显示信息（用于日志），兼容 str / dict / ResourceDictInstance"""
-    return get_resource_display_info(vessel)
+def get_vessel_display_info(vessel: Union[str, dict]) -> str:
+    """
+    获取容器的显示信息（用于日志）
+    
+    Args:
+        vessel: vessel字典或vessel_id字符串
+        
+    Returns:
+        str: 显示信息
+    """
+    if isinstance(vessel, dict):
+        vessel_id = vessel.get("id", "unknown")
+        vessel_name = vessel.get("name", "")
+        if vessel_name:
+            return f"{vessel_id} ({vessel_name})"
+        else:
+            return vessel_id
+    else:
+        return str(vessel)

 def generate_stir_protocol(
    G: nx.DiGraph,
@@ -49,13 +125,16 @@ def generate_stir_protocol(
 ) -> List[Dict[str, Any]]:
    """生成搅拌操作的协议序列 - 修复vessel参数传递"""
    
+    # 🔧 核心修改：正确处理vessel参数
    vessel_id = extract_vessel_id(vessel)
    vessel_display = get_vessel_display_info(vessel)
-
-    # 确保vessel_resource是完整的Resource对象
+    
+    # 🔧 关键修复：确保vessel_resource是完整的Resource对象
    if isinstance(vessel, dict):
-        vessel_resource = vessel
+        vessel_resource = vessel  # 已经是完整的Resource字典
+        debug_print(f"✅ 使用传入的vessel Resource对象")
    else:
+        # 如果只是字符串，构建一个基本的Resource对象
        vessel_resource = {
            "id": vessel,
            "name": "",
@@ -71,60 +150,91 @@ def generate_stir_protocol(
            "sample_id": "",
            "type": ""
        }
-
-    # 参数验证
-    if not vessel_id:
+        debug_print(f"🔧 构建了基本的vessel Resource对象: {vessel}")
+    
+    debug_print("🌪️" * 20)
+    debug_print("🚀 开始生成搅拌协议（支持vessel字典）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel_display} (ID: {vessel_id})")
+    debug_print(f"  ⏰ time: {time}")
+    debug_print(f"  🕐 stir_time: {stir_time}")
+    debug_print(f"  🎯 time_spec: {time_spec}")
+    debug_print(f"  🌪️ stir_speed: {stir_speed} RPM")
+    debug_print(f"  ⏱️ settling_time: {settling_time}")
+    debug_print("🌪️" * 20)
+    
+    # 📋 参数验证
+    debug_print("📍 步骤1: 参数验证... 🔧")
+    if not vessel_id:  # 🔧 使用 vessel_id
+        debug_print("❌ vessel 参数不能为空! 😱")
        raise ValueError("vessel 参数不能为空")
-
-    if vessel_id not in G.nodes():
+    
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print(f"❌ 容器 '{vessel_id}' 不存在于系统中! 😞")
        raise ValueError(f"容器 '{vessel_id}' 不存在于系统中")
    
-    # 参数解析 — 确定实际时间（优先级：time_spec > stir_time > time）
+    debug_print("✅ 基础参数验证通过 🎯")
+    
+    # 🔄 参数解析
+    debug_print("📍 步骤2: 参数解析... ⚡")
+    
+    # 确定实际时间（优先级：time_spec > stir_time > time）
    if time_spec:
        parsed_time = parse_time_input(time_spec)
+        debug_print(f"🎯 使用time_spec: '{time_spec}' → {parsed_time}s")
    elif stir_time not in ["0", 0, 0.0]:
        parsed_time = parse_time_input(stir_time)
+        debug_print(f"🎯 使用stir_time: {stir_time} → {parsed_time}s")
    else:
        parsed_time = parse_time_input(time)
+        debug_print(f"🎯 使用time: {time} → {parsed_time}s")
    
    # 解析沉降时间
    parsed_settling_time = parse_time_input(settling_time)
    
-    # 模拟运行时间优化
+    # 🕐 模拟运行时间优化
+    debug_print("  ⏱️ 检查模拟运行时间限制...")
    original_stir_time = parsed_time
    original_settling_time = parsed_settling_time
-
+    
    # 搅拌时间限制为60秒
    stir_time_limit = 60.0
    if parsed_time > stir_time_limit:
        parsed_time = stir_time_limit
-
+        debug_print(f"  🎮 搅拌时间优化: {original_stir_time}s → {parsed_time}s ⚡")
+    
    # 沉降时间限制为30秒
    settling_time_limit = 30.0
    if parsed_settling_time > settling_time_limit:
        parsed_settling_time = settling_time_limit
+        debug_print(f"  🎮 沉降时间优化: {original_settling_time}s → {parsed_settling_time}s ⚡")
    
    # 参数修正
    parsed_time, stir_speed, parsed_settling_time = validate_and_fix_params(
        parsed_time, stir_speed, parsed_settling_time
    )
    
-    debug_print(f"最终参数: time={parsed_time}s, speed={stir_speed}RPM, settling={parsed_settling_time}s")
-
-    # 查找设备
+    debug_print(f"🎯 最终参数: time={parsed_time}s, speed={stir_speed}RPM, settling={parsed_settling_time}s")
+    
+    # 🔍 查找设备
+    debug_print("📍 步骤3: 查找搅拌设备... 🔍")
    try:
-        stirrer_id = find_connected_stirrer(G, vessel_id)
+        stirrer_id = find_connected_stirrer(G, vessel_id)  # 🔧 使用 vessel_id
+        debug_print(f"🎉 使用搅拌设备: {stirrer_id} ✨")
    except Exception as e:
+        debug_print(f"❌ 设备查找失败: {str(e)} 😭")
        raise ValueError(f"无法找到搅拌设备: {str(e)}")
-
-    # 生成动作
+    
+    # 🚀 生成动作
+    debug_print("📍 步骤4: 生成搅拌动作... 🌪️")
    
    action_sequence = []
    stir_action = {
        "device_id": stirrer_id,
        "action_name": "stir",
        "action_kwargs": {
-            "vessel": {"id": vessel_id},
+            # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
+            "vessel": {"id": vessel_id},  # 传递字符串ID，不是Resource对象
            "time": str(time),
            "event": event,
            "time_spec": time_spec,
@@ -134,14 +244,22 @@ def generate_stir_protocol(
        }
    }
    action_sequence.append(stir_action)
-
-    # 时间优化信息
+    debug_print("✅ 搅拌动作已添加 🌪️✨")
+    
+    # 显示时间优化信息
    if original_stir_time != parsed_time or original_settling_time != parsed_settling_time:
-        debug_print(f"模拟优化: 搅拌 {original_stir_time/60:.1f}min→{parsed_time/60:.1f}min, "
-                    f"沉降 {original_settling_time/60:.1f}min→{parsed_settling_time/60:.1f}min")
-
-    debug_print(f"搅拌协议生成完成: {vessel_display}, {stir_speed}RPM, "
-                f"{parsed_time}s, 沉降{parsed_settling_time}s, 总{(parsed_time + parsed_settling_time)/60:.1f}min")
+        debug_print(f"  🎭 模拟优化说明:")
+        debug_print(f"    搅拌时间: {original_stir_time/60:.1f}分钟 → {parsed_time/60:.1f}分钟")
+        debug_print(f"    沉降时间: {original_settling_time/60:.1f}分钟 → {parsed_settling_time/60:.1f}分钟")
+    
+    # 🎊 总结
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 搅拌协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 搅拌容器: {vessel_display}")
+    debug_print(f"🌪️ 搅拌参数: {stir_speed} RPM, {parsed_time}s, 沉降 {parsed_settling_time}s")
+    debug_print(f"⏱️ 预计总时间: {(parsed_time + parsed_settling_time)/60:.1f} 分钟 ⌛")
+    debug_print("🎊" * 20)
    
    return action_sequence

@@ -154,13 +272,16 @@ def generate_start_stir_protocol(
 ) -> List[Dict[str, Any]]:
    """生成开始搅拌操作的协议序列 - 修复vessel参数传递"""
    
+    # 🔧 核心修改：正确处理vessel参数
    vessel_id = extract_vessel_id(vessel)
    vessel_display = get_vessel_display_info(vessel)
-
-    # 确保vessel_resource是完整的Resource对象
+    
+    # 🔧 关键修复：确保vessel_resource是完整的Resource对象
    if isinstance(vessel, dict):
-        vessel_resource = vessel
+        vessel_resource = vessel  # 已经是完整的Resource字典
+        debug_print(f"✅ 使用传入的vessel Resource对象")
    else:
+        # 如果只是字符串，构建一个基本的Resource对象
        vessel_resource = {
            "id": vessel,
            "name": "",
@@ -176,29 +297,39 @@ def generate_start_stir_protocol(
            "sample_id": "",
            "type": ""
        }
-
+        debug_print(f"🔧 构建了基本的vessel Resource对象: {vessel}")
+    
+    debug_print("🔄 开始生成启动搅拌协议（修复vessel参数）✨")
+    debug_print(f"🥽 vessel: {vessel_display} (ID: {vessel_id})")
+    debug_print(f"🌪️ speed: {stir_speed} RPM")
+    debug_print(f"🎯 purpose: {purpose}")
+    
    # 基础验证
    if not vessel_id or vessel_id not in G.nodes():
+        debug_print("❌ 容器验证失败!")
        raise ValueError("vessel 参数无效")
-
+    
    # 参数修正
    if stir_speed < 10.0 or stir_speed > 1500.0:
+        debug_print(f"⚠️ 搅拌速度修正: {stir_speed} → 300 RPM 🌪️")
        stir_speed = 300.0
-
+    
    # 查找设备
    stirrer_id = find_connected_stirrer(G, vessel_id)
-
+    
+    # 🔧 关键修复：传递vessel_id字符串
    action_sequence = [{
        "device_id": stirrer_id,
        "action_name": "start_stir",
        "action_kwargs": {
-            "vessel": {"id": vessel_id},
+            # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
+            "vessel": {"id": vessel_id},  # 传递字符串ID，不是Resource对象
            "stir_speed": stir_speed,
            "purpose": purpose or f"启动搅拌 {stir_speed} RPM"
        }
    }]
-
-    debug_print(f"启动搅拌协议: {vessel_display}, {stir_speed}RPM, device={stirrer_id}")
+    
+    debug_print(f"✅ 启动搅拌协议生成完成 🎯")
    return action_sequence

 def generate_stop_stir_protocol(
@@ -208,13 +339,16 @@ def generate_stop_stir_protocol(
 ) -> List[Dict[str, Any]]:
    """生成停止搅拌操作的协议序列 - 修复vessel参数传递"""
    
+    # 🔧 核心修改：正确处理vessel参数
    vessel_id = extract_vessel_id(vessel)
    vessel_display = get_vessel_display_info(vessel)
-
-    # 确保vessel_resource是完整的Resource对象
+    
+    # 🔧 关键修复：确保vessel_resource是完整的Resource对象
    if isinstance(vessel, dict):
-        vessel_resource = vessel
+        vessel_resource = vessel  # 已经是完整的Resource字典
+        debug_print(f"✅ 使用传入的vessel Resource对象")
    else:
+        # 如果只是字符串，构建一个基本的Resource对象
        vessel_resource = {
            "id": vessel,
            "name": "",
@@ -230,103 +364,115 @@ def generate_stop_stir_protocol(
            "sample_id": "",
            "type": ""
        }
-
+        debug_print(f"🔧 构建了基本的vessel Resource对象: {vessel}")
+    
+    debug_print("🛑 开始生成停止搅拌协议（修复vessel参数）✨")
+    debug_print(f"🥽 vessel: {vessel_display} (ID: {vessel_id})")
+    
    # 基础验证
    if not vessel_id or vessel_id not in G.nodes():
+        debug_print("❌ 容器验证失败!")
        raise ValueError("vessel 参数无效")
-
+    
    # 查找设备
    stirrer_id = find_connected_stirrer(G, vessel_id)
-
+    
+    # 🔧 关键修复：传递vessel_id字符串
    action_sequence = [{
        "device_id": stirrer_id,
        "action_name": "stop_stir",
        "action_kwargs": {
-            "vessel": {"id": vessel_id},
+            # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
+            "vessel": {"id": vessel_id},  # 传递字符串ID，不是Resource对象
        }
    }]
-
-    debug_print(f"停止搅拌协议: {vessel_display}, device={stirrer_id}")
+    
+    debug_print(f"✅ 停止搅拌协议生成完成 🎯")
    return action_sequence

-# 便捷函数
+# 🔧 新增：便捷函数
 def stir_briefly(G: nx.DiGraph, vessel: Union[str, dict], 
                speed: float = 300.0) -> List[Dict[str, Any]]:
    """短时间搅拌（30秒）"""
    vessel_display = get_vessel_display_info(vessel)
-    debug_print(f"短时间搅拌: {vessel_display} @ {speed}RPM (30s)")
+    debug_print(f"⚡ 短时间搅拌: {vessel_display} @ {speed}RPM (30s)")
    return generate_stir_protocol(G, vessel, time="30", stir_speed=speed)

 def stir_slowly(G: nx.DiGraph, vessel: Union[str, dict], 
               time: Union[str, float] = "10 min") -> List[Dict[str, Any]]:
    """慢速搅拌"""
    vessel_display = get_vessel_display_info(vessel)
-    debug_print(f"慢速搅拌: {vessel_display} @ 150RPM")
+    debug_print(f"🐌 慢速搅拌: {vessel_display} @ 150RPM")
    return generate_stir_protocol(G, vessel, time=time, stir_speed=150.0)

 def stir_vigorously(G: nx.DiGraph, vessel: Union[str, dict], 
                   time: Union[str, float] = "5 min") -> List[Dict[str, Any]]:
    """剧烈搅拌"""
    vessel_display = get_vessel_display_info(vessel)
-    debug_print(f"剧烈搅拌: {vessel_display} @ 800RPM")
+    debug_print(f"💨 剧烈搅拌: {vessel_display} @ 800RPM")
    return generate_stir_protocol(G, vessel, time=time, stir_speed=800.0)

 def stir_for_reaction(G: nx.DiGraph, vessel: Union[str, dict], 
                     time: Union[str, float] = "1 h") -> List[Dict[str, Any]]:
    """反应搅拌（标准速度，长时间）"""
    vessel_display = get_vessel_display_info(vessel)
-    debug_print(f"反应搅拌: {vessel_display} @ 400RPM")
+    debug_print(f"🧪 反应搅拌: {vessel_display} @ 400RPM")
    return generate_stir_protocol(G, vessel, time=time, stir_speed=400.0)

 def stir_for_dissolution(G: nx.DiGraph, vessel: Union[str, dict], 
                        time: Union[str, float] = "15 min") -> List[Dict[str, Any]]:
    """溶解搅拌（中等速度）"""
    vessel_display = get_vessel_display_info(vessel)
-    debug_print(f"溶解搅拌: {vessel_display} @ 500RPM")
+    debug_print(f"💧 溶解搅拌: {vessel_display} @ 500RPM")
    return generate_stir_protocol(G, vessel, time=time, stir_speed=500.0)

 def stir_gently(G: nx.DiGraph, vessel: Union[str, dict], 
               time: Union[str, float] = "30 min") -> List[Dict[str, Any]]:
    """温和搅拌"""
    vessel_display = get_vessel_display_info(vessel)
-    debug_print(f"温和搅拌: {vessel_display} @ 200RPM")
+    debug_print(f"🍃 温和搅拌: {vessel_display} @ 200RPM")
    return generate_stir_protocol(G, vessel, time=time, stir_speed=200.0)

 def stir_overnight(G: nx.DiGraph, vessel: Union[str, dict]) -> List[Dict[str, Any]]:
    """过夜搅拌（模拟时缩短为2小时）"""
    vessel_display = get_vessel_display_info(vessel)
-    debug_print(f"过夜搅拌（模拟2小时）: {vessel_display} @ 300RPM")
+    debug_print(f"🌙 过夜搅拌（模拟2小时）: {vessel_display} @ 300RPM")
    return generate_stir_protocol(G, vessel, time="2 h", stir_speed=300.0)

 def start_continuous_stirring(G: nx.DiGraph, vessel: Union[str, dict], 
                             speed: float = 300.0, purpose: str = "continuous stirring") -> List[Dict[str, Any]]:
    """开始连续搅拌"""
    vessel_display = get_vessel_display_info(vessel)
-    debug_print(f"开始连续搅拌: {vessel_display} @ {speed}RPM")
+    debug_print(f"🔄 开始连续搅拌: {vessel_display} @ {speed}RPM")
    return generate_start_stir_protocol(G, vessel, stir_speed=speed, purpose=purpose)

 def stop_all_stirring(G: nx.DiGraph, vessel: Union[str, dict]) -> List[Dict[str, Any]]:
    """停止所有搅拌"""
    vessel_display = get_vessel_display_info(vessel)
-    debug_print(f"停止搅拌: {vessel_display}")
+    debug_print(f"🛑 停止搅拌: {vessel_display}")
    return generate_stop_stir_protocol(G, vessel)

 # 测试函数
 def test_stir_protocol():
    """测试搅拌协议"""
+    debug_print("🧪 === STIR PROTOCOL 测试 === ✨")
+    
+    # 测试vessel参数处理
+    debug_print("🔧 测试vessel参数处理...")
+    
    # 测试字典格式
    vessel_dict = {"id": "flask_1", "name": "反应瓶1"}
    vessel_id = extract_vessel_id(vessel_dict)
    vessel_display = get_vessel_display_info(vessel_dict)
-    debug_print(f"字典格式: {vessel_dict} -> ID: {vessel_id}, 显示: {vessel_display}")
-
+    debug_print(f"  字典格式: {vessel_dict} → ID: {vessel_id}, 显示: {vessel_display}")
+    
    # 测试字符串格式
    vessel_str = "flask_2"
    vessel_id = extract_vessel_id(vessel_str)
    vessel_display = get_vessel_display_info(vessel_str)
-    debug_print(f"字符串格式: {vessel_str} -> ID: {vessel_id}, 显示: {vessel_display}")
-
-    debug_print("测试完成")
+    debug_print(f"  字符串格式: {vessel_str} → ID: {vessel_id}, 显示: {vessel_display}")
+    
+    debug_print("✅ 测试完成 🎉")

 if __name__ == "__main__":
    test_stir_protocol()
--- a/unilabos/compile/utils/logger_util.py
+++ b/unilabos/compile/utils/logger_util.py
@@ -1,57 +1,36 @@
-"""编译器共享日志工具"""
-
-import inspect
+# 🆕 创建进度日志动作
 import logging
 from typing import Dict, Any

-# 模块名到前缀的映射
-_MODULE_PREFIXES = {
-    "add_protocol": "[ADD]",
-    "adjustph_protocol": "[ADJUSTPH]",
-    "clean_vessel_protocol": "[CLEAN_VESSEL]",
-    "dissolve_protocol": "[DISSOLVE]",
-    "dry_protocol": "[DRY]",
-    "evacuateandrefill_protocol": "[EVACUATE]",
-    "evaporate_protocol": "[EVAPORATE]",
-    "filter_protocol": "[FILTER]",
-    "heatchill_protocol": "[HEATCHILL]",
-    "hydrogenate_protocol": "[HYDROGENATE]",
-    "pump_protocol": "[PUMP]",
-    "recrystallize_protocol": "[RECRYSTALLIZE]",
-    "reset_handling_protocol": "[RESET]",
-    "run_column_protocol": "[RUN_COLUMN]",
-    "separate_protocol": "[SEPARATE]",
-    "stir_protocol": "[STIR]",
-    "wash_solid_protocol": "[WASH_SOLID]",
-    "vessel_parser": "[VESSEL_PARSER]",
-    "unit_parser": "[UNIT_PARSER]",
-    "resource_helper": "[RESOURCE_HELPER]",
-}
+logger = logging.getLogger(__name__)

-
-def debug_print(message, prefix=None):
-    """调试输出 — 自动根据调用模块设置前缀"""
-    if prefix is None:
-        frame = inspect.currentframe()
-        caller = frame.f_back if frame else None
-        module_name = ""
-        if caller:
-            module_name = caller.f_globals.get("__name__", "")
-            # 取最后一段作为模块短名
-            module_name = module_name.rsplit(".", 1)[-1]
-        prefix = _MODULE_PREFIXES.get(module_name, f"[{module_name.upper()}]")
-    logger = logging.getLogger("unilabos.compile")
+def debug_print(message, prefix="[UNIT_PARSER]"):
+    """调试输出"""
    logger.info(f"{prefix} {message}")


 def action_log(message: str, emoji: str = "📝", prefix="[HIGH-LEVEL OPERATION]") -> Dict[str, Any]:
-    """创建一个动作日志"""
-    full_message = f"{prefix} {emoji} {message}"
-    return {
-        "action_name": "wait",
-        "action_kwargs": {
-            "time": 0.1,
-            "log_message": full_message,
-            "progress_message": full_message
+    """创建一个动作日志 - 支持中文和emoji"""
+    try:
+        full_message = f"{prefix} {emoji} {message}"
+
+        return {
+            "action_name": "wait",
+            "action_kwargs": {
+                "time": 0.1,
+                "log_message": full_message,
+                "progress_message": full_message
+            }
        }
-    }
+    except Exception as e:
+        # 如果emoji有问题，使用纯文本
+        safe_message = f"{prefix} {message}"
+
+        return {
+            "action_name": "wait",
+            "action_kwargs": {
+                "time": 0.1,
+                "log_message": safe_message,
+                "progress_message": safe_message
+            }
+        }
--- a/unilabos/compile/utils/resource_helper.py
+++ b/unilabos/compile/utils/resource_helper.py
@@ -1,172 +0,0 @@
-"""
-资源实例兼容层
-
-提供 ensure_resource_instance() 将 dict / ResourceDictInstance 统一转为
-ResourceDictInstance，使编译器可以渐进式迁移到强类型资源。
-"""
-
-from typing import Any, Dict, Optional, Union
-
-from unilabos.resources.resource_tracker import ResourceDictInstance
-
-
-def ensure_resource_instance(
-    resource: Union[Dict[str, Any], ResourceDictInstance, None],
-) -> Optional[ResourceDictInstance]:
-    """将 dict 或 ResourceDictInstance 统一转为 ResourceDictInstance
-
-    编译器入口统一调用此函数，即可同时兼容旧 dict 传参和新 ResourceDictInstance 传参。
-
-    Args:
-        resource: 资源数据，可以是 plain dict、ResourceDictInstance 或 None
-
-    Returns:
-        ResourceDictInstance 或 None（当输入为 None 时）
-    """
-    if resource is None:
-        return None
-    if isinstance(resource, ResourceDictInstance):
-        return resource
-    if isinstance(resource, dict):
-        return ResourceDictInstance.get_resource_instance_from_dict(resource)
-    raise TypeError(f"不支持的资源类型: {type(resource)}, 期望 dict 或 ResourceDictInstance")
-
-
-def resource_to_dict(resource: Union[Dict[str, Any], ResourceDictInstance]) -> Dict[str, Any]:
-    """将 ResourceDictInstance 或 dict 统一转为 plain dict
-
-    用于需要 dict 操作的场景（如 children dict 操作）。
-
-    Args:
-        resource: ResourceDictInstance 或 dict
-
-    Returns:
-        plain dict
-    """
-    if isinstance(resource, dict):
-        return resource
-    if isinstance(resource, ResourceDictInstance):
-        return resource.get_plr_nested_dict()
-    raise TypeError(f"不支持的资源类型: {type(resource)}")
-
-
-def get_resource_id(resource: Union[str, Dict[str, Any], ResourceDictInstance]) -> str:
-    """从资源对象中提取 ID
-
-    Args:
-        resource: 字符串 ID、dict 或 ResourceDictInstance
-
-    Returns:
-        资源 ID 字符串
-    """
-    if isinstance(resource, str):
-        return resource
-    if isinstance(resource, ResourceDictInstance):
-        return resource.res_content.id
-    if isinstance(resource, dict):
-        if "id" in resource:
-            return resource["id"]
-        # 兼容 {station_id: {...}} 格式
-        first_val = next(iter(resource.values()), {})
-        if isinstance(first_val, dict):
-            return first_val.get("id", "")
-        return ""
-    raise TypeError(f"不支持的资源类型: {type(resource)}")
-
-
-def get_resource_data(resource: Union[str, Dict[str, Any], ResourceDictInstance]) -> Dict[str, Any]:
-    """从资源对象中提取 data 字段
-
-    Args:
-        resource: 字符串、dict 或 ResourceDictInstance
-
-    Returns:
-        data 字典
-    """
-    if isinstance(resource, str):
-        return {}
-    if isinstance(resource, ResourceDictInstance):
-        return dict(resource.res_content.data)
-    if isinstance(resource, dict):
-        return resource.get("data", {})
-    return {}
-
-
-def get_resource_display_info(resource: Union[str, Dict[str, Any], ResourceDictInstance]) -> str:
-    """获取资源的显示信息（用于日志）
-
-    Args:
-        resource: 字符串 ID、dict 或 ResourceDictInstance
-
-    Returns:
-        显示信息字符串
-    """
-    if isinstance(resource, str):
-        return resource
-    if isinstance(resource, ResourceDictInstance):
-        res = resource.res_content
-        return f"{res.id} ({res.name})" if res.name and res.name != res.id else res.id
-    if isinstance(resource, dict):
-        res_id = resource.get("id", "unknown")
-        res_name = resource.get("name", "")
-        if res_name and res_name != res_id:
-            return f"{res_id} ({res_name})"
-        return res_id
-    return str(resource)
-
-
-def get_resource_liquid_volume(resource: Union[Dict[str, Any], ResourceDictInstance]) -> float:
-    """从资源中获取液体体积
-
-    Args:
-        resource: dict 或 ResourceDictInstance
-
-    Returns:
-        液体总体积 (mL)
-    """
-    data = get_resource_data(resource)
-    liquids = data.get("liquid", [])
-    if isinstance(liquids, list):
-        return sum(l.get("volume", 0.0) for l in liquids if isinstance(l, dict))
-    return 0.0
-
-
-def update_vessel_volume(vessel, G, new_volume: float, description: str = "") -> None:
-    """
-    更新容器体积（同时更新vessel字典和图节点）
-
-    Args:
-        vessel: 容器字典或 ResourceDictInstance
-        G: 网络图 (nx.DiGraph)
-        new_volume: 新体积 (mL)
-        description: 更新描述（用于日志）
-    """
-    import logging
-    logger = logging.getLogger("unilabos.compile")
-
-    vessel_id = get_resource_id(vessel)
-
-    if description:
-        logger.info(f"[RESOURCE] 更新容器体积 - {description}")
-
-    # 更新 vessel 字典中的体积
-    if isinstance(vessel, dict):
-        if "data" not in vessel:
-            vessel["data"] = {}
-        lv = vessel["data"].get("liquid_volume")
-        if isinstance(lv, list) and len(lv) > 0:
-            vessel["data"]["liquid_volume"][0] = new_volume
-        else:
-            vessel["data"]["liquid_volume"] = new_volume
-
-    # 同时更新图中的容器数据
-    if vessel_id and vessel_id in G.nodes():
-        if "data" not in G.nodes[vessel_id]:
-            G.nodes[vessel_id]["data"] = {}
-        node_lv = G.nodes[vessel_id]["data"].get("liquid_volume")
-        if isinstance(node_lv, list) and len(node_lv) > 0:
-            G.nodes[vessel_id]["data"]["liquid_volume"][0] = new_volume
-        else:
-            G.nodes[vessel_id]["data"]["liquid_volume"] = new_volume
-
-    logger.info(f"[RESOURCE] 容器 '{vessel_id}' 体积已更新为: {new_volume:.2f}mL")
--- a/unilabos/compile/utils/unit_parser.py
+++ b/unilabos/compile/utils/unit_parser.py
@@ -184,42 +184,6 @@ def parse_time_input(time_input: Union[str, float]) -> float:

    return time_sec

-
-def parse_temperature_input(temp_input: Union[str, float], default_temp: float = 25.0) -> float:
-    """
-    解析温度输入，支持字符串和数值
-
-    Args:
-        temp_input: 温度输入（如 "256 °C", "reflux", 45.0）
-        default_temp: 默认温度
-
-    Returns:
-        float: 温度（°C）
-    """
-    if not temp_input:
-        return default_temp
-
-    if isinstance(temp_input, (int, float)):
-        return float(temp_input)
-
-    temp_str = str(temp_input).lower().strip()
-
-    # 特殊温度关键词
-    special_temps = {
-        "room temperature": 25.0, "reflux": 78.0, "ice bath": 0.0,
-        "boiling": 100.0, "hot": 60.0, "warm": 40.0, "cold": 10.0,
-    }
-    if temp_str in special_temps:
-        return special_temps[temp_str]
-
-    # 正则解析（如 "256 °C", "45°C", "45"）
-    match = re.search(r'(\d+(?:\.\d+)?)\s*°?[cf]?', temp_str)
-    if match:
-        return float(match.group(1))
-
-    debug_print(f"无法解析温度: '{temp_str}'，使用默认值: {default_temp}°C")
-    return default_temp
-
 # 测试函数
 def test_unit_parser():
    """测试单位解析功能"""
--- a/unilabos/compile/utils/vessel_parser.py
+++ b/unilabos/compile/utils/vessel_parser.py
@@ -1,23 +1,27 @@
 import networkx as nx

 from .logger_util import debug_print
-from .resource_helper import get_resource_id, get_resource_data


 def get_vessel(vessel):
    """
    统一处理vessel参数，返回vessel_id和vessel_data。
-    支持 dict、str、ResourceDictInstance。

    Args:
-        vessel: 可以是一个字典、字符串或 ResourceDictInstance，表示vessel的ID或数据。
+        vessel: 可以是一个字典或字符串，表示vessel的ID或数据。

    Returns:
        tuple: 包含vessel_id和vessel_data。
    """
-    # 统一使用 resource_helper 处理
-    vessel_id = get_resource_id(vessel)
-    vessel_data = get_resource_data(vessel)
+    if isinstance(vessel, dict):
+        if "id" not in vessel:
+            vessel_id = list(vessel.values())[0].get("id", "")
+        else:
+            vessel_id = vessel.get("id", "")
+        vessel_data = vessel.get("data", {})
+    else:
+        vessel_id = str(vessel)
+        vessel_data = {}
    return vessel_id, vessel_data


@@ -274,31 +278,4 @@ def find_solid_dispenser(G: nx.DiGraph) -> str:
            return node

    debug_print(f"❌ 未找到固体加样器")
-    return ""
-
-
-def find_connected_heatchill(G: nx.DiGraph, vessel: str) -> str:
-    """查找与指定容器相连的加热/冷却设备"""
-    heatchill_nodes = []
-    for node in G.nodes():
-        node_data = G.nodes[node]
-        node_class = node_data.get('class', '') or ''
-        node_name = node.lower()
-        if ('heatchill' in node_class.lower() or 'virtual_heatchill' in node_class
-                or 'heater' in node_name or 'heat' in node_name):
-            heatchill_nodes.append(node)
-
-    # 检查连接
-    if vessel and heatchill_nodes:
-        for hc in heatchill_nodes:
-            if G.has_edge(hc, vessel) or G.has_edge(vessel, hc):
-                debug_print(f"加热设备 '{hc}' 与容器 '{vessel}' 相连")
-                return hc
-
-    # 使用第一个可用设备
-    if heatchill_nodes:
-        debug_print(f"使用第一个加热设备: {heatchill_nodes[0]}")
-        return heatchill_nodes[0]
-
-    debug_print("未找到加热设备，使用默认设备")
-    return "heatchill_1"
+    return ""
--- a/unilabos/compile/wash_solid_protocol.py
+++ b/unilabos/compile/wash_solid_protocol.py
@@ -4,55 +4,199 @@ import logging
 import re

 from .utils.unit_parser import parse_time_input, parse_volume_input
-from .utils.resource_helper import get_resource_id, get_resource_display_info, get_resource_liquid_volume, update_vessel_volume
-from .utils.logger_util import debug_print

 logger = logging.getLogger(__name__)

+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[WASH_SOLID] {message}")
+

 def find_solvent_source(G: nx.DiGraph, solvent: str) -> str:
-    """查找溶剂源"""
+    """查找溶剂源（精简版）"""
+    debug_print(f"🔍 查找溶剂源: {solvent}")
+    
+    # 简化搜索列表
    search_patterns = [
        f"flask_{solvent}", f"bottle_{solvent}", f"reagent_{solvent}",
        "liquid_reagent_bottle_1", "flask_1", "solvent_bottle"
    ]
-
+    
    for pattern in search_patterns:
        if pattern in G.nodes():
-            debug_print(f"找到溶剂源: {pattern}")
+            debug_print(f"🎉 找到溶剂源: {pattern}")
            return pattern
-
-    debug_print(f"使用默认溶剂源: flask_{solvent}")
+    
+    debug_print(f"⚠️ 使用默认溶剂源: flask_{solvent}")
    return f"flask_{solvent}"

 def find_filtrate_vessel(G: nx.DiGraph, filtrate_vessel: str = "") -> str:
-    """查找滤液容器"""
+    """查找滤液容器（精简版）"""
+    debug_print(f"🔍 查找滤液容器: {filtrate_vessel}")
+    
+    # 如果指定了且存在，直接使用
    if filtrate_vessel and filtrate_vessel in G.nodes():
+        debug_print(f"✅ 使用指定容器: {filtrate_vessel}")
        return filtrate_vessel
-
+    
+    # 简化搜索列表
    default_vessels = ["waste_workup", "filtrate_vessel", "flask_1", "collection_bottle_1"]
-
+    
    for vessel in default_vessels:
        if vessel in G.nodes():
-            debug_print(f"找到滤液容器: {vessel}")
+            debug_print(f"🎉 找到滤液容器: {vessel}")
            return vessel
-
+    
+    debug_print(f"⚠️ 使用默认滤液容器: waste_workup")
    return "waste_workup"

-def extract_vessel_id(vessel) -> str:
-    """从vessel参数中提取vessel_id，兼容 str / dict / ResourceDictInstance"""
-    return get_resource_id(vessel)
+def extract_vessel_id(vessel: Union[str, dict]) -> str:
+    """
+    从vessel参数中提取vessel_id
+    
+    Args:
+        vessel: vessel字典或vessel_id字符串
+        
+    Returns:
+        str: vessel_id
+    """
+    if isinstance(vessel, dict):
+        vessel_id = list(vessel.values())[0].get("id", "")
+        debug_print(f"🔧 从vessel字典提取ID: {vessel_id}")
+        return vessel_id
+    elif isinstance(vessel, str):
+        debug_print(f"🔧 vessel参数为字符串: {vessel}")
+        return vessel
+    else:
+        debug_print(f"⚠️ 无效的vessel参数类型: {type(vessel)}")
+        return ""

-def get_vessel_display_info(vessel) -> str:
-    """获取容器的显示信息（用于日志），兼容 str / dict / ResourceDictInstance"""
-    return get_resource_display_info(vessel)
+def get_vessel_display_info(vessel: Union[str, dict]) -> str:
+    """
+    获取容器的显示信息（用于日志）
+    
+    Args:
+        vessel: vessel字典或vessel_id字符串
+        
+    Returns:
+        str: 显示信息
+    """
+    if isinstance(vessel, dict):
+        vessel_id = vessel.get("id", "unknown")
+        vessel_name = vessel.get("name", "")
+        if vessel_name:
+            return f"{vessel_id} ({vessel_name})"
+        else:
+            return vessel_id
+    else:
+        return str(vessel)
+
+def get_vessel_liquid_volume(vessel: dict) -> float:
+    """
+    获取容器中的液体体积 - 支持vessel字典
+    
+    Args:
+        vessel: 容器字典
+        
+    Returns:
+        float: 液体体积（mL）
+    """
+    if not vessel or "data" not in vessel:
+        debug_print(f"⚠️ 容器数据为空，返回 0.0mL")
+        return 0.0
+    
+    vessel_data = vessel["data"]
+    vessel_id = vessel.get("id", "unknown")
+    
+    debug_print(f"🔍 读取容器 '{vessel_id}' 体积数据: {vessel_data}")
+    
+    # 检查liquid_volume字段
+    if "liquid_volume" in vessel_data:
+        liquid_volume = vessel_data["liquid_volume"]
+        
+        # 处理列表格式
+        if isinstance(liquid_volume, list):
+            if len(liquid_volume) > 0:
+                volume = liquid_volume[0]
+                if isinstance(volume, (int, float)):
+                    debug_print(f"✅ 容器 '{vessel_id}' 体积: {volume}mL (列表格式)")
+                    return float(volume)
+        
+        # 处理直接数值格式
+        elif isinstance(liquid_volume, (int, float)):
+            debug_print(f"✅ 容器 '{vessel_id}' 体积: {liquid_volume}mL (数值格式)")
+            return float(liquid_volume)
+    
+    # 检查其他可能的体积字段
+    volume_keys = ['current_volume', 'total_volume', 'volume']
+    for key in volume_keys:
+        if key in vessel_data:
+            try:
+                volume = float(vessel_data[key])
+                if volume > 0:
+                    debug_print(f"✅ 容器 '{vessel_id}' 体积: {volume}mL (字段: {key})")
+                    return volume
+            except (ValueError, TypeError):
+                continue
+    
+    debug_print(f"⚠️ 无法获取容器 '{vessel_id}' 的体积，返回默认值 0.0mL")
+    return 0.0
+
+def update_vessel_volume(vessel: dict, G: nx.DiGraph, new_volume: float, description: str = "") -> None:
+    """
+    更新容器体积（同时更新vessel字典和图节点）
+    
+    Args:
+        vessel: 容器字典
+        G: 网络图
+        new_volume: 新体积
+        description: 更新描述
+    """
+    vessel_id = vessel.get("id", "unknown")
+    
+    if description:
+        debug_print(f"🔧 更新容器体积 - {description}")
+    
+    # 更新vessel字典中的体积
+    if "data" in vessel:
+        if "liquid_volume" in vessel["data"]:
+            current_volume = vessel["data"]["liquid_volume"]
+            if isinstance(current_volume, list):
+                if len(current_volume) > 0:
+                    vessel["data"]["liquid_volume"][0] = new_volume
+                else:
+                    vessel["data"]["liquid_volume"] = [new_volume]
+            else:
+                vessel["data"]["liquid_volume"] = new_volume
+        else:
+            vessel["data"]["liquid_volume"] = new_volume
+    else:
+        vessel["data"] = {"liquid_volume": new_volume}
+    
+    # 同时更新图中的容器数据
+    if vessel_id in G.nodes():
+        if 'data' not in G.nodes[vessel_id]:
+            G.nodes[vessel_id]['data'] = {}
+        
+        vessel_node_data = G.nodes[vessel_id]['data']
+        current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+        
+        if isinstance(current_node_volume, list):
+            if len(current_node_volume) > 0:
+                G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume
+            else:
+                G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume]
+        else:
+            G.nodes[vessel_id]['data']['liquid_volume'] = new_volume
+    
+    debug_print(f"📊 容器 '{vessel_id}' 体积已更新为: {new_volume:.2f}mL")

 def generate_wash_solid_protocol(
    G: nx.DiGraph,
-    vessel: Union[str, dict],
+    vessel: Union[str, dict],  # 🔧 修改：支持vessel字典
    solvent: str,
    volume: Union[float, str] = "50",
-    filtrate_vessel: Union[str, dict] = "",
+    filtrate_vessel: Union[str, dict] = "",  # 🔧 修改：支持vessel字典
    temp: float = 25.0,
    stir: bool = False,
    stir_speed: float = 0.0,
@@ -66,7 +210,7 @@ def generate_wash_solid_protocol(
 ) -> List[Dict[str, Any]]:
    """
    生成固体清洗协议 - 支持vessel字典和体积运算
-
+    
    Args:
        G: 有向图，节点为设备和容器，边为流体管道
        vessel: 清洗容器字典（从XDL传入）或容器ID字符串
@@ -83,78 +227,106 @@ def generate_wash_solid_protocol(
        mass: 固体质量（用于计算溶剂用量）
        event: 事件描述
        **kwargs: 其他可选参数
-
+    
    Returns:
        List[Dict[str, Any]]: 固体清洗操作的动作序列
    """
-
+    
+    # 🔧 核心修改：从vessel参数中提取vessel_id
    vessel_id = extract_vessel_id(vessel)
    vessel_display = get_vessel_display_info(vessel)
-
+    
+    # 🔧 处理filtrate_vessel参数
    filtrate_vessel_id = extract_vessel_id(filtrate_vessel) if filtrate_vessel else ""
-
-    debug_print(f"开始生成固体清洗协议: vessel={vessel_id}, solvent={solvent}, volume={volume}, repeats={repeats}")
-
-    # 记录清洗前的容器状态
+    
+    debug_print("🧼" * 20)
+    debug_print("🚀 开始生成固体清洗协议（支持vessel字典和体积运算）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel_display} (ID: {vessel_id})")
+    debug_print(f"  🧪 solvent: {solvent}")
+    debug_print(f"  💧 volume: {volume}")
+    debug_print(f"  🗑️ filtrate_vessel: {filtrate_vessel_id}")
+    debug_print(f"  ⏰ time: {time}")
+    debug_print(f"  🔄 repeats: {repeats}")
+    debug_print("🧼" * 20)
+    
+    # 🔧 新增：记录清洗前的容器状态
+    debug_print("🔍 记录清洗前容器状态...")
    if isinstance(vessel, dict):
-        original_volume = get_resource_liquid_volume(vessel)
+        original_volume = get_vessel_liquid_volume(vessel)
+        debug_print(f"📊 清洗前液体体积: {original_volume:.2f}mL")
    else:
        original_volume = 0.0
-
-    # 快速验证
-    if not vessel_id or vessel_id not in G.nodes():
+        debug_print(f"📊 vessel为字符串格式，无法获取体积信息")
+    
+    # 📋 快速验证
+    if not vessel_id or vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print("❌ 容器验证失败! 😱")
        raise ValueError("vessel 参数无效")
-
+    
    if not solvent:
+        debug_print("❌ 溶剂不能为空! 😱")
        raise ValueError("solvent 参数不能为空")
-
-    # 参数解析
+    
+    debug_print("✅ 基础验证通过 🎯")
+    
+    # 🔄 参数解析
+    debug_print("📍 步骤1: 参数解析... ⚡")
    final_volume = parse_volume_input(volume, volume_spec, mass)
    final_time = parse_time_input(time)
-
-    # 重复次数处理
+    
+    # 重复次数处理（简化）
    if repeats_spec:
        spec_map = {'few': 2, 'several': 3, 'many': 4, 'thorough': 5}
        final_repeats = next((v for k, v in spec_map.items() if k in repeats_spec.lower()), repeats)
    else:
-        final_repeats = max(1, min(repeats, 5))
-
-    # 模拟时间优化
+        final_repeats = max(1, min(repeats, 5))  # 限制1-5次
+    
+    # 🕐 模拟时间优化
+    debug_print("  ⏱️ 模拟时间优化...")
    original_time = final_time
    if final_time > 60.0:
-        final_time = 60.0
-        debug_print(f"时间优化: {original_time}s -> {final_time}s")
-
+        final_time = 60.0  # 限制最长60秒
+        debug_print(f"  🎮 时间优化: {original_time}s → {final_time}s ⚡")
+    
    # 参数修正
-    temp = max(25.0, min(temp, 80.0))
-    stir_speed = max(0.0, min(stir_speed, 300.0)) if stir else 0.0
-
-    debug_print(f"最终参数: 体积={final_volume}mL, 时间={final_time}s, 重复={final_repeats}次")
-
-    # 查找设备
+    temp = max(25.0, min(temp, 80.0))  # 温度范围25-80°C
+    stir_speed = max(0.0, min(stir_speed, 300.0)) if stir else 0.0  # 速度范围0-300
+    
+    debug_print(f"🎯 最终参数: 体积={final_volume}mL, 时间={final_time}s, 重复={final_repeats}次")
+    
+    # 🔍 查找设备
+    debug_print("📍 步骤2: 查找设备... 🔍")
    try:
        solvent_source = find_solvent_source(G, solvent)
        actual_filtrate_vessel = find_filtrate_vessel(G, filtrate_vessel_id)
+        debug_print(f"🎉 设备配置完成 ✨")
+        debug_print(f"  🧪 溶剂源: {solvent_source}")
+        debug_print(f"  🗑️ 滤液容器: {actual_filtrate_vessel}")
    except Exception as e:
+        debug_print(f"❌ 设备查找失败: {str(e)} 😭")
        raise ValueError(f"设备查找失败: {str(e)}")
-
-    # 生成动作序列
+    
+    # 🚀 生成动作序列
+    debug_print("📍 步骤3: 生成清洗动作... 🧼")
    action_sequence = []
-
+    
+    # 🔧 新增：体积变化跟踪变量
    current_volume = original_volume
    total_solvent_used = 0.0
-
+    
    for cycle in range(final_repeats):
-        debug_print(f"第{cycle+1}/{final_repeats}次清洗")
-
+        debug_print(f"  🔄 第{cycle+1}/{final_repeats}次清洗...")
+        
        # 1. 转移溶剂
        try:
            from .pump_protocol import generate_pump_protocol_with_rinsing
-
+            
+            debug_print(f"    💧 添加溶剂: {final_volume}mL {solvent}")
            transfer_actions = generate_pump_protocol_with_rinsing(
                G=G,
                from_vessel=solvent_source,
-                to_vessel=vessel_id,
+                to_vessel=vessel_id,  # 🔧 使用 vessel_id
                volume=final_volume,
                amount="",
                time=0.0,
@@ -166,160 +338,211 @@ def generate_wash_solid_protocol(
                flowrate=2.5,
                transfer_flowrate=0.5
            )
-
+            
            if transfer_actions:
                action_sequence.extend(transfer_actions)
-
+                debug_print(f"    ✅ 转移动作: {len(transfer_actions)}个 🚚")
+                
+                # 🔧 新增：更新体积 - 添加溶剂后
                current_volume += final_volume
                total_solvent_used += final_volume
-
+                
                if isinstance(vessel, dict):
-                    update_vessel_volume(vessel, G, current_volume,
+                    update_vessel_volume(vessel, G, current_volume, 
                                       f"第{cycle+1}次清洗添加{final_volume}mL溶剂后")
-
+            
        except Exception as e:
-            debug_print(f"转移失败: {str(e)}")
-
+            debug_print(f"    ❌ 转移失败: {str(e)} 😞")
+        
        # 2. 搅拌（如果需要）
        if stir and final_time > 0:
+            debug_print(f"    🌪️ 搅拌: {final_time}s @ {stir_speed}RPM")
            stir_action = {
                "device_id": "stirrer_1",
                "action_name": "stir",
                "action_kwargs": {
-                    "vessel": {"id": vessel_id},
+                    "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
                    "time": str(time),
                    "stir_time": final_time,
                    "stir_speed": stir_speed,
-                    "settling_time": 10.0
+                    "settling_time": 10.0  # 🕐 缩短沉降时间
                }
            }
            action_sequence.append(stir_action)
-
+            debug_print(f"    ✅ 搅拌动作: {final_time}s, {stir_speed}RPM 🌪️")
+        
        # 3. 过滤
+        debug_print(f"    🌊 过滤到: {actual_filtrate_vessel}")
        filter_action = {
            "device_id": "filter_1",
            "action_name": "filter",
            "action_kwargs": {
-                "vessel": {"id": vessel_id},
+                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
                "filtrate_vessel": actual_filtrate_vessel,
                "temp": temp,
                "volume": final_volume
            }
        }
        action_sequence.append(filter_action)
-
-        # 更新体积 - 过滤后
-        filtered_volume = current_volume * 0.9
+        debug_print(f"    ✅ 过滤动作: → {actual_filtrate_vessel} 🌊")
+        
+        # 🔧 新增：更新体积 - 过滤后（液体被滤除）
+        # 假设滤液完全被移除，固体残留在容器中
+        filtered_volume = current_volume * 0.9  # 假设90%的液体被过滤掉
        current_volume = current_volume - filtered_volume
-
+        
        if isinstance(vessel, dict):
-            update_vessel_volume(vessel, G, current_volume,
+            update_vessel_volume(vessel, G, current_volume, 
                               f"第{cycle+1}次清洗过滤后")
-
-        # 4. 等待
-        wait_time = 5.0
+        
+        # 4. 等待（缩短时间）
+        wait_time = 5.0  # 🕐 缩短等待时间：10s → 5s
        action_sequence.append({
            "action_name": "wait",
            "action_kwargs": {"time": wait_time}
        })
-
-    # 最终状态
+        debug_print(f"    ✅ 等待: {wait_time}s ⏰")
+    
+    # 🔧 新增：清洗完成后的最终状态报告
    if isinstance(vessel, dict):
-        final_volume_vessel = get_resource_liquid_volume(vessel)
+        final_volume_vessel = get_vessel_liquid_volume(vessel)
    else:
        final_volume_vessel = current_volume
-
-    debug_print(f"固体清洗协议生成完成: {len(action_sequence)} 个动作, {final_repeats}次清洗, 溶剂总用量={total_solvent_used:.2f}mL")
-
+    
+    # 🎊 总结
+    debug_print("🧼" * 20)
+    debug_print(f"🎉 固体清洗协议生成完成! ✨")
+    debug_print(f"📊 协议统计:")
+    debug_print(f"  📋 总动作数: {len(action_sequence)} 个")
+    debug_print(f"  🥽 清洗容器: {vessel_display}")
+    debug_print(f"  🧪 使用溶剂: {solvent}")
+    debug_print(f"  💧 单次体积: {final_volume}mL")
+    debug_print(f"  🔄 清洗次数: {final_repeats}次")
+    debug_print(f"  💧 总溶剂用量: {total_solvent_used:.2f}mL")
+    debug_print(f"📊 体积变化统计:")
+    debug_print(f"  - 清洗前体积: {original_volume:.2f}mL")
+    debug_print(f"  - 清洗后体积: {final_volume_vessel:.2f}mL")
+    debug_print(f"  - 溶剂总用量: {total_solvent_used:.2f}mL")
+    debug_print(f"⏱️ 预计总时间: {(final_time + 5) * final_repeats / 60:.1f} 分钟")
+    debug_print("🧼" * 20)
+    
    return action_sequence

-# 便捷函数
-def wash_with_water(G: nx.DiGraph, vessel: Union[str, dict],
-                   volume: Union[float, str] = "50",
+# 🔧 新增：便捷函数
+def wash_with_water(G: nx.DiGraph, vessel: Union[str, dict], 
+                   volume: Union[float, str] = "50", 
                   repeats: int = 2) -> List[Dict[str, Any]]:
    """用水清洗固体"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"💧 水洗固体: {vessel_display} ({repeats} 次)")
    return generate_wash_solid_protocol(G, vessel, "water", volume=volume, repeats=repeats)

-def wash_with_ethanol(G: nx.DiGraph, vessel: Union[str, dict],
-                     volume: Union[float, str] = "30",
+def wash_with_ethanol(G: nx.DiGraph, vessel: Union[str, dict], 
+                     volume: Union[float, str] = "30", 
                     repeats: int = 1) -> List[Dict[str, Any]]:
    """用乙醇清洗固体"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"🍺 乙醇洗固体: {vessel_display} ({repeats} 次)")
    return generate_wash_solid_protocol(G, vessel, "ethanol", volume=volume, repeats=repeats)

-def wash_with_acetone(G: nx.DiGraph, vessel: Union[str, dict],
-                     volume: Union[float, str] = "25",
+def wash_with_acetone(G: nx.DiGraph, vessel: Union[str, dict], 
+                     volume: Union[float, str] = "25", 
                     repeats: int = 1) -> List[Dict[str, Any]]:
    """用丙酮清洗固体"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"💨 丙酮洗固体: {vessel_display} ({repeats} 次)")
    return generate_wash_solid_protocol(G, vessel, "acetone", volume=volume, repeats=repeats)

-def wash_with_ether(G: nx.DiGraph, vessel: Union[str, dict],
-                   volume: Union[float, str] = "40",
+def wash_with_ether(G: nx.DiGraph, vessel: Union[str, dict], 
+                   volume: Union[float, str] = "40", 
                   repeats: int = 2) -> List[Dict[str, Any]]:
    """用乙醚清洗固体"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"🌬️ 乙醚洗固体: {vessel_display} ({repeats} 次)")
    return generate_wash_solid_protocol(G, vessel, "diethyl_ether", volume=volume, repeats=repeats)

-def wash_with_cold_solvent(G: nx.DiGraph, vessel: Union[str, dict],
-                          solvent: str, volume: Union[float, str] = "30",
+def wash_with_cold_solvent(G: nx.DiGraph, vessel: Union[str, dict], 
+                          solvent: str, volume: Union[float, str] = "30", 
                          repeats: int = 1) -> List[Dict[str, Any]]:
    """用冷溶剂清洗固体"""
-    return generate_wash_solid_protocol(G, vessel, solvent, volume=volume,
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"❄️ 冷{solvent}洗固体: {vessel_display} ({repeats} 次)")
+    return generate_wash_solid_protocol(G, vessel, solvent, volume=volume, 
                                      temp=5.0, repeats=repeats)

-def wash_with_hot_solvent(G: nx.DiGraph, vessel: Union[str, dict],
-                         solvent: str, volume: Union[float, str] = "50",
+def wash_with_hot_solvent(G: nx.DiGraph, vessel: Union[str, dict], 
+                         solvent: str, volume: Union[float, str] = "50", 
                         repeats: int = 1) -> List[Dict[str, Any]]:
    """用热溶剂清洗固体"""
-    return generate_wash_solid_protocol(G, vessel, solvent, volume=volume,
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"🔥 热{solvent}洗固体: {vessel_display} ({repeats} 次)")
+    return generate_wash_solid_protocol(G, vessel, solvent, volume=volume, 
                                      temp=60.0, repeats=repeats)

-def wash_with_stirring(G: nx.DiGraph, vessel: Union[str, dict],
-                      solvent: str, volume: Union[float, str] = "50",
-                      stir_time: Union[str, float] = "5 min",
+def wash_with_stirring(G: nx.DiGraph, vessel: Union[str, dict], 
+                      solvent: str, volume: Union[float, str] = "50", 
+                      stir_time: Union[str, float] = "5 min", 
                      repeats: int = 1) -> List[Dict[str, Any]]:
    """带搅拌的溶剂清洗"""
-    return generate_wash_solid_protocol(G, vessel, solvent, volume=volume,
-                                      stir=True, stir_speed=200.0,
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"🌪️ 搅拌清洗: {vessel_display} with {solvent} ({repeats} 次)")
+    return generate_wash_solid_protocol(G, vessel, solvent, volume=volume, 
+                                      stir=True, stir_speed=200.0, 
                                      time=stir_time, repeats=repeats)

-def thorough_wash(G: nx.DiGraph, vessel: Union[str, dict],
+def thorough_wash(G: nx.DiGraph, vessel: Union[str, dict], 
                 solvent: str, volume: Union[float, str] = "50") -> List[Dict[str, Any]]:
    """彻底清洗（多次重复）"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"🔄 彻底清洗: {vessel_display} with {solvent} (5 次)")
    return generate_wash_solid_protocol(G, vessel, solvent, volume=volume, repeats=5)

-def quick_rinse(G: nx.DiGraph, vessel: Union[str, dict],
+def quick_rinse(G: nx.DiGraph, vessel: Union[str, dict], 
               solvent: str, volume: Union[float, str] = "20") -> List[Dict[str, Any]]:
    """快速冲洗（单次，小体积）"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"⚡ 快速冲洗: {vessel_display} with {solvent}")
    return generate_wash_solid_protocol(G, vessel, solvent, volume=volume, repeats=1)

-def sequential_wash(G: nx.DiGraph, vessel: Union[str, dict],
+def sequential_wash(G: nx.DiGraph, vessel: Union[str, dict], 
                   solvents: list, volume: Union[float, str] = "40") -> List[Dict[str, Any]]:
    """连续多溶剂清洗"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"📝 连续清洗: {vessel_display} with {' → '.join(solvents)}")
+    
    action_sequence = []
    for solvent in solvents:
-        wash_actions = generate_wash_solid_protocol(G, vessel, solvent,
+        wash_actions = generate_wash_solid_protocol(G, vessel, solvent, 
                                                   volume=volume, repeats=1)
        action_sequence.extend(wash_actions)
-
+    
    return action_sequence

 # 测试函数
 def test_wash_solid_protocol():
    """测试固体清洗协议"""
-    debug_print("=== WASH SOLID PROTOCOL 测试 ===")
-
-    vessel_dict = {"id": "filter_flask_1", "name": "过滤瓶1",
+    debug_print("🧪 === WASH SOLID PROTOCOL 测试 === ✨")
+    
+    # 测试vessel参数处理
+    debug_print("🔧 测试vessel参数处理...")
+    
+    # 测试字典格式
+    vessel_dict = {"id": "filter_flask_1", "name": "过滤瓶1", 
                  "data": {"liquid_volume": 25.0}}
    vessel_id = extract_vessel_id(vessel_dict)
    vessel_display = get_vessel_display_info(vessel_dict)
-    volume = get_resource_liquid_volume(vessel_dict)
-    debug_print(f"字典格式: ID={vessel_id}, 显示={vessel_display}, 体积={volume}mL")
-
+    volume = get_vessel_liquid_volume(vessel_dict)
+    debug_print(f"  字典格式: {vessel_dict}")
+    debug_print(f"    → ID: {vessel_id}, 显示: {vessel_display}, 体积: {volume}mL")
+    
+    # 测试字符串格式
    vessel_str = "filter_flask_2"
    vessel_id = extract_vessel_id(vessel_str)
    vessel_display = get_vessel_display_info(vessel_str)
-    debug_print(f"字符串格式: ID={vessel_id}, 显示={vessel_display}")
-
-    debug_print("测试完成")
+    debug_print(f"  字符串格式: {vessel_str}")
+    debug_print(f"    → ID: {vessel_id}, 显示: {vessel_display}")
+    
+    debug_print("✅ 测试完成 🎉")

 if __name__ == "__main__":
-    test_wash_solid_protocol()
+    test_wash_solid_protocol()
--- a/unilabos/config/config.py
+++ b/unilabos/config/config.py
@@ -46,7 +46,7 @@ class WSConfig:

 # HTTP配置
 class HTTPConfig:
-    remote_addr = "https://uni-lab.bohrium.com/api/v1"
+    remote_addr = "https://leap-lab.bohrium.com/api/v1"


 # ROS配置
--- a/unilabos/devices/transport/init.py
+++ b/unilabos/devices/transport/init.py
--- a/unilabos/devices/transport/agv_workstation.py
+++ b/unilabos/devices/transport/agv_workstation.py
@@ -1,127 +0,0 @@
-"""
-AGV 通用转运工站 Driver
-
-继承 WorkstationBase，通过 WorkstationNodeCreator 自动获得 ROS2WorkstationNode 能力。
-Warehouse 作为 children 中的资源节点，由 attach_resource() 自动注册到 resource_tracker。
-deck=None，不使用 PLR Deck 抽象。
-"""
-
-from typing import Any, Dict, List, Optional
-
-from pylabrobot.resources import Deck
-
-from unilabos.devices.workstation.workstation_base import WorkstationBase
-from unilabos.resources.warehouse import WareHouse
-from unilabos.utils import logger
-
-
-class AGVTransportStation(WorkstationBase):
-    """通用 AGV 转运工站
-
-    初始化链路（零框架改动）：
-        ROS2DeviceNode.__init__():
-          issubclass(AGVTransportStation, WorkstationBase) → True
-          → WorkstationNodeCreator.create_instance(data):
-              data["deck"] = None
-              → DeviceClassCreator.create_instance(data) → AGVTransportStation(deck=None, ...)
-              → attach_resource(): children 中 type="warehouse" → resource_tracker.add_resource(wh)
-          → ROS2WorkstationNode(protocol_type=[...], children=[nav, arm], ...)
-          → driver.post_init(ros_node):
-              self.carrier 从 resource_tracker 中获取 WareHouse
-    """
-
-    def __init__(
-        self,
-        deck: Optional[Deck] = None,
-        children: Optional[List[Any]] = None,
-        route_table: Optional[Dict[str, Dict[str, str]]] = None,
-        device_roles: Optional[Dict[str, str]] = None,
-        **kwargs,
-    ):
-        super().__init__(deck=None, **kwargs)
-        self.route_table: Dict[str, Dict[str, str]] = route_table or {}
-        self.device_roles: Dict[str, str] = device_roles or {}
-
-    # ============ 载具 (Warehouse) ============
-
-    @property
-    def carrier(self) -> Optional[WareHouse]:
-        """从 resource_tracker 中找到 AGV 载具 Warehouse"""
-        if not hasattr(self, "_ros_node"):
-            return None
-        for res in self._ros_node.resource_tracker.resources:
-            if isinstance(res, WareHouse):
-                return res
-        return None
-
-    @property
-    def capacity(self) -> int:
-        """AGV 载具总容量（slot 数）"""
-        wh = self.carrier
-        if wh is None:
-            return 0
-        return wh.num_items_x * wh.num_items_y * wh.num_items_z
-
-    @property
-    def free_slots(self) -> List[str]:
-        """返回当前空闲 slot 名称列表"""
-        wh = self.carrier
-        if wh is None:
-            return []
-        ordering = getattr(wh, "_ordering", {})
-        return [name for name, site in ordering.items() if site.resource is None]
-
-    @property
-    def occupied_slots(self) -> Dict[str, Any]:
-        """返回已占用的 slot → Resource 映射"""
-        wh = self.carrier
-        if wh is None:
-            return {}
-        ordering = getattr(wh, "_ordering", {})
-        return {name: site.resource for name, site in ordering.items() if site.resource is not None}
-
-    # ============ 路由查询 ============
-
-    def resolve_route(self, from_station: str, to_station: str) -> Dict[str, str]:
-        """查询路由表，返回导航和机械臂指令
-
-        Args:
-            from_station: 来源工站 ID
-            to_station: 目标工站 ID
-
-        Returns:
-            {"nav_command": "...", "arm_pick": "...", "arm_place": "..."}
-
-        Raises:
-            KeyError: 路由表中未找到对应路线
-        """
-        route_key = f"{from_station}->{to_station}"
-        if route_key not in self.route_table:
-            raise KeyError(f"路由表中未找到路线: {route_key}")
-        return self.route_table[route_key]
-
-    def get_device_id(self, role: str) -> str:
-        """获取子设备 ID
-
-        Args:
-            role: 设备角色，如 "navigator", "arm"
-
-        Returns:
-            设备 ID 字符串
-
-        Raises:
-            KeyError: 未配置该角色的设备
-        """
-        if role not in self.device_roles:
-            raise KeyError(f"未配置设备角色: {role}，当前已配置: {list(self.device_roles.keys())}")
-        return self.device_roles[role]
-
-    # ============ 生命周期 ============
-
-    def post_init(self, ros_node) -> None:
-        super().post_init(ros_node)
-        wh = self.carrier
-        if wh is not None:
-            logger.info(f"AGV {ros_node.device_id} 载具已就绪: {wh.name}, 容量={self.capacity}")
-        else:
-            logger.warning(f"AGV {ros_node.device_id} 未发现 Warehouse 载具资源")
--- a/unilabos/devices/virtual/workbench.py
+++ b/unilabos/devices/virtual/workbench.py
@@ -22,10 +22,11 @@ from threading import Lock, RLock
 from typing_extensions import TypedDict

 from unilabos.registry.decorators import (
-    device, action, ActionInputHandle, ActionOutputHandle, DataSource, topic_config, not_action
+    device, action, ActionInputHandle, ActionOutputHandle, DataSource, topic_config, not_action, NodeType
 )
-from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-from unilabos.resources.resource_tracker import SampleUUIDsType, LabSample
+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


 # ============ TypedDict 返回类型定义 ============
@@ -290,6 +291,126 @@ class VirtualWorkbench:
        self._update_data_status(f"机械臂已释放 (完成: {task})")
        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,
+        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),
+            # 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),
+            # 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),
+        ]
+    )
+    def manual_confirm(
+        self,
+        resource: List[ResourceSlot],
+        target_device: DeviceSlot,
+        mount_resource: List[ResourceSlot],
+        collector_mass: List[float],
+        active_material: List[float],
+        capacity: List[float],
+        battery_system: List[str],
+        timeout_seconds: int,
+        assignee_user_ids: list[str],
+        **kwargs
+    ) -> dict:
+        """
+        timeout_seconds: 超时时间（秒），默认3600秒
+        collector_mass: 极流体质量
+        active_material: 活性物质含量
+        capacity: 克容量（mAh/g）
+        battery_system: 电池体系
+        修改的结果无效，是只读的
+        """
+        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")
+        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),
+        ]
+    )
+    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),
+        ]
+    )
+    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]
+    ):
+        print(resource)
+        print(mount_resource)
+        print(collector_mass)
+        print(active_material)
+        print(capacity)
+        print(battery_system)
+
    @action(
        auto_prefix=True,
        description="批量准备物料 - 虚拟起始节点, 生成A1-A5物料, 输出5个handle供后续节点使用",
--- a/unilabos/devices/workstation/workstation_base.py
+++ b/unilabos/devices/workstation/workstation_base.py
@@ -197,28 +197,6 @@ class WorkstationBase(ABC):
        self._ros_node = workstation_node
        logger.info(f"工作站 {self._ros_node.device_id} 关联协议节点")

-    # ============ 物料转运回调 ============
-
-    def resource_tree_batch_transfer(
-        self,
-        transfers: list,
-        old_parents: list,
-        new_parents: list,
-    ) -> None:
-        """批量物料转运完成后的回调，供子类重写
-
-        默认实现：逐个调用 resource_tree_transfer（如存在）。
-
-        Args:
-            transfers: 转移列表，每项包含 resource, from_parent, to_parent, to_site 等
-            old_parents: 每个物料转移前的原父节点
-            new_parents: 每个物料转移后的新父节点
-        """
-        func = getattr(self, "resource_tree_transfer", None)
-        if callable(func):
-            for t, old_parent, new_parent in zip(transfers, old_parents, new_parents):
-                func(old_parent, t["resource"], new_parent)
-
    # ============ 设备操作接口 ============

    def call_device_method(self, method: str, *args, **kwargs) -> Any:
--- a/unilabos/messages/init.py
+++ b/unilabos/messages/init.py
@@ -217,24 +217,6 @@ class AGVTransferProtocol(BaseModel):
    from_repo_position: str
    to_repo_position: str

-
-class BatchTransferItem(BaseModel):
-    """批量转运中的单个物料条目"""
-    resource_uuid: str = ""
-    resource_id: str = ""
-    from_position: str
-    to_position: str
-
-
-class BatchTransferProtocol(BaseModel):
-    """批量物料转运协议 — 支持多物料一次性从来源工站转运到目标工站"""
-    from_repo: dict
-    to_repo: dict
-    transfer_resources: list  # list[Resource dict]，被转运的物料
-    from_positions: list      # list[str]，来源 slot 位置（与 transfer_resources 平行）
-    to_positions: list        # list[str]，目标 slot 位置（与 transfer_resources 平行）
-
-
 #=============新添加的新的协议================
 class AddProtocol(BaseModel):
    vessel: dict
@@ -647,16 +629,15 @@ class HydrogenateProtocol(BaseModel):
    vessel: dict = Field(..., description="反应容器")

 __all__ = [
-    "Point3D", "PumpTransferProtocol", "CleanProtocol", "SeparateProtocol",
-    "EvaporateProtocol", "EvacuateAndRefillProtocol", "AGVTransferProtocol",
-    "BatchTransferItem", "BatchTransferProtocol",
-    "CentrifugeProtocol", "AddProtocol", "FilterProtocol",
+    "Point3D", "PumpTransferProtocol", "CleanProtocol", "SeparateProtocol", 
+    "EvaporateProtocol", "EvacuateAndRefillProtocol", "AGVTransferProtocol", 
+    "CentrifugeProtocol", "AddProtocol", "FilterProtocol", 
    "HeatChillProtocol",
    "HeatChillStartProtocol", "HeatChillStopProtocol",
-    "StirProtocol", "StartStirProtocol", "StopStirProtocol",
-    "TransferProtocol", "CleanVesselProtocol", "DissolveProtocol",
+    "StirProtocol", "StartStirProtocol", "StopStirProtocol", 
+    "TransferProtocol", "CleanVesselProtocol", "DissolveProtocol", 
    "FilterThroughProtocol", "RunColumnProtocol", "WashSolidProtocol",
-    "AdjustPHProtocol", "ResetHandlingProtocol", "DryProtocol",
+    "AdjustPHProtocol", "ResetHandlingProtocol", "DryProtocol", 
    "RecrystallizeProtocol", "HydrogenateProtocol"
 ]
 # End Protocols
--- a/unilabos/registry/ast_registry_scanner.py
+++ b/unilabos/registry/ast_registry_scanner.py
@@ -825,6 +825,7 @@ def _extract_class_body(
            action_args.setdefault("placeholder_keys", {})
            action_args.setdefault("always_free", False)
            action_args.setdefault("is_protocol", False)
+            action_args.setdefault("feedback_interval", 1.0)
            action_args.setdefault("description", "")
            action_args.setdefault("auto_prefix", False)
            action_args.setdefault("parent", False)
--- a/unilabos/registry/decorators.py
+++ b/unilabos/registry/decorators.py
@@ -343,6 +343,7 @@ def action(
    auto_prefix: bool = False,
    parent: bool = False,
    node_type: Optional["NodeType"] = None,
+    feedback_interval: Optional[float] = None,
 ):
    """
    动作方法装饰器
@@ -378,9 +379,16 @@ def action(
    """

    def decorator(func: F) -> F:
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
+        import asyncio as _asyncio
+
+        if _asyncio.iscoroutinefunction(func):
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                return await func(*args, **kwargs)
+        else:
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)

        # action_type 为哨兵值 => 用户没传, 视为 None (UniLabJsonCommand)
        resolved_type = None if action_type is _ACTION_TYPE_UNSET else action_type
@@ -399,6 +407,8 @@ def action(
            "auto_prefix": auto_prefix,
            "parent": parent,
        }
+        if feedback_interval is not None:
+            meta["feedback_interval"] = feedback_interval
        if node_type is not None:
            meta["node_type"] = node_type.value if isinstance(node_type, NodeType) else str(node_type)
        wrapper._action_registry_meta = meta  # type: ignore[attr-defined]
--- a/unilabos/registry/devices/hotel.yaml
+++ b/unilabos/registry/devices/hotel.yaml
@@ -31,6 +31,6 @@ hotel.thermo_orbitor_rs2_hotel:
      type: object
  model:
    mesh: thermo_orbitor_rs2_hotel
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/thermo_orbitor_rs2_hotel/macro_device.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/thermo_orbitor_rs2_hotel/macro_device.xacro
    type: device
  version: 1.0.0
--- a/unilabos/registry/devices/robot_arm.yaml
+++ b/unilabos/registry/devices/robot_arm.yaml
@@ -329,7 +329,7 @@ robotic_arm.SCARA_with_slider.moveit.virtual:
      type: object
  model:
    mesh: arm_slider
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/arm_slider/macro_device.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/arm_slider/macro_device.xacro
    type: device
  version: 1.0.0
 robotic_arm.UR:
--- a/unilabos/registry/devices/transport_agv.yaml
+++ b/unilabos/registry/devices/transport_agv.yaml
@@ -1,368 +0,0 @@
-agv_transport_station:
-  category:
-  - work_station
-  - transport_agv
-  class:
-    action_value_mappings:
-      AGVTransferProtocol:
-        feedback: {}
-        goal:
-          from_repo: from_repo
-          from_repo_position: from_repo_position
-          to_repo: to_repo
-          to_repo_position: to_repo_position
-        goal_default:
-          from_repo:
-            category: ''
-            children: []
-            config: ''
-            data: ''
-            id: ''
-            name: ''
-            parent: ''
-            pose:
-              orientation:
-                w: 1.0
-                x: 0.0
-                y: 0.0
-                z: 0.0
-              position:
-                x: 0.0
-                y: 0.0
-                z: 0.0
-            sample_id: ''
-            type: ''
-          from_repo_position: ''
-          to_repo:
-            category: ''
-            children: []
-            config: ''
-            data: ''
-            id: ''
-            name: ''
-            parent: ''
-            pose:
-              orientation:
-                w: 1.0
-                x: 0.0
-                y: 0.0
-                z: 0.0
-              position:
-                x: 0.0
-                y: 0.0
-                z: 0.0
-            sample_id: ''
-            type: ''
-          to_repo_position: ''
-        handles: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback:
-              properties:
-                status:
-                  type: string
-              required:
-              - status
-              title: AGVTransfer_Feedback
-              type: object
-            goal:
-              properties:
-                from_repo:
-                  properties:
-                    category:
-                      type: string
-                    children:
-                      items:
-                        type: string
-                      type: array
-                    config:
-                      type: string
-                    data:
-                      type: string
-                    id:
-                      type: string
-                    name:
-                      type: string
-                    parent:
-                      type: string
-                    pose:
-                      properties:
-                        orientation:
-                          properties:
-                            w:
-                              type: number
-                            x:
-                              type: number
-                            y:
-                              type: number
-                            z:
-                              type: number
-                          required:
-                          - x
-                          - y
-                          - z
-                          - w
-                          title: orientation
-                          type: object
-                        position:
-                          properties:
-                            x:
-                              type: number
-                            y:
-                              type: number
-                            z:
-                              type: number
-                          required:
-                          - x
-                          - y
-                          - z
-                          title: position
-                          type: object
-                      required:
-                      - position
-                      - orientation
-                      title: pose
-                      type: object
-                    sample_id:
-                      type: string
-                    type:
-                      type: string
-                  required:
-                  - id
-                  - name
-                  - sample_id
-                  - children
-                  - parent
-                  - type
-                  - category
-                  - pose
-                  - config
-                  - data
-                  title: from_repo
-                  type: object
-                from_repo_position:
-                  type: string
-                to_repo:
-                  properties:
-                    category:
-                      type: string
-                    children:
-                      items:
-                        type: string
-                      type: array
-                    config:
-                      type: string
-                    data:
-                      type: string
-                    id:
-                      type: string
-                    name:
-                      type: string
-                    parent:
-                      type: string
-                    pose:
-                      properties:
-                        orientation:
-                          properties:
-                            w:
-                              type: number
-                            x:
-                              type: number
-                            y:
-                              type: number
-                            z:
-                              type: number
-                          required:
-                          - x
-                          - y
-                          - z
-                          - w
-                          title: orientation
-                          type: object
-                        position:
-                          properties:
-                            x:
-                              type: number
-                            y:
-                              type: number
-                            z:
-                              type: number
-                          required:
-                          - x
-                          - y
-                          - z
-                          title: position
-                          type: object
-                      required:
-                      - position
-                      - orientation
-                      title: pose
-                      type: object
-                    sample_id:
-                      type: string
-                    type:
-                      type: string
-                  required:
-                  - id
-                  - name
-                  - sample_id
-                  - children
-                  - parent
-                  - type
-                  - category
-                  - pose
-                  - config
-                  - data
-                  title: to_repo
-                  type: object
-                to_repo_position:
-                  type: string
-              required:
-              - from_repo
-              - from_repo_position
-              - to_repo
-              - to_repo_position
-              title: AGVTransfer_Goal
-              type: object
-            result:
-              properties:
-                return_info:
-                  type: string
-                success:
-                  type: boolean
-              required:
-              - return_info
-              - success
-              title: AGVTransfer_Result
-              type: object
-          required:
-          - goal
-          title: AGVTransfer
-          type: object
-        type: AGVTransfer
-      BatchTransferProtocol:
-        feedback: {}
-        goal:
-          from_positions: from_positions
-          from_repo: from_repo
-          to_positions: to_positions
-          to_repo: to_repo
-          transfer_resources: transfer_resources
-        goal_default:
-          from_positions: []
-          from_repo:
-            category: ''
-            children: []
-            config: ''
-            data: ''
-            id: ''
-            name: ''
-            parent: ''
-            pose:
-              orientation:
-                w: 1.0
-                x: 0.0
-                y: 0.0
-                z: 0.0
-              position:
-                x: 0.0
-                y: 0.0
-                z: 0.0
-            sample_id: ''
-            type: ''
-          to_positions: []
-          to_repo:
-            category: ''
-            children: []
-            config: ''
-            data: ''
-            id: ''
-            name: ''
-            parent: ''
-            pose:
-              orientation:
-                w: 1.0
-                x: 0.0
-                y: 0.0
-                z: 0.0
-              position:
-                x: 0.0
-                y: 0.0
-                z: 0.0
-            sample_id: ''
-            type: ''
-          transfer_resources: []
-        handles: {}
-        result: {}
-        schema:
-          description: AGV 批量物料转运协议
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                from_positions:
-                  items:
-                    type: string
-                  type: array
-                from_repo:
-                  type: object
-                to_positions:
-                  items:
-                    type: string
-                  type: array
-                to_repo:
-                  type: object
-                transfer_resources:
-                  items:
-                    type: object
-                  type: array
-              required:
-              - from_repo
-              - to_repo
-              - transfer_resources
-              - from_positions
-              - to_positions
-              type: object
-            result: {}
-          required:
-          - goal
-          title: BatchTransferProtocol
-          type: object
-        type: BatchTransfer
-    module: unilabos.devices.transport.agv_workstation:AGVTransportStation
-    status_types:
-      agv_status: String
-      carrier_status: String
-    type: python
-  config_info: []
-  description: 通用 AGV 转运工站。继承 WorkstationBase，通过 Warehouse 子资源管理物料中转态。支持单物料和批量物料转运协议，路由表和子设备配置全部由
-    JSON 驱动。
-  handles: []
-  icon: ''
-  init_param_schema:
-    config:
-      properties:
-        device_roles:
-          properties:
-            arm:
-              type: string
-            navigator:
-              type: string
-          type: object
-        protocol_type:
-          items:
-            type: string
-          type: array
-        route_table:
-          type: object
-      type: object
-    data:
-      properties:
-        agv_status:
-          type: string
-        carrier_status:
-          type: string
-      type: object
-  version: 1.0.0
--- a/unilabos/registry/registry.py
+++ b/unilabos/registry/registry.py
@@ -238,6 +238,7 @@ class Registry:
                            "class_name": "unilabos_class",
                        },
                        "always_free": True,
+                        "feedback_interval": 300.0,
                    },
                    "test_latency": test_latency_action,
                    "auto-test_resource": test_resource_action,
@@ -829,8 +830,9 @@ class Registry:
            raw_handles = (action_args or {}).get("handles")
            handles = normalize_ast_action_handles(raw_handles) if isinstance(raw_handles, list) else (raw_handles or {})

-            # placeholder_keys: 优先用装饰器显式配置，否则从参数类型检测
-            pk = (action_args or {}).get("placeholder_keys") or detect_placeholder_keys(params)
+            # placeholder_keys: 先从参数类型自动检测，再用装饰器显式配置覆盖/补充
+            pk = detect_placeholder_keys(params)
+            pk.update((action_args or {}).get("placeholder_keys") or {})

            # 从方法返回值类型生成 result schema
            result_schema = None
@@ -852,6 +854,8 @@ class Registry:
            }
            if (action_args or {}).get("always_free") or method_info.get("always_free"):
                entry["always_free"] = True
+            _fb_iv = (action_args or {}).get("feedback_interval", method_info.get("feedback_interval", 1.0))
+            entry["feedback_interval"] = _fb_iv
            nt = normalize_enum_value((action_args or {}).get("node_type"), NodeType)
            if nt:
                entry["node_type"] = nt
@@ -975,10 +979,12 @@ class Registry:
                "schema": schema,
                "goal_default": goal_default,
                "handles": handles,
-                "placeholder_keys": action_args.get("placeholder_keys") or detect_placeholder_keys(method_params),
+                "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
+            _fb_iv = action_args.get("feedback_interval", method_info.get("feedback_interval", 1.0))
+            action_entry["feedback_interval"] = _fb_iv
            nt = normalize_enum_value(action_args.get("node_type"), NodeType)
            if nt:
                action_entry["node_type"] = nt
--- a/unilabos/registry/resources/common/resource_container.yaml
+++ b/unilabos/registry/resources/common/resource_container.yaml
@@ -17,7 +17,7 @@ hplc_plate:
    - 0
    - 0
    - 3.1416
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/hplc_plate/modal.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/hplc_plate/modal.xacro
    type: resource
  version: 1.0.0
 plate_96:
@@ -39,7 +39,7 @@ plate_96:
    - 0
    - 0
    - 0
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/plate_96/modal.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/plate_96/modal.xacro
    type: resource
  version: 1.0.0
 plate_96_high:
@@ -61,7 +61,7 @@ plate_96_high:
    - 1.5708
    - 0
    - 1.5708
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/plate_96_high/modal.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/plate_96_high/modal.xacro
    type: resource
  version: 1.0.0
 tiprack_96_high:
@@ -76,7 +76,7 @@ tiprack_96_high:
  init_param_schema: {}
  model:
    children_mesh: generic_labware_tube_10_75/meshes/0_base.stl
-    children_mesh_path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/generic_labware_tube_10_75/modal.xacro
+    children_mesh_path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/generic_labware_tube_10_75/modal.xacro
    children_mesh_tf:
    - 0.0018
    - 0.0018
@@ -92,7 +92,7 @@ tiprack_96_high:
    - 1.5708
    - 0
    - 1.5708
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tiprack_96_high/modal.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tiprack_96_high/modal.xacro
    type: resource
  version: 1.0.0
 tiprack_box:
@@ -107,7 +107,7 @@ tiprack_box:
  init_param_schema: {}
  model:
    children_mesh: tip/meshes/tip.stl
-    children_mesh_path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tip/modal.xacro
+    children_mesh_path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tip/modal.xacro
    children_mesh_tf:
    - 0.0045
    - 0.0045
@@ -123,6 +123,6 @@ tiprack_box:
    - 0
    - 0
    - 0
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tiprack_box/modal.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tiprack_box/modal.xacro
    type: resource
  version: 1.0.0
--- a/unilabos/registry/resources/laiyu/container.yaml
+++ b/unilabos/registry/resources/laiyu/container.yaml
@@ -11,7 +11,7 @@ bottle_container:
  init_param_schema: {}
  model:
    children_mesh: bottle/meshes/bottle.stl
-    children_mesh_path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/bottle/modal.xacro
+    children_mesh_path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/bottle/modal.xacro
    children_mesh_tf:
    - 0.04
    - 0.04
@@ -27,7 +27,7 @@ bottle_container:
    - 0
    - 0
    - 0
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/bottle_container/modal.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/bottle_container/modal.xacro
    type: resource
  version: 1.0.0
 tube_container:
@@ -43,7 +43,7 @@ tube_container:
  init_param_schema: {}
  model:
    children_mesh: tube/meshes/tube.stl
-    children_mesh_path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tube/modal.xacro
+    children_mesh_path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tube/modal.xacro
    children_mesh_tf:
    - 0.017
    - 0.017
@@ -59,6 +59,6 @@ tube_container:
    - 0
    - 0
    - 0
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tube_container/modal.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tube_container/modal.xacro
    type: resource
  version: 1.0.0
--- a/unilabos/registry/resources/laiyu/deck.yaml
+++ b/unilabos/registry/resources/laiyu/deck.yaml
@@ -10,6 +10,6 @@ TransformXYZDeck:
  init_param_schema: {}
  model:
    mesh: liquid_transform_xyz
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/liquid_transform_xyz/macro_device.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/liquid_transform_xyz/macro_device.xacro
    type: device
  version: 1.0.0
--- a/unilabos/registry/resources/opentrons/deck.yaml
+++ b/unilabos/registry/resources/opentrons/deck.yaml
@@ -10,7 +10,7 @@ OTDeck:
  init_param_schema: {}
  model:
    mesh: opentrons_liquid_handler
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/opentrons_liquid_handler/macro_device.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/opentrons_liquid_handler/macro_device.xacro
    type: device
  version: 1.0.0
 hplc_station:
@@ -25,6 +25,6 @@ hplc_station:
  init_param_schema: {}
  model:
    mesh: hplc_station
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/hplc_station/macro_device.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/devices/hplc_station/macro_device.xacro
    type: device
  version: 1.0.0
--- a/unilabos/registry/resources/opentrons/plates.yaml
+++ b/unilabos/registry/resources/opentrons/plates.yaml
@@ -109,7 +109,7 @@ nest_96_wellplate_100ul_pcr_full_skirt:
  init_param_schema: {}
  model:
    children_mesh: generic_labware_tube_10_75/meshes/0_base.stl
-    children_mesh_path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/generic_labware_tube_10_75/modal.xacro
+    children_mesh_path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/generic_labware_tube_10_75/modal.xacro
    children_mesh_tf:
    - 0.0018
    - 0.0018
@@ -125,7 +125,7 @@ nest_96_wellplate_100ul_pcr_full_skirt:
    - -1.5708
    - 0
    - 1.5708
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tecan_nested_tip_rack/modal.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tecan_nested_tip_rack/modal.xacro
    type: resource
  version: 1.0.0
 nest_96_wellplate_200ul_flat:
@@ -158,7 +158,7 @@ nest_96_wellplate_2ml_deep:
    - -1.5708
    - 0
    - 1.5708
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tecan_nested_tip_rack/modal.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tecan_nested_tip_rack/modal.xacro
    type: resource
  version: 1.0.0
 thermoscientificnunc_96_wellplate_1300ul:
--- a/unilabos/registry/resources/opentrons/tip_racks.yaml
+++ b/unilabos/registry/resources/opentrons/tip_racks.yaml
@@ -69,7 +69,7 @@ opentrons_96_filtertiprack_1000ul:
    - -1.5708
    - 0
    - 1.5708
-    path: https://uni-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tecan_nested_tip_rack/modal.xacro
+    path: https://leap-lab.oss-cn-zhangjiakou.aliyuncs.com/uni-lab/resources/tecan_nested_tip_rack/modal.xacro
    type: resource
  version: 1.0.0
 opentrons_96_filtertiprack_10ul:
--- a/unilabos/resources/graphio.py
+++ b/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
@@ -1033,7 +1033,7 @@ def resource_plr_to_bioyond(plr_resources: list[ResourcePLR], type_mapping: dict
                    logger.debug(f"🔍 [PLR→Bioyond] detail转换: {bottle.name} → PLR(x={site['x']},y={site['y']},id={site.get('identifier','?')}) → Bioyond(x={bioyond_x},y={bioyond_y})")

                    # 🔥 提取物料名称：从 tracker.liquids 中获取第一个液体的名称（去除PLR系统添加的后缀）
-                    # tracker.liquids 格式: [(物料名称, 数量), ...]
+                    # tracker.liquids 格式: [(物料名称, 数量, 单位), ...]
                    material_name = bottle_type_info[0]  # 默认使用类型名称（如"样品瓶"）
                    if hasattr(bottle, "tracker") and bottle.tracker.liquids:
                        # 如果有液体，使用液体的名称
@@ -1051,7 +1051,7 @@ def resource_plr_to_bioyond(plr_resources: list[ResourcePLR], type_mapping: dict
                        "typeId": bottle_type_info[1],
                        "code": bottle.code if hasattr(bottle, "code") else "",
                        "name": material_name,  # 使用物料名称（如"9090"），而不是类型名称（"样品瓶"）
-                        "quantity": sum(qty for _, qty in bottle.tracker.liquids) if hasattr(bottle, "tracker") else 0,
+                        "quantity": sum(qty for _, qty, *_ in bottle.tracker.liquids) if hasattr(bottle, "tracker") else 0,
                        "x": bioyond_x,
                        "y": bioyond_y,
                        "z": 1,
@@ -1124,7 +1124,7 @@ def resource_plr_to_bioyond(plr_resources: list[ResourcePLR], type_mapping: dict
                "barCode": "",
                "name": material_name,  # 使用物料名称而不是资源名称
                "unit": default_unit,  # 使用配置的单位或默认单位
-                "quantity": sum(qty for _, qty in bottle.tracker.liquids) if hasattr(bottle, "tracker") else 0,
+                "quantity": sum(qty for _, qty, *_ in bottle.tracker.liquids) if hasattr(bottle, "tracker") else 0,
                "Parameters": parameters_json  # API 实际要求的字段（必需）
            }

--- a/unilabos/ros/main_slave_run.py
+++ b/unilabos/ros/main_slave_run.py
@@ -1,4 +1,5 @@
 import json
+import os

 # from nt import device_encoding
 import threading
@@ -61,7 +62,7 @@ def main(
        rclpy.init(args=rclpy_init_args)
    else:
        logger.info("[ROS] rclpy already initialized, reusing context")
-    executor = rclpy.__executor = MultiThreadedExecutor()
+    executor = rclpy.__executor = MultiThreadedExecutor(num_threads=max(os.cpu_count() * 4, 48))
    # 创建主机节点
    host_node = HostNode(
        "host_node",
@@ -122,7 +123,7 @@ def slave(
        rclpy.init(args=rclpy_init_args)
    executor = rclpy.__executor
    if not executor:
-        executor = rclpy.__executor = MultiThreadedExecutor()
+        executor = rclpy.__executor = MultiThreadedExecutor(num_threads=max(os.cpu_count() * 4, 48))

    # 1.5 启动 executor 线程
    thread = threading.Thread(target=executor.spin, daemon=True, name="slave_executor_thread")
--- a/unilabos/ros/msgs/message_converter.py
+++ b/unilabos/ros/msgs/message_converter.py
@@ -142,16 +142,12 @@ _msg_converter: Dict[Type, Any] = {
    ),
    Resource: lambda x: Resource(
        id=x.get("id", ""),
-        uuid=x.get("uuid", ""),
        name=x.get("name", ""),
        sample_id=x.get("sample_id", "") or "",
-        description=x.get("description", ""),
        children=list(x.get("children", [])),
        parent=x.get("parent", "") or "",
-        parent_uuid=x.get("parent_uuid", ""),
        type=x.get("type", ""),
-        category=x.get("category", "") or x.get("class", "") or x.get("type", ""),
-        klass=x.get("class", "") or x.get("klass", ""),
+        category=x.get("class", "") or x.get("type", ""),
        pose=(
            Pose(
                position=Point(
@@ -164,11 +160,15 @@ _msg_converter: Dict[Type, Any] = {
            else Pose()
        ),
        config=json.dumps(x.get("config", {})),
-        data=json.dumps(x.get("data", {})),
-        extra=json.dumps(x.get("extra", {})),
+        data=json.dumps(obtain_data_with_uuid(x)),
    ),
 }

+def obtain_data_with_uuid(x: dict):
+    data = x.get("data", {})
+    data["unilabos_uuid"] = x.get("uuid", None)
+    return data
+
 def json_or_yaml_loads(data: str) -> Any:
    try:
        return json.loads(data)
@@ -195,20 +195,15 @@ _msg_converter_back: Dict[Type, Any] = {
    Point: lambda x: Point3D(x=x.x, y=x.y, z=x.z),
    Resource: lambda x: {
        "id": x.id,
-        "uuid": x.uuid if x.uuid else None,
        "name": x.name,
        "sample_id": x.sample_id if x.sample_id else None,
-        "description": x.description if x.description else "",
        "children": list(x.children),
        "parent": x.parent if x.parent else None,
-        "parent_uuid": x.parent_uuid if x.parent_uuid else None,
        "type": x.type,
-        "class": x.klass if x.klass else "",
-        "category": x.category if x.category else "",
+        "class": "",
        "position": {"x": x.pose.position.x, "y": x.pose.position.y, "z": x.pose.position.z},
        "config": json_or_yaml_loads(x.config or "{}"),
        "data": json_or_yaml_loads(x.data or "{}"),
-        "extra": json_or_yaml_loads(x.extra or "{}"),
    },
 }

--- a/unilabos/ros/nodes/base_device_node.py
+++ b/unilabos/ros/nodes/base_device_node.py
@@ -4,6 +4,8 @@ import json
 import threading
 import time
 import traceback
+
+from unilabos.utils.tools import fast_dumps_str as _fast_dumps_str, fast_loads as _fast_loads
 from typing import (
    get_type_hints,
    TypeVar,
@@ -78,6 +80,67 @@ if TYPE_CHECKING:
 T = TypeVar("T")


+class RclpyAsyncMutex:
+    """rclpy executor 兼容的异步互斥锁
+
+    通过 executor.create_task 唤醒等待者，避免 timer 的 InvalidHandle 问题。
+    """
+
+    def __init__(self, name: str = ""):
+        self._lock = threading.Lock()
+        self._acquired = False
+        self._queue: List[Future] = []
+        self._name = name
+        self._holder: Optional[str] = None
+
+    async def acquire(self, node: "BaseROS2DeviceNode", tag: str = ""):
+        """获取锁。如果已被占用，则异步等待直到锁释放。"""
+        # t0 = time.time()
+        with self._lock:
+            # qlen = len(self._queue)
+            if not self._acquired:
+                self._acquired = True
+                self._holder = tag
+                # node.lab_logger().debug(
+                #     f"[Mutex:{self._name}] 获取锁 tag={tag} (无等待, queue=0)"
+                # )
+                return
+            waiter = Future()
+            self._queue.append(waiter)
+            # node.lab_logger().info(
+            #     f"[Mutex:{self._name}] 等待锁 tag={tag} "
+            #     f"(holder={self._holder}, queue={qlen + 1})"
+            # )
+        await waiter
+        # wait_ms = (time.time() - t0) * 1000
+        self._holder = tag
+        # node.lab_logger().info(
+        #     f"[Mutex:{self._name}] 获取锁 tag={tag} (等了 {wait_ms:.0f}ms)"
+        # )
+
+    def release(self, node: "BaseROS2DeviceNode"):
+        """释放锁，通过 executor task 唤醒下一个等待者。"""
+        with self._lock:
+            # old_holder = self._holder
+            if self._queue:
+                next_waiter = self._queue.pop(0)
+                # node.lab_logger().debug(
+                #     f"[Mutex:{self._name}] 释放锁 holder={old_holder} → 唤醒下一个 (剩余 queue={len(self._queue)})"
+                # )
+
+                async def _wake():
+                    if not next_waiter.done():
+                        next_waiter.set_result(None)
+
+                rclpy.get_global_executor().create_task(_wake())
+            else:
+                self._acquired = False
+                self._holder = None
+                # node.lab_logger().debug(
+                #     f"[Mutex:{self._name}] 释放锁 holder={old_holder} → 空闲"
+                # )
+
+
 # 在线设备注册表
 registered_devices: Dict[str, "DeviceInfoType"] = {}

@@ -355,6 +418,8 @@ class BaseROS2DeviceNode(Node, Generic[T]):
            max_workers=max(len(action_value_mappings), 1), thread_name_prefix=f"ROSDevice{self.device_id}"
        )

+        self._append_resource_lock = RclpyAsyncMutex(name=f"AR:{device_id}")
+
        # 创建资源管理客户端
        self._resource_clients: Dict[str, Client] = {
            "resource_add": self.create_client(ResourceAdd, "/resources/add", callback_group=self.callback_group),
@@ -378,15 +443,40 @@ class BaseROS2DeviceNode(Node, Generic[T]):
            return res

        async def append_resource(req: SerialCommand_Request, res: SerialCommand_Response):
+            _cmd = _fast_loads(req.command)
+            _res_name = _cmd.get("resource", [{}])
+            _res_name = (_res_name[0].get("id", "?") if isinstance(_res_name, list) and _res_name
+                         else _res_name.get("id", "?") if isinstance(_res_name, dict) else "?")
+            _ar_tag = f"{_res_name}"
+            # _t_enter = time.time()
+            # self.lab_logger().info(f"[AR:{_ar_tag}] 进入 append_resource")
+            await self._append_resource_lock.acquire(self, tag=_ar_tag)
+            # _t_locked = time.time()
+            try:
+                return await _append_resource_inner(req, res, _ar_tag)
+                # _t_done = time.time()
+                # self.lab_logger().info(
+                #     f"[AR:{_ar_tag}] 完成 "
+                #     f"等锁={(_t_locked - _t_enter) * 1000:.0f}ms "
+                #     f"执行={(_t_done - _t_locked) * 1000:.0f}ms "
+                #     f"总计={(_t_done - _t_enter) * 1000:.0f}ms"
+                # )
+            except Exception as _ex:
+                self.lab_logger().error(f"[AR:{_ar_tag}] 异常: {_ex}")
+                raise
+            finally:
+                self._append_resource_lock.release(self)
+
+        async def _append_resource_inner(req: SerialCommand_Request, res: SerialCommand_Response, _ar_tag: str = ""):
            from pylabrobot.resources.deck import Deck
            from pylabrobot.resources import Coordinate
            from pylabrobot.resources import Plate

-            # 物料传输到对应的node节点
+            # _t0 = time.time()
            client = self._resource_clients["c2s_update_resource_tree"]
            request = SerialCommand.Request()
            request2 = SerialCommand.Request()
-            command_json = json.loads(req.command)
+            command_json = _fast_loads(req.command)
            namespace = command_json["namespace"]
            bind_parent_id = command_json["bind_parent_id"]
            edge_device_id = command_json["edge_device_id"]
@@ -439,7 +529,11 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                            f"更新物料{container_instance.name}出现不支持的数据类型{type(found_resource)} {found_resource}"
                        )
            # noinspection PyUnresolvedReferences
-            request.command = json.dumps(
+            # _t1 = time.time()
+            # self.lab_logger().debug(
+            #     f"[AR:{_ar_tag}] 准备完成 PLR转换+序列化 {((_t1 - _t0) * 1000):.0f}ms, 发送首次上传..."
+            # )
+            request.command = _fast_dumps_str(
                {
                    "action": "add",
                    "data": {
@@ -450,7 +544,11 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                }
            )
            tree_response: SerialCommand.Response = await client.call_async(request)
-            uuid_maps = json.loads(tree_response.response)
+            # _t2 = time.time()
+            # self.lab_logger().debug(
+            #     f"[AR:{_ar_tag}] 首次上传完成 {((_t2 - _t1) * 1000):.0f}ms"
+            # )
+            uuid_maps = _fast_loads(tree_response.response)
            plr_instances = rts.to_plr_resources()
            for plr_instance in plr_instances:
                self.resource_tracker.loop_update_uuid(plr_instance, uuid_maps)
@@ -486,18 +584,12 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                if len(rts.root_nodes) == 1 and parent_resource is not None:
                    plr_instance = plr_instances[0]
                    if isinstance(plr_instance, Plate):
-                        empty_liquid_info_in: List[Tuple[Optional[str], float]] = [(None, 0)] * plr_instance.num_items
                        if len(ADD_LIQUID_TYPE) == 1 and len(LIQUID_VOLUME) == 1 and len(LIQUID_INPUT_SLOT) > 1:
                            ADD_LIQUID_TYPE = ADD_LIQUID_TYPE * len(LIQUID_INPUT_SLOT)
                            LIQUID_VOLUME = LIQUID_VOLUME * len(LIQUID_INPUT_SLOT)
                            self.lab_logger().warning(
                                f"增加液体资源时，数量为1，自动补全为 {len(LIQUID_INPUT_SLOT)} 个"
                            )
-                        for liquid_type, liquid_volume, liquid_input_slot in zip(
-                            ADD_LIQUID_TYPE, LIQUID_VOLUME, LIQUID_INPUT_SLOT
-                        ):
-                            empty_liquid_info_in[liquid_input_slot] = (liquid_type, liquid_volume)
-                        plr_instance.set_well_liquids(empty_liquid_info_in)
                        try:
                            # noinspection PyProtectedMember
                            keys = list(plr_instance._ordering.keys())
@@ -511,6 +603,10 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                            input_wells = []
                            for r in LIQUID_INPUT_SLOT:
                                input_wells.append(plr_instance.children[r])
+                        for input_well, liquid_type, liquid_volume, liquid_input_slot in zip(
+                            input_wells, ADD_LIQUID_TYPE, LIQUID_VOLUME, LIQUID_INPUT_SLOT
+                        ):
+                            input_well.set_liquids([(liquid_type, liquid_volume, "ul")])
                        final_response["liquid_input_resource_tree"] = ResourceTreeSet.from_plr_resources(
                            input_wells
                        ).dump()
@@ -529,12 +625,13 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                            Coordinate(location["x"], location["y"], location["z"]),
                            **other_calling_param,
                        )
-                    # 调整了液体以及Deck之后要重新Assign
                    # noinspection PyUnresolvedReferences
+                    # _t3 = time.time()
                    rts_with_parent = ResourceTreeSet.from_plr_resources([parent_resource])
+                    # _n_parent = len(rts_with_parent.all_nodes)
                    if rts_with_parent.root_nodes[0].res_content.uuid_parent is None:
                        rts_with_parent.root_nodes[0].res_content.parent_uuid = self.uuid
-                    request.command = json.dumps(
+                    request.command = _fast_dumps_str(
                        {
                            "action": "add",
                            "data": {
@@ -544,11 +641,18 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                            },
                        }
                    )
+                    # _t4 = time.time()
+                    # self.lab_logger().debug(
+                    #     f"[AR:{_ar_tag}] 二次上传序列化 {_n_parent}节点 {((_t4 - _t3) * 1000):.0f}ms, 发送中..."
+                    # )
                    tree_response: SerialCommand.Response = await client.call_async(request)
-                    uuid_maps = json.loads(tree_response.response)
+                    # _t5 = time.time()
+                    uuid_maps = _fast_loads(tree_response.response)
                    self.resource_tracker.loop_update_uuid(input_resources, uuid_maps)
-                    self._lab_logger.info(f"Resource tree added. UUID mapping: {len(uuid_maps)} nodes")
-                    # 这里created_resources不包含parent_resource
+                    # self._lab_logger.info(
+                    #     f"[AR:{_ar_tag}] 二次上传完成 HTTP={(_t5 - _t4) * 1000:.0f}ms "
+                    #     f"UUID映射={len(uuid_maps)}节点 总执行={(_t5 - _t0) * 1000:.0f}ms"
+                    # )
                # 发送给ResourceMeshManager
                action_client = ActionClient(
                    self,
@@ -685,7 +789,11 @@ class BaseROS2DeviceNode(Node, Generic[T]):
        )
        # 发送请求并等待响应
        response: SerialCommand_Response = await self._resource_clients["resource_get"].call_async(r)
+        if not response.response:
+            raise ValueError(f"查询资源 {resource_id} 失败：服务端返回空响应")
        raw_data = json.loads(response.response)
+        if not raw_data:
+            raise ValueError(f"查询资源 {resource_id} 失败：返回数据为空")

        # 转换为 PLR 资源
        tree_set = ResourceTreeSet.from_raw_dict_list(raw_data)
@@ -761,84 +869,6 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                    f"物料{plr_resource}请求挂载{tree.root_node.res_content.name}的父节点{parent_resource}[{parent_uuid}]失败！\n{traceback.format_exc()}"
                )

-    def batch_transfer_resources(
-        self,
-        transfers: List[Dict[str, Any]],
-    ) -> List["ResourcePLR"]:
-        """批量转移 PLR 资源：先全部 unassign，再全部 assign，最后一次性回调和同步
-
-        Args:
-            transfers: 转移列表，每项包含:
-                - "resource": PLR 资源对象
-                - "from_parent": 原父节点 (PLR ResourceHolder/WareHouse)
-                - "to_parent": 目标父节点
-                - "to_site": 目标 slot 名称（可选，用于 ItemizedCarrier）
-
-        Returns:
-            成功转移的目标 parent 列表
-        """
-        from pylabrobot.resources.resource import Resource as ResourcePLR
-
-        if not transfers:
-            return []
-
-        # 第一遍：校验所有物料和目标 parent 的合法性
-        for t in transfers:
-            resource = t["resource"]
-            to_parent = t["to_parent"]
-            if resource is None:
-                raise ValueError("转移列表中存在 resource=None")
-            if to_parent is None:
-                raise ValueError(f"物料 {resource} 的目标 parent 为 None")
-
-        # 第二遍：批量 unassign
-        old_parents = []
-        for t in transfers:
-            resource = t["resource"]
-            old_parent = resource.parent
-            old_parents.append(old_parent)
-            if old_parent is not None:
-                self.lab_logger().debug(f"批量 unassign: {resource.name} 从 {old_parent.name}")
-                old_parent.unassign_child_resource(resource)
-            # 从顶级资源列表中移除（避免 figure_resource 重复引用）
-            resource_id = id(resource)
-            for i, r in enumerate(self.resource_tracker.resources):
-                if id(r) == resource_id:
-                    self.resource_tracker.resources.pop(i)
-                    break
-
-        # 第三遍：批量 assign
-        parents = []
-        for t, old_parent in zip(transfers, old_parents):
-            resource = t["resource"]
-            to_parent = t["to_parent"]
-            to_site = t.get("to_site")
-            additional_params = {}
-            if to_site is not None:
-                spec = inspect.signature(to_parent.assign_child_resource)
-                if "spot" in spec.parameters:
-                    ordering_dict = getattr(to_parent, "_ordering", None)
-                    if ordering_dict and to_site in ordering_dict:
-                        additional_params["spot"] = list(ordering_dict.keys()).index(to_site)
-                    else:
-                        additional_params["spot"] = to_site
-            self.lab_logger().debug(f"批量 assign: {resource.name} → {to_parent.name} site={to_site}")
-            to_parent.assign_child_resource(resource, location=None, **additional_params)
-            parents.append(to_parent)
-
-        # 一次性触发 driver 回调
-        func = getattr(self.driver_instance, "resource_tree_batch_transfer", None)
-        if callable(func):
-            func(transfers, old_parents, parents)
-        else:
-            # 兜底：逐个调用 resource_tree_transfer
-            single_func = getattr(self.driver_instance, "resource_tree_transfer", None)
-            if callable(single_func):
-                for t, old_parent, new_parent in zip(transfers, old_parents, parents):
-                    single_func(old_parent, t["resource"], new_parent)
-
-        return parents
-
    async def s2c_resource_tree(self, req: SerialCommand_Request, res: SerialCommand_Response):
        """
        处理资源树更新请求
@@ -1212,7 +1242,8 @@ class BaseROS2DeviceNode(Node, Generic[T]):
            if uid is None:
                raise ValueError(f"目标物料{target_resource}没有unilabos_uuid属性，无法转运")
            target_uids.append(uid)
-        srv_address = f"/srv{target_device_id}/s2c_resource_tree"
+        _ns = target_device_id if target_device_id.startswith("/devices/") else f"/devices/{target_device_id.lstrip('/')}"
+        srv_address = f"/srv{_ns}/s2c_resource_tree"
        sclient = self.create_client(SerialCommand, srv_address)
        # 等待服务可用（设置超时）
        if not sclient.wait_for_service(timeout_sec=5.0):
@@ -1262,7 +1293,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                    return False
                time.sleep(0.05)
            self.lab_logger().info(f"资源本地增加到{target_device_id}结果: {response.response}")
-        return None
+        return "转运完成"

    def register_device(self):
        """向注册表中注册设备信息"""
@@ -1334,9 +1365,8 @@ class BaseROS2DeviceNode(Node, Generic[T]):
        return self._lab_logger

    def create_ros_publisher(self, attr_name, msg_type, initial_period=5.0):
-        """创建ROS发布者，仅当方法/属性有 @topic_config 装饰器时才创建。"""
-        # 检测 @topic_config 装饰器配置
-        topic_config = {}
+        """创建ROS发布者。已在 status_types 中声明的属性直接创建；@topic_config 用于覆盖默认参数。"""
+        topic_cfg = {}
        driver_class = type(self.driver_instance)

        # 区分 @property 和普通方法两种情况
@@ -1345,23 +1375,17 @@ class BaseROS2DeviceNode(Node, Generic[T]):
        )

        if is_prop:
-            # @property: 检测 fget 上的 @topic_config
            class_attr = getattr(driver_class, attr_name)
            if class_attr.fget is not None:
-                topic_config = get_topic_config(class_attr.fget)
+                topic_cfg = get_topic_config(class_attr.fget)
        else:
-            # 普通方法: 直接检测 attr_name 方法上的 @topic_config
            if hasattr(self.driver_instance, attr_name):
                method = getattr(self.driver_instance, attr_name)
                if callable(method):
-                    topic_config = get_topic_config(method)
-
-        # 没有 @topic_config 装饰器则跳过发布
-        if not topic_config:
-            return
+                    topic_cfg = get_topic_config(method)

        # 发布名称优先级: @topic_config(name=...) > get_ 前缀去除 > attr_name
-        cfg_name = topic_config.get("name")
+        cfg_name = topic_cfg.get("name")
        if cfg_name:
            publish_name = cfg_name
        elif attr_name.startswith("get_"):
@@ -1369,10 +1393,10 @@ class BaseROS2DeviceNode(Node, Generic[T]):
        else:
            publish_name = attr_name

-        # 使用装饰器配置或默认值
-        cfg_period = topic_config.get("period")
-        cfg_print = topic_config.get("print_publish")
-        cfg_qos = topic_config.get("qos")
+        # @topic_config 参数覆盖默认值
+        cfg_period = topic_cfg.get("period")
+        cfg_print = topic_cfg.get("print_publish")
+        cfg_qos = topic_cfg.get("qos")
        period: float = cfg_period if cfg_period is not None else initial_period
        print_publish: bool = cfg_print if cfg_print is not None else self._print_publish
        qos: int = cfg_qos if cfg_qos is not None else 10
@@ -1654,37 +1678,75 @@ class BaseROS2DeviceNode(Node, Generic[T]):
            feedback_msg_types = action_type.Feedback.get_fields_and_field_types()
            result_msg_types = action_type.Result.get_fields_and_field_types()

-            while future is not None and not future.done():
-                if goal_handle.is_cancel_requested:
-                    self.lab_logger().info(f"取消动作: {action_name}")
-                    future.cancel()  # 尝试取消线程池中的任务
-                    goal_handle.canceled()
-                    return action_type.Result()
+            # 低频 feedback timer（10s），不阻塞完成检测
+            _feedback_timer = None

-                self._time_spent = time.time() - time_start
-                self._time_remaining = time_overall - self._time_spent
+            def _publish_feedback():
+                if future is not None and not future.done():
+                    self._time_spent = time.time() - time_start
+                    self._time_remaining = time_overall - self._time_spent
+                    feedback_values = {}
+                    for msg_name, attr_name in action_value_mapping["feedback"].items():
+                        if hasattr(self.driver_instance, f"get_{attr_name}"):
+                            method = getattr(self.driver_instance, f"get_{attr_name}")
+                            if not asyncio.iscoroutinefunction(method):
+                                feedback_values[msg_name] = method()
+                        elif hasattr(self.driver_instance, attr_name):
+                            feedback_values[msg_name] = getattr(self.driver_instance, attr_name)
+                    if self._print_publish:
+                        self.lab_logger().info(f"反馈: {feedback_values}")
+                    feedback_msg = convert_to_ros_msg_with_mapping(
+                        ros_msg_type=action_type.Feedback(),
+                        obj=feedback_values,
+                        value_mapping=action_value_mapping["feedback"],
+                    )
+                    goal_handle.publish_feedback(feedback_msg)

-                # 发布反馈
-                feedback_values = {}
-                for msg_name, attr_name in action_value_mapping["feedback"].items():
-                    if hasattr(self.driver_instance, f"get_{attr_name}"):
-                        method = getattr(self.driver_instance, f"get_{attr_name}")
-                        if not asyncio.iscoroutinefunction(method):
-                            feedback_values[msg_name] = method()
-                    elif hasattr(self.driver_instance, attr_name):
-                        feedback_values[msg_name] = getattr(self.driver_instance, attr_name)
-
-                if self._print_publish:
-                    self.lab_logger().info(f"反馈: {feedback_values}")
-
-                feedback_msg = convert_to_ros_msg_with_mapping(
-                    ros_msg_type=action_type.Feedback(),
-                    obj=feedback_values,
-                    value_mapping=action_value_mapping["feedback"],
+            if action_value_mapping.get("feedback"):
+                _fb_interval = action_value_mapping.get("feedback_interval", 0.5)
+                _feedback_timer = self.create_timer(
+                    _fb_interval, _publish_feedback, callback_group=self.callback_group
                )

-                goal_handle.publish_feedback(feedback_msg)
-                time.sleep(0.5)
+            # 等待 action 完成
+            if future is not None:
+                if isinstance(future, Task):
+                    # rclpy Task：直接 await，完成瞬间唤醒
+                    try:
+                        _raw_result = await future
+                    except Exception as e:
+                        _raw_result = e
+                else:
+                    # concurrent.futures.Future（同步 action）：用 rclpy 兼容的轮询
+                    _poll_future = Future()
+
+                    def _on_sync_done(fut):
+                        if not _poll_future.done():
+                            _poll_future.set_result(None)
+
+                    future.add_done_callback(_on_sync_done)
+                    await _poll_future
+                    try:
+                        _raw_result = future.result()
+                    except Exception as e:
+                        _raw_result = e
+
+                # 确保 execution_error/success 被正确设置（不依赖 done callback 时序）
+                if isinstance(_raw_result, BaseException):
+                    if not execution_error:
+                        execution_error = traceback.format_exception(
+                            type(_raw_result), _raw_result, _raw_result.__traceback__
+                        )
+                        execution_error = "".join(execution_error)
+                    execution_success = False
+                    action_return_value = _raw_result
+                elif not execution_error:
+                    execution_success = True
+                    action_return_value = _raw_result
+
+            # 清理 feedback timer
+            if _feedback_timer is not None:
+                _feedback_timer.cancel()

            if future is not None and future.cancelled():
                self.lab_logger().info(f"动作 {action_name} 已取消")
@@ -1693,8 +1755,12 @@ class BaseROS2DeviceNode(Node, Generic[T]):
            # self.lab_logger().info(f"动作执行完成: {action_name}")
            del future

+            # 执行失败时跳过物料状态更新
+            if execution_error:
+                execution_success = False
+
            # 向Host更新物料当前状态
-            if action_name not in ["create_resource_detailed", "create_resource"]:
+            if not execution_error and action_name not in ["create_resource_detailed", "create_resource"]:
                for k, v in goal.get_fields_and_field_types().items():
                    if v not in ["unilabos_msgs/Resource", "sequence<unilabos_msgs/Resource>"]:
                        continue
@@ -1750,7 +1816,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):

            for attr_name in result_msg_types.keys():
                if attr_name in ["success", "reached_goal"]:
-                    setattr(result_msg, attr_name, True)
+                    setattr(result_msg, attr_name, execution_success)
                elif attr_name == "return_info":
                    setattr(
                        result_msg,
@@ -1856,7 +1922,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
            raise ValueError("至少需要提供一个 UUID")

        uuids_list = list(uuids)
-        future = self._resource_clients["c2s_update_resource_tree"].call_async(
+        future: Future = self._resource_clients["c2s_update_resource_tree"].call_async(
            SerialCommand.Request(
                command=json.dumps(
                    {
@@ -1882,6 +1948,8 @@ class BaseROS2DeviceNode(Node, Generic[T]):
            raise Exception(f"资源查询返回空结果: {uuids_list}")

        raw_data = json.loads(response.response)
+        if not raw_data:
+            raise Exception(f"资源原始查询返回空结果: {raw_data}")

        # 转换为 PLR 资源
        tree_set = ResourceTreeSet.from_raw_dict_list(raw_data)
@@ -1999,16 +2067,27 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                f"执行动作时JSON缺少function_name或function_args: {ex}\n原JSON: {string}\n{traceback.format_exc()}"
            )

-    async def _convert_resource_async(self, resource_data: Dict[str, Any]):
-        """异步转换资源数据为实例"""
-        # 使用封装的get_resource_with_dir方法获取PLR资源
-        plr_resource = await self.get_resource_with_dir(resource_ids=resource_data["id"], with_children=True)
+    async def _convert_resource_async(self, resource_data: "ResourceDictType"):
+        """异步转换 ResourceDictType 为 PLR 实例，优先用 uuid 查询"""
+        unilabos_uuid = resource_data.get("uuid")
+
+        if unilabos_uuid:
+            resource_tree = await self.get_resource([unilabos_uuid], with_children=True)
+            plr_resources = resource_tree.to_plr_resources()
+            if plr_resources:
+                plr_resource = plr_resources[0]
+            else:
+                raise ValueError(f"通过 uuid={unilabos_uuid} 查询资源为空")
+        else:
+            res_id = resource_data.get("id") or resource_data.get("name", "")
+            if not res_id:
+                raise ValueError(f"资源数据缺少 uuid 和 id: {list(resource_data.keys())}")
+            plr_resource = await self.get_resource_with_dir(resource_id=res_id, with_children=True)

        # 通过资源跟踪器获取本地实例
        res = self.resource_tracker.figure_resource(plr_resource, try_mode=True)
        if len(res) == 0:
-            # todo: 后续通过decoration来区分，减少warning
-            self.lab_logger().warning(f"资源转换未能索引到实例: {resource_data}，返回新建实例")
+            self.lab_logger().warning(f"资源转换未能索引到实例: {resource_data.get('id', '?')}，返回新建实例")
            return plr_resource
        elif len(res) == 1:
            return res[0]
--- a/unilabos/ros/nodes/presets/host_node.py
+++ b/unilabos/ros/nodes/presets/host_node.py
@@ -4,6 +4,8 @@ import threading
 import time
 import traceback
 import uuid
+
+from unilabos.utils.tools import fast_dumps_str as _fast_dumps_str, fast_loads as _fast_loads
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Optional, Dict, Any, List, ClassVar, Set, Union

@@ -618,22 +620,17 @@ class HostNode(BaseROS2DeviceNode):
                }
            )
        ]
-
        response: List[str] = await self.create_resource_detailed(
            resources, device_ids, bind_parent_id, bind_location, other_calling_param
        )

-        try:
-            assert len(response) == 1, "Create Resource应当只返回一个结果"
-            for i in response:
-                res = json.loads(i)
-                if "suc" in res:
-                    raise ValueError(res.get("error"))
-                return res
-        except Exception as ex:
-            pass
-        _n = "\n"
-        raise ValueError(f"创建资源时失败！\n{_n.join(response)}")
+        assert len(response) == 1, "Create Resource应当只返回一个结果"
+        for i in response:
+            res = json.loads(i)
+            if "suc" in res and not res["suc"]:
+                raise ValueError(res.get("error", "未知错误"))
+            return res
+        raise ValueError(f"创建资源时失败！响应为空")

    def initialize_device(self, device_id: str, device_config: ResourceDictInstance) -> None:
        """
@@ -1168,7 +1165,7 @@ class HostNode(BaseROS2DeviceNode):
                else:
                    physical_setup_graph.nodes[resource_dict["id"]]["data"].update(resource_dict.get("data", {}))

-        response.response = json.dumps(uuid_mapping) if success else "FAILED"
+        response.response = _fast_dumps_str(uuid_mapping) if success else "FAILED"
        self.lab_logger().info(f"[Host Node-Resource] Resource tree add completed, success: {success}")

    async def _resource_tree_action_get_callback(self, data: dict, response: SerialCommand_Response):  # OK
@@ -1178,6 +1175,7 @@ class HostNode(BaseROS2DeviceNode):

        resource_response = http_client.resource_tree_get(uuid_list, with_children)
        response.response = json.dumps(resource_response)
+        self.lab_logger().trace(f"[Host Node-Resource] Resource tree get request callback {response.response}")

    async def _resource_tree_action_remove_callback(self, data: dict, response: SerialCommand_Response):
        """
@@ -1230,9 +1228,26 @@ class HostNode(BaseROS2DeviceNode):
        """
        try:
            # 解析请求数据
-            data = json.loads(request.command)
+            data = _fast_loads(request.command)
            action = data["action"]
-            self.lab_logger().info(f"[Host Node-Resource] Resource tree {action} request received")
+            inner = data.get("data", {})
+            if action == "add":
+                mount_uuid = inner.get("mount_uuid", "?")[:8] if isinstance(inner, dict) else "?"
+                tree_data = inner.get("data", []) if isinstance(inner, dict) else inner
+                node_count = len(tree_data) if isinstance(tree_data, list) else "?"
+                source = f"mount={mount_uuid}.. nodes≈{node_count}"
+            elif action in ("get", "remove"):
+                uid_list = inner.get("data", inner) if isinstance(inner, dict) else inner
+                source = f"uuids={len(uid_list) if isinstance(uid_list, list) else '?'}"
+            elif action == "update":
+                tree_data = inner.get("data", []) if isinstance(inner, dict) else inner
+                node_count = len(tree_data) if isinstance(tree_data, list) else "?"
+                source = f"nodes≈{node_count}"
+            else:
+                source = ""
+            self.lab_logger().info(
+                f"[Host Node-Resource] Resource tree {action} request received ({source})"
+            )
            data = data["data"]
            if action == "add":
                await self._resource_tree_action_add_callback(data, response)
@@ -1632,6 +1647,7 @@ class HostNode(BaseROS2DeviceNode):
    def manual_confirm(self, timeout_seconds: int, assignee_user_ids: list[str], **kwargs) -> dict:
        """
        timeout_seconds: 超时时间（秒），默认3600秒
+        修改的结果无效，是只读的
        """
        return kwargs

--- a/unilabos/ros/nodes/presets/workstation.py
+++ b/unilabos/ros/nodes/presets/workstation.py
@@ -340,17 +340,8 @@ class ROS2WorkstationNode(BaseROS2DeviceNode):
                            )  # type: ignore
                            raw_data = json.loads(response.response)
                            tree_set = ResourceTreeSet.from_raw_dict_list(raw_data)
-
-                            # 传递 ResourceDictInstance（保留树结构），不再调用 dump() 扁平化
-                            if v == "unilabos_msgs/Resource":
-                                # 单个资源：取第一棵树的根节点
-                                root_instance = tree_set.trees[0].root_node if tree_set.trees else None
-                                protocol_kwargs[k] = root_instance.get_plr_nested_dict() if root_instance else protocol_kwargs[k]
-                            else:
-                                # 多个资源：取每棵树的根节点
-                                protocol_kwargs[k] = [
-                                    tree.root_node.get_plr_nested_dict() for tree in tree_set.trees
-                                ]
+                            target = tree_set.dump()
+                            protocol_kwargs[k] = target[0][0] if v == "unilabos_msgs/Resource" else target
                        except Exception as ex:
                            self.lab_logger().error(f"查询资源失败: {k}, 错误: {ex}\n{traceback.format_exc()}")
                            raise
--- a/unilabos/test/experiments/virtual_bench.json
+++ b/unilabos/test/experiments/virtual_bench.json
@@ -22,6 +22,447 @@
                "arm_state": "idle",
                "message": "工作台就绪"
            }
+        },
+        {
+            "id": "PRCXI",
+            "name": "PRCXI",
+            "type": "device",
+            "class": "liquid_handler.prcxi",
+            "parent": "",
+            "pose": {
+                "size": {
+                    "width": 562,
+                    "height": 394,
+                    "depth": 0
+                }
+            },
+            "config": {
+                "axis": "Left",
+                "deck": {
+                    "_resource_type": "unilabos.devices.liquid_handling.prcxi.prcxi:PRCXI9300Deck",
+                    "_resource_child_name": "PRCXI_Deck"
+                },
+                "host": "10.20.30.184",
+                "port": 9999,
+                "debug": true,
+                "setup": true,
+                "is_9320": true,
+                "timeout": 10,
+                "matrix_id": "5de524d0-3f95-406c-86dd-f83626ebc7cb",
+                "simulator": true,
+                "channel_num": 2
+            },
+            "data": {
+                "reset_ok": true
+            },
+            "schema": {},
+            "description": "",
+            "model": null,
+            "position": {
+                "x": 0,
+                "y": 240,
+                "z": 0
+            }
+        },
+        {
+            "id": "PRCXI_Deck",
+            "name": "PRCXI_Deck",
+            "children": [],
+            "parent": "PRCXI",
+            "type": "deck",
+            "class": "",
+            "position": {
+                "x": 10,
+                "y": 10,
+                "z": 0
+            },
+            "config": {
+                "type": "PRCXI9300Deck",
+                "size_x": 542,
+                "size_y": 374,
+                "size_z": 0,
+                "rotation": {
+                    "x": 0,
+                    "y": 0,
+                    "z": 0,
+                    "type": "Rotation"
+                },
+                "category": "deck",
+                "barcode": null,
+                "preferred_pickup_location": null,
+                "sites": [
+                    {
+                        "label": "T1",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 0,
+                            "y": 0,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "container",
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T2",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 138,
+                            "y": 0,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T3",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 276,
+                            "y": 0,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T4",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 414,
+                            "y": 0,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T5",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 0,
+                            "y": 96,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T6",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 138,
+                            "y": 96,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T7",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 276,
+                            "y": 96,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T8",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 414,
+                            "y": 96,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T9",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 0,
+                            "y": 192,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T10",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 138,
+                            "y": 192,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T11",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 276,
+                            "y": 192,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T12",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 414,
+                            "y": 192,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T13",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 0,
+                            "y": 288,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T14",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 138,
+                            "y": 288,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T15",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 276,
+                            "y": 288,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    },
+                    {
+                        "label": "T16",
+                        "visible": true,
+                        "occupied_by": null,
+                        "position": {
+                            "x": 414,
+                            "y": 288,
+                            "z": 0
+                        },
+                        "size": {
+                            "width": 128.0,
+                            "height": 86,
+                            "depth": 0
+                        },
+                        "content_type": [
+                            "plate",
+                            "tip_rack",
+                            "plates",
+                            "tip_racks",
+                            "tube_rack",
+                            "adaptor"
+                        ]
+                    }
+                ]
+            },
+            "data": {}
        }
    ],
    "links": []
--- a/unilabos/test/experiments/workshop.json
+++ b/unilabos/test/experiments/workshop.json
@@ -577,38 +577,17 @@
        {
            "id": "AGV",
            "name": "AGV",
-            "children": ["zhixing_agv", "zhixing_ur_arm", "agv_platform"],
+            "children": ["zhixing_agv", "zhixing_ur_arm"],
            "parent": null,
            "type": "device",
-            "class": "agv_transport_station",
+            "class": "workstation",
            "position": {
                "x": 698.1111111111111,
                "y": 478,
                "z": 0
            },
            "config": {
-                "protocol_type": ["AGVTransferProtocol", "BatchTransferProtocol"],
-                "device_roles": {
-                    "navigator": "zhixing_agv",
-                    "arm": "zhixing_ur_arm"
-                },
-                "route_table": {
-                    "AiChemEcoHiWo->Revvity": {
-                        "nav_command": "{\"target\": \"LM14\"}",
-                        "arm_pick": "{\"task_name\": \"camera/250111_biaozhi.urp\"}",
-                        "arm_place": "{\"task_name\": \"camera/250111_put_board.urp\"}"
-                    },
-                    "Revvity->HPLC": {
-                        "nav_command": "{\"target\": \"LM13\"}",
-                        "arm_pick": "{\"task_name\": \"camera/250111_lfp.urp\"}",
-                        "arm_place": "{\"task_name\": \"camera/250111_hplc.urp\"}"
-                    },
-                    "HPLC->Revvity": {
-                        "nav_command": "{\"target\": \"LM13\"}",
-                        "arm_pick": "{\"task_name\": \"camera/250111_hplc.urp\"}",
-                        "arm_place": "{\"task_name\": \"camera/250111_lfp.urp\"}"
-                    }
-                }
+                "protocol_type": ["AGVTransferProtocol"]
            },
            "data": {
            }
@@ -648,27 +627,6 @@
            },
            "data": {
            }
-        },
-        {
-            "id": "agv_platform",
-            "name": "agv_platform",
-            "children": [],
-            "parent": "AGV",
-            "type": "warehouse",
-            "class": "",
-            "position": {
-                "x": 698.1111111111111,
-                "y": 478,
-                "z": 0
-            },
-            "config": {
-                "name": "agv_platform",
-                "num_items_x": 2,
-                "num_items_y": 1,
-                "num_items_z": 1
-            },
-            "data": {
-            }
        }
    ],
    "links": [
--- a/unilabos/utils/tools.py
+++ b/unilabos/utils/tools.py
@@ -17,6 +17,14 @@ try:
            default=json_default,
        )

+    def fast_loads(data) -> dict:
+        """JSON 反序列化，优先使用 orjson。接受 str / bytes。"""
+        return orjson.loads(data)
+
+    def fast_dumps_str(obj, **kwargs) -> str:
+        """JSON 序列化为 str，优先使用 orjson。用于需要 str 而非 bytes 的场景（如 ROS msg）。"""
+        return orjson.dumps(obj, option=orjson.OPT_NON_STR_KEYS, default=json_default).decode("utf-8")
+
    def normalize_json(info: dict) -> dict:
        """经 JSON 序列化/反序列化一轮来清理非标准类型。"""
        return orjson.loads(orjson.dumps(info, default=json_default))
@@ -29,6 +37,14 @@ except ImportError:
    def fast_dumps_pretty(obj, **kwargs) -> bytes:  # type: ignore[misc]
        return json.dumps(obj, indent=2, ensure_ascii=False, cls=TypeEncoder).encode("utf-8")

+    def fast_loads(data) -> dict:  # type: ignore[misc]
+        if isinstance(data, bytes):
+            data = data.decode("utf-8")
+        return json.loads(data)
+
+    def fast_dumps_str(obj, **kwargs) -> str:  # type: ignore[misc]
+        return json.dumps(obj, ensure_ascii=False, cls=TypeEncoder)
+
    def normalize_json(info: dict) -> dict:  # type: ignore[misc]
        return json.loads(json.dumps(info, ensure_ascii=False, cls=TypeEncoder))

--- a/unilabos/workflow/init.py
+++ b/unilabos/workflow/init.py
--- a/unilabos/workflow/common.py
+++ b/unilabos/workflow/common.py
@@ -346,7 +346,7 @@ def refactor_data(
            "template_name": template_name,
            "resource_name": resource_name,
            "description": step.get("description", step.get("purpose", f"{operation} operation")),
-            "lab_node_type": "Device",
+            "lab_node_type": "ILab",
            "param": step.get("parameters", step.get("action_args", {})),
            "footer": f"{template_name}-{resource_name}",
        }
--- a/unilabos/workflow/from_python_script.py
+++ b/unilabos/workflow/from_python_script.py
@@ -1,241 +0,0 @@
-import ast
-import json
-from typing import Dict, List, Any, Tuple, Optional
-
-from .common import WorkflowGraph, RegistryAdapter
-
-Json = Dict[str, Any]
-
-# ---------------- Converter ----------------
-
-class DeviceMethodConverter:
-    """
-    - 字段统一：resource_name（原 device_class）、template_name（原 action_key）
-    - params 单层；inputs 使用 'params.' 前缀
-    - SimpleGraph.add_workflow_node 负责变量连线与边
-    """
-    def __init__(self, device_registry: Optional[Dict[str, Any]] = None):
-        self.graph = WorkflowGraph()
-        self.variable_sources: Dict[str, Dict[str, Any]] = {}        # var -> {node_id, output_name}
-        self.instance_to_resource: Dict[str, Optional[str]] = {}     # 实例名 -> resource_name
-        self.node_id_counter: int = 0
-        self.registry = RegistryAdapter(device_registry or {})
-
-    # ---- helpers ----
-    def _new_node_id(self) -> int:
-        nid = self.node_id_counter
-        self.node_id_counter += 1
-        return nid
-
-    def _assign_targets(self, targets) -> List[str]:
-        names: List[str] = []
-        import ast
-        if isinstance(targets, ast.Tuple):
-            for elt in targets.elts:
-                if isinstance(elt, ast.Name):
-                    names.append(elt.id)
-        elif isinstance(targets, ast.Name):
-            names.append(targets.id)
-        return names
-
-    def _extract_device_instantiation(self, node) -> Optional[Tuple[str, str]]:
-        import ast
-        if not isinstance(node.value, ast.Call):
-            return None
-        callee = node.value.func
-        if isinstance(callee, ast.Name):
-            class_name = callee.id
-        elif isinstance(callee, ast.Attribute) and isinstance(callee.value, ast.Name):
-            class_name = callee.attr
-        else:
-            return None
-        if isinstance(node.targets[0], ast.Name):
-            instance = node.targets[0].id
-            return instance, class_name
-        return None
-
-    def _extract_call(self, call) -> Tuple[str, str, Dict[str, Any], str]:
-        import ast
-        owner_name, method_name, call_kind = "", "", "func"
-        if isinstance(call.func, ast.Attribute):
-            method_name = call.func.attr
-            if isinstance(call.func.value, ast.Name):
-                owner_name = call.func.value.id
-                call_kind = "instance" if owner_name in self.instance_to_resource else "class_or_module"
-            elif isinstance(call.func.value, ast.Attribute) and isinstance(call.func.value.value, ast.Name):
-                owner_name = call.func.value.attr
-                call_kind = "class_or_module"
-        elif isinstance(call.func, ast.Name):
-            method_name = call.func.id
-            call_kind = "func"
-
-        def pack(node):
-            if isinstance(node, ast.Name):
-                return {"type": "variable", "value": node.id}
-            if isinstance(node, ast.Constant):
-                return {"type": "constant", "value": node.value}
-            if isinstance(node, ast.Dict):
-                return {"type": "dict", "value": self._parse_dict(node)}
-            if isinstance(node, ast.List):
-                return {"type": "list", "value": self._parse_list(node)}
-            return {"type": "raw", "value": ast.unparse(node) if hasattr(ast, "unparse") else str(node)}
-
-        args: Dict[str, Any] = {}
-        pos: List[Any] = []
-        for a in call.args:
-            pos.append(pack(a))
-        for kw in call.keywords:
-            args[kw.arg] = pack(kw.value)
-        if pos:
-            args["_positional"] = pos
-        return owner_name, method_name, args, call_kind
-
-    def _parse_dict(self, node) -> Dict[str, Any]:
-        import ast
-        out: Dict[str, Any] = {}
-        for k, v in zip(node.keys, node.values):
-            if isinstance(k, ast.Constant):
-                key = str(k.value)
-                if isinstance(v, ast.Name):
-                    out[key] = f"var:{v.id}"
-                elif isinstance(v, ast.Constant):
-                    out[key] = v.value
-                elif isinstance(v, ast.Dict):
-                    out[key] = self._parse_dict(v)
-                elif isinstance(v, ast.List):
-                    out[key] = self._parse_list(v)
-        return out
-
-    def _parse_list(self, node) -> List[Any]:
-        import ast
-        out: List[Any] = []
-        for elt in node.elts:
-            if isinstance(elt, ast.Name):
-                out.append(f"var:{elt.id}")
-            elif isinstance(elt, ast.Constant):
-                out.append(elt.value)
-            elif isinstance(elt, ast.Dict):
-                out.append(self._parse_dict(elt))
-            elif isinstance(elt, ast.List):
-                out.append(self._parse_list(elt))
-        return out
-
-    def _normalize_var_tokens(self, x: Any) -> Any:
-        if isinstance(x, str) and x.startswith("var:"):
-            return {"__var__": x[4:]}
-        if isinstance(x, list):
-            return [self._normalize_var_tokens(i) for i in x]
-        if isinstance(x, dict):
-            return {k: self._normalize_var_tokens(v) for k, v in x.items()}
-        return x
-
-    def _make_params_payload(self, resource_name: Optional[str], template_name: str, call_args: Dict[str, Any]) -> Dict[str, Any]:
-        input_keys = self.registry.get_action_input_keys(resource_name, template_name) if resource_name else []
-        defaults = self.registry.get_action_goal_default(resource_name, template_name) if resource_name else {}
-        params: Dict[str, Any] = dict(defaults)
-
-        def unpack(p):
-            t, v = p.get("type"), p.get("value")
-            if t == "variable":
-                return {"__var__": v}
-            if t == "dict":
-                return self._normalize_var_tokens(v)
-            if t == "list":
-                return self._normalize_var_tokens(v)
-            return v
-
-        for k, p in call_args.items():
-            if k == "_positional":
-                continue
-            params[k] = unpack(p)
-
-        pos = call_args.get("_positional", [])
-        if pos:
-            if input_keys:
-                for i, p in enumerate(pos):
-                    if i >= len(input_keys):
-                        break
-                    name = input_keys[i]
-                    if name in params:
-                        continue
-                    params[name] = unpack(p)
-            else:
-                for i, p in enumerate(pos):
-                    params[f"arg_{i}"] = unpack(p)
-        return params
-
-    # ---- handlers ----
-    def _on_assign(self, stmt):
-        import ast
-        inst = self._extract_device_instantiation(stmt)
-        if inst:
-            instance, code_class = inst
-            resource_name = self.registry.resolve_resource_by_classname(code_class)
-            self.instance_to_resource[instance] = resource_name
-            return
-
-        if isinstance(stmt.value, ast.Call):
-            owner, method, call_args, kind = self._extract_call(stmt.value)
-            if kind == "instance":
-                device_key = owner
-                resource_name = self.instance_to_resource.get(owner)
-            else:
-                device_key = owner
-                resource_name = self.registry.resolve_resource_by_classname(owner)
-
-            module = self.registry.get_device_module(resource_name)
-            params = self._make_params_payload(resource_name, method, call_args)
-
-            nid = self._new_node_id()
-            self.graph.add_workflow_node(
-                nid,
-                device_key=device_key,
-                resource_name=resource_name,      # ✅
-                module=module,
-                template_name=method,             # ✅
-                params=params,
-                variable_sources=self.variable_sources,
-                add_ready_if_no_vars=True,
-                prev_node_id=(nid - 1) if nid > 0 else None,
-            )
-
-            out_vars = self._assign_targets(stmt.targets[0])
-            for var in out_vars:
-                self.variable_sources[var] = {"node_id": nid, "output_name": "result"}
-
-    def _on_expr(self, stmt):
-        import ast
-        if not isinstance(stmt.value, ast.Call):
-            return
-        owner, method, call_args, kind = self._extract_call(stmt.value)
-        if kind == "instance":
-            device_key = owner
-            resource_name = self.instance_to_resource.get(owner)
-        else:
-            device_key = owner
-            resource_name = self.registry.resolve_resource_by_classname(owner)
-
-        module = self.registry.get_device_module(resource_name)
-        params = self._make_params_payload(resource_name, method, call_args)
-
-        nid = self._new_node_id()
-        self.graph.add_workflow_node(
-            nid,
-            device_key=device_key,
-            resource_name=resource_name,      # ✅
-            module=module,
-            template_name=method,             # ✅
-            params=params,
-            variable_sources=self.variable_sources,
-            add_ready_if_no_vars=True,
-            prev_node_id=(nid - 1) if nid > 0 else None,
-        )
-
-    def convert(self, python_code: str):
-        tree = ast.parse(python_code)
-        for stmt in tree.body:
-            if isinstance(stmt, ast.Assign):
-                self._on_assign(stmt)
-            elif isinstance(stmt, ast.Expr):
-                self._on_expr(stmt)
-        return self
--- a/unilabos/workflow/from_xdl.py
+++ b/unilabos/workflow/from_xdl.py
@@ -1,131 +0,0 @@
-from typing import List, Any, Dict
-import xml.etree.ElementTree as ET
-
-
-def convert_to_type(val: str) -> Any:
-    """将字符串值转换为适当的数据类型"""
-    if val == "True":
-        return True
-    if val == "False":
-        return False
-    if val == "?":
-        return None
-    if val.endswith(" g"):
-        return float(val.split(" ")[0])
-    if val.endswith("mg"):
-        return float(val.split("mg")[0])
-    elif val.endswith("mmol"):
-        return float(val.split("mmol")[0]) / 1000
-    elif val.endswith("mol"):
-        return float(val.split("mol")[0])
-    elif val.endswith("ml"):
-        return float(val.split("ml")[0])
-    elif val.endswith("RPM"):
-        return float(val.split("RPM")[0])
-    elif val.endswith(" °C"):
-        return float(val.split(" ")[0])
-    elif val.endswith(" %"):
-        return float(val.split(" ")[0])
-    return val
-
-
-def flatten_xdl_procedure(procedure_elem: ET.Element) -> List[ET.Element]:
-    """展平嵌套的XDL程序结构"""
-    flattened_operations = []
-    TEMP_UNSUPPORTED_PROTOCOL = ["Purge", "Wait", "Stir", "ResetHandling"]
-
-    def extract_operations(element: ET.Element):
-        if element.tag not in ["Prep", "Reaction", "Workup", "Purification", "Procedure"]:
-            if element.tag not in TEMP_UNSUPPORTED_PROTOCOL:
-                flattened_operations.append(element)
-
-        for child in element:
-            extract_operations(child)
-
-    for child in procedure_elem:
-        extract_operations(child)
-
-    return flattened_operations
-
-
-def parse_xdl_content(xdl_content: str) -> tuple:
-    """解析XDL内容"""
-    try:
-        xdl_content_cleaned = "".join(c for c in xdl_content if c.isprintable())
-        root = ET.fromstring(xdl_content_cleaned)
-
-        synthesis_elem = root.find("Synthesis")
-        if synthesis_elem is None:
-            return None, None, None
-
-        # 解析硬件组件
-        hardware_elem = synthesis_elem.find("Hardware")
-        hardware = []
-        if hardware_elem is not None:
-            hardware = [{"id": c.get("id"), "type": c.get("type")} for c in hardware_elem.findall("Component")]
-
-        # 解析试剂
-        reagents_elem = synthesis_elem.find("Reagents")
-        reagents = []
-        if reagents_elem is not None:
-            reagents = [{"name": r.get("name"), "role": r.get("role", "")} for r in reagents_elem.findall("Reagent")]
-
-        # 解析程序
-        procedure_elem = synthesis_elem.find("Procedure")
-        if procedure_elem is None:
-            return None, None, None
-
-        flattened_operations = flatten_xdl_procedure(procedure_elem)
-        return hardware, reagents, flattened_operations
-
-    except ET.ParseError as e:
-        raise ValueError(f"Invalid XDL format: {e}")
-
-
-def convert_xdl_to_dict(xdl_content: str) -> Dict[str, Any]:
-    """
-    将XDL XML格式转换为标准的字典格式
-
-    Args:
-        xdl_content: XDL XML内容
-
-    Returns:
-        转换结果，包含步骤和器材信息
-    """
-    try:
-        hardware, reagents, flattened_operations = parse_xdl_content(xdl_content)
-        if hardware is None:
-            return {"error": "Failed to parse XDL content", "success": False}
-
-        # 将XDL元素转换为字典格式
-        steps_data = []
-        for elem in flattened_operations:
-            # 转换参数类型
-            parameters = {}
-            for key, val in elem.attrib.items():
-                converted_val = convert_to_type(val)
-                if converted_val is not None:
-                    parameters[key] = converted_val
-
-            step_dict = {
-                "operation": elem.tag,
-                "parameters": parameters,
-                "description": elem.get("purpose", f"Operation: {elem.tag}"),
-            }
-            steps_data.append(step_dict)
-
-        # 合并硬件和试剂为统一的labware_info格式
-        labware_data = []
-        labware_data.extend({"id": hw["id"], "type": "hardware", **hw} for hw in hardware)
-        labware_data.extend({"name": reagent["name"], "type": "reagent", **reagent} for reagent in reagents)
-
-        return {
-            "success": True,
-            "steps": steps_data,
-            "labware": labware_data,
-            "message": f"Successfully converted XDL to dict format. Found {len(steps_data)} steps and {len(labware_data)} labware items.",
-        }
-
-    except Exception as e:
-        error_msg = f"XDL conversion failed: {str(e)}"
-        return {"error": error_msg, "success": False}
--- a/unilabos_msgs/CMakeLists.txt
+++ b/unilabos_msgs/CMakeLists.txt
@@ -96,7 +96,6 @@ set(action_files

  "action/WorkStationRun.action"
  "action/AGVTransfer.action"
-  "action/BatchTransfer.action"

  "action/DispenStationSolnPrep.action"
  "action/DispenStationVialFeed.action"
--- a/Show More
+++ b/Show More