Version 0.10.1 (#66)

* add biomek.py demo implementation

* 更新LiquidHandlerBiomek类，添加资源创建功能，优化协议创建方法，修复部分代码格式问题，更新YAML配置以支持新功能。

* Test

* fix biomek success type

* Convert LH action to biomek.

* Update biomek.py

* 注册表上报handle和schema (param input)

* 修复biomek缺少的字段

* delete 's'

* Remove warnings

* Update biomek.py

* Biomek test

* Update biomek.py

* 新增transfer_biomek的msg

* New transfer_biomek

* Updated transfer_biomek

* 更新transfer_biomek的msg

* 更新transfer_biomek的msg

* 支持Biomek创建

* new action

* fix key name typo

* New parameter for biomek to run.

* Refine

* Update

* new actions

* new actions

* 1

* registry

* fix biomek startup
add action handles

* fix handles not as default entry

* biomek_test.py

biomek_test.py是最新的版本，运行它会生成complete_biomek_protocol.json

* Update biomek.py

* biomek_test.py

* fix liquid_handler.biomek handles

* host node新增resource add时间统计
create_resource新增handle
bump version to 0.9.2

* 修正物料上传时间
改用biomek_test
增加ResultInfoEncoder
支持返回结果上传

* 正确发送return_info结果

* 同步执行状态信息

* 取消raiseValueError提示

* Update biomek_test.py

* 0608 DONE

* 同步了Biomek.py 现在应可用

* biomek switch back to non-test

* temp disable initialize resource

* 37-biomek-i5i7 (#40)

* add biomek.py demo implementation

* 更新LiquidHandlerBiomek类，添加资源创建功能，优化协议创建方法，修复部分代码格式问题，更新YAML配置以支持新功能。

* Test

* fix biomek success type

* Convert LH action to biomek.

* Update biomek.py

* 注册表上报handle和schema (param input)

* 修复biomek缺少的字段

* delete 's'

* Remove warnings

* Update biomek.py

* Biomek test

* Update biomek.py

* 新增transfer_biomek的msg

* New transfer_biomek

* Updated transfer_biomek

* 更新transfer_biomek的msg

* 更新transfer_biomek的msg

* 支持Biomek创建

* new action

* fix key name typo

* New parameter for biomek to run.

* Refine

* Update

* new actions

* new actions

* 1

* registry

* fix biomek startup
add action handles

* fix handles not as default entry

* biomek_test.py

biomek_test.py是最新的版本，运行它会生成complete_biomek_protocol.json

* Update biomek.py

* biomek_test.py

* fix liquid_handler.biomek handles

* host node新增resource add时间统计
create_resource新增handle
bump version to 0.9.2

* 修正物料上传时间
改用biomek_test
增加ResultInfoEncoder
支持返回结果上传

* 正确发送return_info结果

* 同步执行状态信息

* 取消raiseValueError提示

* Update biomek_test.py

* 0608 DONE

* 同步了Biomek.py 现在应可用

* biomek switch back to non-test

* temp disable initialize resource

* Refine biomek

* Refine copy issue

* Refine

---------

Co-authored-by: Junhan Chang <changjh@pku.edu.cn>
Co-authored-by: Guangxin Zhang <guangxin.zhang.bio@gmail.com>
Co-authored-by: qxw138 <qxw@stu.pku.edu.cn>

* Device visualization (#39)

* Update README and MQTTClient for installation instructions and code improvements

* feat: 支持local_config启动
add: 增加对crt path的说明，为传入config.py的相对路径
move: web component

* add: registry description

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* feat: node_info_update srv
fix: OTDeck cant create

* close #12
feat: slave node registry

* feat: show machine name
fix: host node registry not uploaded

* feat: add hplc registry

* feat: add hplc registry

* fix: hplc status typo

* fix: devices/

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* fix: device.class possible null

* fix: HPLC additions with online service

* fix: slave mode spin not working

* fix: slave mode spin not working

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* feat: 多ProtocolNode 允许子设备ID相同
feat: 上报发现的ActionClient
feat: Host重启动，通过discover机制要求slaveNode重新注册，实现信息及时上报

* feat: 支持env设置config

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* Device visualization (#14)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: missing hostname in devices_names
fix: upload_file for model file

* fix: missing paho-mqtt package
bump version to 0.9.0

* fix startup
add ResourceCreateFromOuter.action

* fix type hint

* update actions

* update actions

* host node add_resource_from_outer
fix cmake list

* pass device config to device class

* add: bind_parent_ids to resource create action
fix: message convert string

* fix: host node should not be re_discovered

* feat: resource tracker support dict

* feat: add more necessary params

* feat: fix boolean null in registry action data

* feat: add outer resource

* 编写mesh添加action

* feat: append resource

* add action

* feat: vis 2d for plr

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

* Device visualization (#22)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* 编写mesh添加action

* add action

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: multi channel

* fix: aspirate

* fix: aspirate

* fix: aspirate

* fix: aspirate

* 提交

* fix: jobadd

* fix: jobadd

* fix: msg converter

* tijiao

* add resource creat easy action

* identify debug msg

* mq client id

* 提取lh的joint发布

* unify liquid_handler definition

* 修改物料跟随与物料添加逻辑

修改物料跟随与物料添加逻辑
将joint_publisher类移出lh的backends，但仍需要对lh的backends进行一些改写

* Revert "修改物料跟随与物料添加逻辑"

This reverts commit 498c997ad7.

* Reapply "修改物料跟随与物料添加逻辑"

This reverts commit 3a60d2ae81.

* Revert "Merge remote-tracking branch 'upstream/dev' into device_visualization"

This reverts commit fa727220af, reversing
changes made to 498c997ad7.

* 修改物料放下时的方法，如果选择

修改物料放下时的方法，
如果选择drop_trash，则删除物料显示
如果选择drop，则让其解除连接

* add biomek.py demo implementation

* 更新LiquidHandlerBiomek类，添加资源创建功能，优化协议创建方法，修复部分代码格式问题，更新YAML配置以支持新功能。

* Test

* fix biomek success type

* Convert LH action to biomek.

* Update biomek.py

* 注册表上报handle和schema (param input)

* 修复biomek缺少的字段

* delete 's'

* Remove warnings

* Update biomek.py

* Biomek test

* Update biomek.py

* 新增transfer_biomek的msg

* New transfer_biomek

* Updated transfer_biomek

* 更新transfer_biomek的msg

* 更新transfer_biomek的msg

* 支持Biomek创建

* new action

* fix key name typo

* New parameter for biomek to run.

* Refine

* Update

* new actions

* new actions

* 1

* registry

* fix biomek startup
add action handles

* fix handles not as default entry

* unilab添加moveit启动

1,整合所有moveit节点到一个move_group中，并整合所有的controller依次激活
2,添加pymoveit2的节点，使用json可直接启动
3,修改机械臂规划方式，添加约束，让冗余关节不会进行过多移动

* biomek_test.py

biomek_test.py是最新的版本，运行它会生成complete_biomek_protocol.json

* Update biomek.py

* biomek_test.py

* fix liquid_handler.biomek handles

* 修改物体attach时，多次赋值当前时间导致卡顿问题，

* Revert "修改物体attach时，多次赋值当前时间导致卡顿问题，"

This reverts commit 56d45b94f5.

* Reapply "修改物体attach时，多次赋值当前时间导致卡顿问题，"

This reverts commit 07d9db20c3.

* 添加缺少物料："plate_well_G12",

* host node新增resource add时间统计
create_resource新增handle
bump version to 0.9.2

* 修正物料上传时间
改用biomek_test
增加ResultInfoEncoder
支持返回结果上传

* 正确发送return_info结果

* 同步执行状态信息

* 取消raiseValueError提示

* Update biomek_test.py

* 0608 DONE

* 同步了Biomek.py 现在应可用

* biomek switch back to non-test

* temp disable initialize resource

* add

* fix tip resource data

* liquid states

* change to debug level

* Revert "change to debug level"

This reverts commit 5d9953c3e5.

* Reapply "change to debug level"

This reverts commit 2487bb6ffc.

* fix tip resource data

* add full device

* add moveit yaml

* 修复moveit
增加post_init阶段，给予ros_node反向

* remove necessary node

* fix moveit action client

* remove necessary imports

* Update moveit_interface.py

* fix handler_key uppercase

* json add liquids

* fix setup

* add

* change to "sources" and "targets" for lh

* bump version

* remove parent's parent link

---------

Co-authored-by: Harvey Que <Q-Query@outlook.com>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>
Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: Junhan Chang <changjh@pku.edu.cn>
Co-authored-by: Guangxin Zhang <guangxin.zhang.bio@gmail.com>
Co-authored-by: qxw138 <qxw@stu.pku.edu.cn>

* Device visualization (#41)

* Update README and MQTTClient for installation instructions and code improvements

* feat: 支持local_config启动
add: 增加对crt path的说明，为传入config.py的相对路径
move: web component

* add: registry description

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* feat: node_info_update srv
fix: OTDeck cant create

* close #12
feat: slave node registry

* feat: show machine name
fix: host node registry not uploaded

* feat: add hplc registry

* feat: add hplc registry

* fix: hplc status typo

* fix: devices/

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* fix: device.class possible null

* fix: HPLC additions with online service

* fix: slave mode spin not working

* fix: slave mode spin not working

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* feat: 多ProtocolNode 允许子设备ID相同
feat: 上报发现的ActionClient
feat: Host重启动，通过discover机制要求slaveNode重新注册，实现信息及时上报

* feat: 支持env设置config

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* Device visualization (#14)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: missing hostname in devices_names
fix: upload_file for model file

* fix: missing paho-mqtt package
bump version to 0.9.0

* fix startup
add ResourceCreateFromOuter.action

* fix type hint

* update actions

* update actions

* host node add_resource_from_outer
fix cmake list

* pass device config to device class

* add: bind_parent_ids to resource create action
fix: message convert string

* fix: host node should not be re_discovered

* feat: resource tracker support dict

* feat: add more necessary params

* feat: fix boolean null in registry action data

* feat: add outer resource

* 编写mesh添加action

* feat: append resource

* add action

* feat: vis 2d for plr

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

* Device visualization (#22)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* 编写mesh添加action

* add action

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: multi channel

* fix: aspirate

* fix: aspirate

* fix: aspirate

* fix: aspirate

* 提交

* fix: jobadd

* fix: jobadd

* fix: msg converter

* tijiao

* add resource creat easy action

* identify debug msg

* mq client id

* 提取lh的joint发布

* unify liquid_handler definition

* 修改物料跟随与物料添加逻辑

修改物料跟随与物料添加逻辑
将joint_publisher类移出lh的backends，但仍需要对lh的backends进行一些改写

* Revert "修改物料跟随与物料添加逻辑"

This reverts commit 498c997ad7.

* Reapply "修改物料跟随与物料添加逻辑"

This reverts commit 3a60d2ae81.

* Revert "Merge remote-tracking branch 'upstream/dev' into device_visualization"

This reverts commit fa727220af, reversing
changes made to 498c997ad7.

* 修改物料放下时的方法，如果选择

修改物料放下时的方法，
如果选择drop_trash，则删除物料显示
如果选择drop，则让其解除连接

* add biomek.py demo implementation

* 更新LiquidHandlerBiomek类，添加资源创建功能，优化协议创建方法，修复部分代码格式问题，更新YAML配置以支持新功能。

* Test

* fix biomek success type

* Convert LH action to biomek.

* Update biomek.py

* 注册表上报handle和schema (param input)

* 修复biomek缺少的字段

* delete 's'

* Remove warnings

* Update biomek.py

* Biomek test

* Update biomek.py

* 新增transfer_biomek的msg

* New transfer_biomek

* Updated transfer_biomek

* 更新transfer_biomek的msg

* 更新transfer_biomek的msg

* 支持Biomek创建

* new action

* fix key name typo

* New parameter for biomek to run.

* Refine

* Update

* new actions

* new actions

* 1

* registry

* fix biomek startup
add action handles

* fix handles not as default entry

* unilab添加moveit启动

1,整合所有moveit节点到一个move_group中，并整合所有的controller依次激活
2,添加pymoveit2的节点，使用json可直接启动
3,修改机械臂规划方式，添加约束，让冗余关节不会进行过多移动

* biomek_test.py

biomek_test.py是最新的版本，运行它会生成complete_biomek_protocol.json

* Update biomek.py

* biomek_test.py

* fix liquid_handler.biomek handles

* 修改物体attach时，多次赋值当前时间导致卡顿问题，

* Revert "修改物体attach时，多次赋值当前时间导致卡顿问题，"

This reverts commit 56d45b94f5.

* Reapply "修改物体attach时，多次赋值当前时间导致卡顿问题，"

This reverts commit 07d9db20c3.

* 添加缺少物料："plate_well_G12",

* host node新增resource add时间统计
create_resource新增handle
bump version to 0.9.2

* 修正物料上传时间
改用biomek_test
增加ResultInfoEncoder
支持返回结果上传

* 正确发送return_info结果

* 同步执行状态信息

* 取消raiseValueError提示

* Update biomek_test.py

* 0608 DONE

* 同步了Biomek.py 现在应可用

* biomek switch back to non-test

* temp disable initialize resource

* add

* fix tip resource data

* liquid states

* change to debug level

* Revert "change to debug level"

This reverts commit 5d9953c3e5.

* Reapply "change to debug level"

This reverts commit 2487bb6ffc.

* fix tip resource data

* add full device

* add moveit yaml

* 修复moveit
增加post_init阶段，给予ros_node反向

* remove necessary node

* fix moveit action client

* remove necessary imports

* Update moveit_interface.py

* fix handler_key uppercase

* json add liquids

* fix setup

* add

* change to "sources" and "targets" for lh

* bump version

* remove parent's parent link

* change arm's name

* change name

---------

Co-authored-by: Harvey Que <Q-Query@outlook.com>
Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: q434343 <73513873+q434343@users.noreply.github.com>
Co-authored-by: Junhan Chang <changjh@pku.edu.cn>
Co-authored-by: Guangxin Zhang <guangxin.zhang.bio@gmail.com>
Co-authored-by: qxw138 <qxw@stu.pku.edu.cn>

* fix move it

* fix move it

* create_resource

* bump ver
modify slot type

* 增加modbus支持
调整protocol node以更好支持多种类型的read和write

* 调整protocol node以更好支持多种类型的read和write

* 补充日志

* Device visualization (#42)

* Update README and MQTTClient for installation instructions and code improvements

* feat: 支持local_config启动
add: 增加对crt path的说明，为传入config.py的相对路径
move: web component

* add: registry description

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* feat: node_info_update srv
fix: OTDeck cant create

* close #12
feat: slave node registry

* feat: show machine name
fix: host node registry not uploaded

* feat: add hplc registry

* feat: add hplc registry

* fix: hplc status typo

* fix: devices/

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* fix: device.class possible null

* fix: HPLC additions with online service

* fix: slave mode spin not working

* fix: slave mode spin not working

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* feat: 多ProtocolNode 允许子设备ID相同
feat: 上报发现的ActionClient
feat: Host重启动，通过discover机制要求slaveNode重新注册，实现信息及时上报

* feat: 支持env设置config

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* Device visualization (#14)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: missing hostname in devices_names
fix: upload_file for model file

* fix: missing paho-mqtt package
bump version to 0.9.0

* fix startup
add ResourceCreateFromOuter.action

* fix type hint

* update actions

* update actions

* host node add_resource_from_outer
fix cmake list

* pass device config to device class

* add: bind_parent_ids to resource create action
fix: message convert string

* fix: host node should not be re_discovered

* feat: resource tracker support dict

* feat: add more necessary params

* feat: fix boolean null in registry action data

* feat: add outer resource

* 编写mesh添加action

* feat: append resource

* add action

* feat: vis 2d for plr

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

* Device visualization (#22)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* 编写mesh添加action

* add action

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: multi channel

* fix: aspirate

* fix: aspirate

* fix: aspirate

* fix: aspirate

* 提交

* fix: jobadd

* fix: jobadd

* fix: msg converter

* tijiao

* add resource creat easy action

* identify debug msg

* mq client id

* 提取lh的joint发布

* unify liquid_handler definition

* 修改物料跟随与物料添加逻辑

修改物料跟随与物料添加逻辑
将joint_publisher类移出lh的backends，但仍需要对lh的backends进行一些改写

* Revert "修改物料跟随与物料添加逻辑"

This reverts commit 498c997ad7.

* Reapply "修改物料跟随与物料添加逻辑"

This reverts commit 3a60d2ae81.

* Revert "Merge remote-tracking branch 'upstream/dev' into device_visualization"

This reverts commit fa727220af, reversing
changes made to 498c997ad7.

* 修改物料放下时的方法，如果选择

修改物料放下时的方法，
如果选择drop_trash，则删除物料显示
如果选择drop，则让其解除连接

* unilab添加moveit启动

1,整合所有moveit节点到一个move_group中，并整合所有的controller依次激活
2,添加pymoveit2的节点，使用json可直接启动
3,修改机械臂规划方式，添加约束，让冗余关节不会进行过多移动

* 修改物体attach时，多次赋值当前时间导致卡顿问题，

* Revert "修改物体attach时，多次赋值当前时间导致卡顿问题，"

This reverts commit 56d45b94f5.

* Reapply "修改物体attach时，多次赋值当前时间导致卡顿问题，"

This reverts commit 07d9db20c3.

* 添加缺少物料："plate_well_G12",

* add

* fix tip resource data

* liquid states

* change to debug level

* Revert "change to debug level"

This reverts commit 5d9953c3e5.

* Reapply "change to debug level"

This reverts commit 2487bb6ffc.

* fix tip resource data

* add full device

* add moveit yaml

* 修复moveit
增加post_init阶段，给予ros_node反向

* remove necessary node

* fix moveit action client

* remove necessary imports

* Update moveit_interface.py

* fix handler_key uppercase

* json add liquids

* fix setup

* add

* change to "sources" and "targets" for lh

* bump version

* remove parent's parent link

* change arm's name

* change name

* fix ik error

---------

Co-authored-by: Harvey Que <Q-Query@outlook.com>
Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: q434343 <73513873+q434343@users.noreply.github.com>
Co-authored-by: Junhan Chang <changjh@pku.edu.cn>

* Add Mock Device for Organic Synthesis\添加有机合成的虚拟仪器和Protocol (#43)

* Add Device MockChiller

Add device MockChiller

* Add Device MockFilter

* Add Device MockPump

* Add Device MockRotavap

* Add Device MockSeparator

* Add Device MockStirrer

* Add Device MockHeater

* Add Device MockVacuum

* Add Device MockSolenoidValve

* Add Device Mock \_init_.py

* 规范模拟设备代码与注册表信息

* 更改Mock大写文件夹名

* 删除大写目录

* Edited Mock device json

* Match mock device with action

* Edit mock device yaml

* Add new action

* Add Virtual Device, Action, YAML, Protocol for Organic Syn

* 单独分类测试的protocol文件夹

* 更名Action

---------

Co-authored-by: Xuwznln <18435084+Xuwznln@users.noreply.github.com>

* bump version & protocol fix

* hotfix: Add macos_sdk_config (#46)

Co-authored-by: quehh <scienceol@outlook.com>

* include device_mesh when pip install

* 测试自动构建

* try build fix

* try build

* test artifacts

* hotfix: Add .certs in .gitignore

* create container

* container 添加和更新完成

* Device registry port (#49)

* Update README and MQTTClient for installation instructions and code improvements

* feat: 支持local_config启动
add: 增加对crt path的说明，为传入config.py的相对路径
move: web component

* add: registry description

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* feat: node_info_update srv
fix: OTDeck cant create

* close #12
feat: slave node registry

* feat: show machine name
fix: host node registry not uploaded

* feat: add hplc registry

* feat: add hplc registry

* fix: hplc status typo

* fix: devices/

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* fix: device.class possible null

* fix: HPLC additions with online service

* fix: slave mode spin not working

* fix: slave mode spin not working

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* feat: 多ProtocolNode 允许子设备ID相同
feat: 上报发现的ActionClient
feat: Host重启动，通过discover机制要求slaveNode重新注册，实现信息及时上报

* feat: 支持env设置config

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* Device visualization (#14)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: missing hostname in devices_names
fix: upload_file for model file

* fix: missing paho-mqtt package
bump version to 0.9.0

* fix startup
add ResourceCreateFromOuter.action

* fix type hint

* update actions

* update actions

* host node add_resource_from_outer
fix cmake list

* pass device config to device class

* add: bind_parent_ids to resource create action
fix: message convert string

* fix: host node should not be re_discovered

* feat: resource tracker support dict

* feat: add more necessary params

* feat: fix boolean null in registry action data

* feat: add outer resource

* 编写mesh添加action

* feat: append resource

* add action

* feat: vis 2d for plr

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

* Device visualization (#22)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* 编写mesh添加action

* add action

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: multi channel

* fix: aspirate

* fix: aspirate

* fix: aspirate

* fix: aspirate

* 提交

* fix: jobadd

* fix: jobadd

* fix: msg converter

* tijiao

* add resource creat easy action

* identify debug msg

* mq client id

* unify liquid_handler definition

* Update virtual_device.yaml

* 更正了stir和heater的连接方式

* 区分了虚拟仪器中的八通阀和电磁阀，添加了两个阀门的驱动

* 修改了add protocol

* 修复了阀门更新版的bug

* 修复了添加protocol前缀导致的不能启动的bug

* Fix handles

* bump version to 0.9.6

* add resource edge upload

* update container registry and handles

* add virtual_separator virtual_rotavap
fix transfer_pump

* fix container value
add parent_name to edge device id

* 大图的问题都修复好了，添加了gassource和vacuum pump的驱动以及注册表

* default resource upload mode is false

* 添加了icon的文件名在注册表里面

* 修改了json图中link的格式

* fix resource and edge upload

* fix device ports

* Fix edge id

* 移除device的父节点关联

* separate registry sync and resource_add

* 默认不进行注册表报送，通过命令unilabos-register或者增加启动参数

* 完善tip

* protocol node不再嵌套显示

* bump version to 0.9.7  新增一个测试PumpTransferProtocol的teststation，亲测可以运行，将八通阀们和转移泵与pump_protocol适配

* protocol node 执行action不应携带自身device id

* 添加了一套简易双八通阀工作站JSON，亲测能跑

* 修复了很多protocol，亲测能跑

* 添加了run column和filter through的protocol，亲测能跑

* fix mock_reactor

* 修改了大图和小图的json，但是在前端上没看到改变

---------

Co-authored-by: Harvey Que <Q-Query@outlook.com>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>
Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: q434343 <73513873+q434343@users.noreply.github.com>
Co-authored-by: Junhan Chang <changjh@pku.edu.cn>

* 更新workstation注册表

* 添加了两个protocol的检索功能 (#51)

* 添加了两个protocol的检索liquid type功能

* fix workstation registry

* 修复了没连接的几个仪器的link，添加了container的icon

* 修改了json和注册表，现在大图全部的device都链接上了

* 修复了小图的json图，线全部连上了

* add work_station protocol handles (ports)

* fix workstation action handle

---------

Co-authored-by: Xuwznln <18435084+Xuwznln@users.noreply.github.com>
Co-authored-by: Junhan Chang <changjh@dp.tech>

* 新增注册表补全功能，修复Protocol执行失败

* 支持通过导入方式补全注册表，新增工作流unilabos_device_id字段

* 修复不启用注册表补充就无法启动的bug

* 修复部分识别error

* 修复静态方法识别get status，注册表支持python类型

* status types对于嵌套类型返回的对象，暂时处理成字符串，无法直接进行转换

* 支持通过list[int]，list[float]进行Int64MultiArray，Float64MultiArray的替换

* 成功动态导入的不再需要使用静态导入

* Fix handle names (#55)

* fix handle names

* improve evacuateAndRefill gas source finding

* add camera and dependency (#56)

* 修复auto-的Action在protocol node下错误注册

* 匹配init param schema格式

* Add channel_sources config in conda_build_config.yaml (#58)

* 修复任务执行传参

* Create 5 new protocols & bump version 0.9.8 (#59)

* 添加了5个缺失的protocol，验证了可以运行

* bump version to 0.9.8

* 修复新增的Action的字段缺失

---------

Co-authored-by: Xuwznln <18435084+Xuwznln@users.noreply.github.com>

* 转换到ros消息时，要进行基础类型转换

* Update work_station.yaml (#60)

* Update work_station.yaml

* Checklist里面有XDL跟protocol之间没对齐的问题，工作量有点大找时间写完

* Create prcxi.py

* Update prcxi.py

* Update Prcxi

* 更新中析仪器，以及启动示例

* 修改moveit_interface，并在mqtt上报时发送一个时间戳，方便网页端对数据的筛选 (#62)

* Update README and MQTTClient for installation instructions and code improvements

* feat: 支持local_config启动
add: 增加对crt path的说明，为传入config.py的相对路径
move: web component

* add: registry description

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* feat: node_info_update srv
fix: OTDeck cant create

* close #12
feat: slave node registry

* feat: show machine name
fix: host node registry not uploaded

* feat: add hplc registry

* feat: add hplc registry

* fix: hplc status typo

* fix: devices/

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* fix: device.class possible null

* fix: HPLC additions with online service

* fix: slave mode spin not working

* fix: slave mode spin not working

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* feat: 多ProtocolNode 允许子设备ID相同
feat: 上报发现的ActionClient
feat: Host重启动，通过discover机制要求slaveNode重新注册，实现信息及时上报

* feat: 支持env设置config

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* Device visualization (#14)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: missing hostname in devices_names
fix: upload_file for model file

* fix: missing paho-mqtt package
bump version to 0.9.0

* fix startup
add ResourceCreateFromOuter.action

* fix type hint

* update actions

* update actions

* host node add_resource_from_outer
fix cmake list

* pass device config to device class

* add: bind_parent_ids to resource create action
fix: message convert string

* fix: host node should not be re_discovered

* feat: resource tracker support dict

* feat: add more necessary params

* feat: fix boolean null in registry action data

* feat: add outer resource

* 编写mesh添加action

* feat: append resource

* add action

* feat: vis 2d for plr

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

* Device visualization (#22)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* 编写mesh添加action

* add action

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: multi channel

* fix: aspirate

* fix: aspirate

* fix: aspirate

* fix: aspirate

* 提交

* fix: jobadd

* fix: jobadd

* fix: msg converter

* tijiao

* add resource creat easy action

* identify debug msg

* mq client id

* 提取lh的joint发布

* unify liquid_handler definition

* 修改物料跟随与物料添加逻辑

修改物料跟随与物料添加逻辑
将joint_publisher类移出lh的backends，但仍需要对lh的backends进行一些改写

* Revert "修改物料跟随与物料添加逻辑"

This reverts commit 498c997ad7.

* Reapply "修改物料跟随与物料添加逻辑"

This reverts commit 3a60d2ae81.

* Revert "Merge remote-tracking branch 'upstream/dev' into device_visualization"

This reverts commit fa727220af, reversing
changes made to 498c997ad7.

* 修改物料放下时的方法，如果选择

修改物料放下时的方法，
如果选择drop_trash，则删除物料显示
如果选择drop，则让其解除连接

* unilab添加moveit启动

1,整合所有moveit节点到一个move_group中，并整合所有的controller依次激活
2,添加pymoveit2的节点，使用json可直接启动
3,修改机械臂规划方式，添加约束，让冗余关节不会进行过多移动

* 修改物体attach时，多次赋值当前时间导致卡顿问题，

* Revert "修改物体attach时，多次赋值当前时间导致卡顿问题，"

This reverts commit 56d45b94f5.

* Reapply "修改物体attach时，多次赋值当前时间导致卡顿问题，"

This reverts commit 07d9db20c3.

* 添加缺少物料："plate_well_G12",

* add

* fix tip resource data

* liquid states

* change to debug level

* Revert "change to debug level"

This reverts commit 5d9953c3e5.

* Reapply "change to debug level"

This reverts commit 2487bb6ffc.

* fix tip resource data

* add full device

* add moveit yaml

* 修复moveit
增加post_init阶段，给予ros_node反向

* remove necessary node

* fix moveit action client

* remove necessary imports

* Update moveit_interface.py

* fix handler_key uppercase

* json add liquids

* fix setup

* add

* change to "sources" and "targets" for lh

* bump version

* remove parent's parent link

* change arm's name

* change name

* fix ik error

* 修改moveit_interface，并在mqtt上报时发送一个时间戳

---------

Co-authored-by: Harvey Que <Q-Query@outlook.com>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>
Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: Junhan Chang <changjh@pku.edu.cn>

* 更新实例

* 更新实例

* 更新实例

* 修正prcxi启动

* 更新PRCXI配置，修改主机地址和设置状态，并添加示例用法

* add pickup tips for prcxi

* 任意执行错误都应该返回failed

* 任意执行错误都应该返回failed

* Add plateT6 to PRCXI configuration and enhance error handling in liquid handling

* prcxi blending

* assert blending_times > 0

* update prcxi

* update prcxi registry

* Update prcxi.py to fit the function in unilabos.

* 不生成已配置action的动作，增加prcxi的debug模式

* 增加注册表版本参数，支持将auto-指令人工检查后非auto，不生成人工已检查的指令，取消不必要的description生成

* 增加注册表版本参数，支持将auto-指令人工检查后非auto，不生成人工已检查的指令，取消不必要的description生成

* Update prcxi.py

* 修复了部分的protocol因为XDL更新导致的问题 (#61)

* 修复了部分的protocol因为XDL更新导致的问题

但是pumptransfer，add，dissolve，separate还没修，后续还需要写virtual固体加料器

* 补充了四个action

* 添加了固体加样器，丰富了json，修改了add protocol

* bump version to 0.9.9

* fix bugs from new actions

* protocol完整修复版本& bump version to 0.9.10

* 修补了一些单位处理，bump version to 0.9.11

* 优化了全protocol的运行时间，除了pumptransfer相关的还没

* 补充了剩下的几个protocol

---------

Co-authored-by: Junhan Chang <changjh@dp.tech>
Co-authored-by: Xuwznln <18435084+Xuwznln@users.noreply.github.com>

* 修复action移除时的报错，更新注册表

* Update prcxi.py

* Update prcxi.py

* 新增simulator

* Update prcxi.py

* Update trash

* Update prcxi.py

* Update prcxi.py

* Update for discard tips

* Update prcxi.py

* Update PRCXI

* 更新axis等参数

* Update 9320

* get_well_container&get_tip_rack

* update

* Update 9320

* update

* deck

* 更新注册表&增加资源，parent应为resources字段

* Update 9320

* update

* 新增set liquid方法

* 新增set liquid方法

* action to resource & 0.9.12 (#64)

* action to resource & 0.9.12

* stir和adjustph的中的bug修不好

* modify prcxi

* 0.9.12 update registry

* update

* update

* registry upadte

* Update

* update

* container_for_nothing

* mix

* registry fix

* registry fix

* registry fix

* Update

* Update prcxi.py

* SET TIP RACK

* bump version

* update registry version & category

* update set tip rack

* yaml dump支持ordered dict，支持config_info

* fix devices

* fix resource check serialize

* fix: Protocol node resource run (#65)

* stir和adjustph的中的bug修不好

* fix sub-resource query in protocol node compiling

* add resource placeholder to vessels

* add the rest yaml

* Update work_station.yaml

---------

Co-authored-by: KCFeng425 <2100011801@stu.pku.edu.cn>

* 采用http报送resource

* 采用http报送resource

* update

* Update .gitignore

* bump version to 0.10.0

* default param simulator

* slim

* Update

* Update for prcxi

* Update

* Update

* Refactor PRCXI9300Deck initialization and update plate configurations

- Changed deck name from "PRCXI_Deck" to "PRCXI_Deck_9300".
- Updated plate4 initialization to use get_well_container instead of get_tip_rack.
- Modified plate4 material details with new UUID, code, and name.
- Renamed output JSON file to "deck_9300_new.json".
- Uncommented and adjusted liquid handling operations for clarity and future use.

* test

* update

* Update prcxi_9300.json

This one is good

* update

* fix protocol_node communication transfer

* 修复注册表handles类型错误的问题

* 物料添加失败应该直接raise ValueError，不要等待

* 更正注册表中的数字类型

* Delete unnecessary files.

* 新增lab_id直接传入

* fix vessel_id param passing in protocols

* 新增dll预载，保证部分设备可正常使用unilabos_msgs

* 修复可能的web template找不到的问题
新增联网获取json启动
删除非-g传入启动json的方式
兼容传参参数名短横线与下划线

* 修复可能的web template找不到的问题
新增联网获取json启动
删除非-g传入启动json的方式
兼容传参参数名短横线与下划线
更新版本到0.10.1
修复Upload Registry镜像不匹配

* 新增用户引导

* Device visualization (#67)

* Update README and MQTTClient for installation instructions and code improvements

* feat: 支持local_config启动
add: 增加对crt path的说明，为传入config.py的相对路径
move: web component

* add: registry description

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* feat: node_info_update srv
fix: OTDeck cant create

* close #12
feat: slave node registry

* feat: show machine name
fix: host node registry not uploaded

* feat: add hplc registry

* feat: add hplc registry

* fix: hplc status typo

* fix: devices/

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* fix: device.class possible null

* fix: HPLC additions with online service

* fix: slave mode spin not working

* fix: slave mode spin not working

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* feat: 多ProtocolNode 允许子设备ID相同
feat: 上报发现的ActionClient
feat: Host重启动，通过discover机制要求slaveNode重新注册，实现信息及时上报

* feat: 支持env设置config

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* Device visualization (#14)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: missing hostname in devices_names
fix: upload_file for model file

* fix: missing paho-mqtt package
bump version to 0.9.0

* fix startup
add ResourceCreateFromOuter.action

* fix type hint

* update actions

* update actions

* host node add_resource_from_outer
fix cmake list

* pass device config to device class

* add: bind_parent_ids to resource create action
fix: message convert string

* fix: host node should not be re_discovered

* feat: resource tracker support dict

* feat: add more necessary params

* feat: fix boolean null in registry action data

* feat: add outer resource

* 编写mesh添加action

* feat: append resource

* add action

* feat: vis 2d for plr

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

* Device visualization (#22)

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* add 3d visualization

* 完成在main中启动设备可视化

完成在main中启动设备可视化，并输出物料ID：mesh的对应关系resource_model

添加物料模型管理类，遍历物料与resource_model，完成TF数据收集

* 完成TF发布

* 修改模型方向，在yaml中添加变换属性

* 添加物料tf变化时，发送topic到前端

另外修改了物料初始化的方法，防止在tf还未发布时提前建立物料模型与发布话题

* 添加关节发布节点与物料可视化节点进入unilab

* 使用json启动plr与3D模型仿真

* 完成启动OT并联动rviz

* 修复rviz位置问题,

修复rviz位置问题,
在无tf变动时减缓发送频率
在backend中添加物料跟随方法

* fix: running logic

* fix: running logic

* fix: missing ot

* 在main中直接初始化republisher和物料的mesh节点

* 将joint_republisher和resource_mesh_manager添加进 main_slave_run.py中

* 编写mesh添加action

* add action

* fix

* fix: browser on rviz

* fix: cloud bridge error fallback to local

* fix: salve auto run rviz

* 初始化两个plate

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>

* fix: multi channel

* fix: aspirate

* fix: aspirate

* fix: aspirate

* fix: aspirate

* 提交

* fix: jobadd

* fix: jobadd

* fix: msg converter

* tijiao

* add resource creat easy action

* identify debug msg

* mq client id

* 提取lh的joint发布

* unify liquid_handler definition

* 修改物料跟随与物料添加逻辑

修改物料跟随与物料添加逻辑
将joint_publisher类移出lh的backends，但仍需要对lh的backends进行一些改写

* Revert "修改物料跟随与物料添加逻辑"

This reverts commit 498c997ad7.

* Reapply "修改物料跟随与物料添加逻辑"

This reverts commit 3a60d2ae81.

* Revert "Merge remote-tracking branch 'upstream/dev' into device_visualization"

This reverts commit fa727220af, reversing
changes made to 498c997ad7.

* 修改物料放下时的方法，如果选择

修改物料放下时的方法，
如果选择drop_trash，则删除物料显示
如果选择drop，则让其解除连接

* unilab添加moveit启动

1,整合所有moveit节点到一个move_group中，并整合所有的controller依次激活
2,添加pymoveit2的节点，使用json可直接启动
3,修改机械臂规划方式，添加约束，让冗余关节不会进行过多移动

* 修改物体attach时，多次赋值当前时间导致卡顿问题，

* Revert "修改物体attach时，多次赋值当前时间导致卡顿问题，"

This reverts commit 56d45b94f5.

* Reapply "修改物体attach时，多次赋值当前时间导致卡顿问题，"

This reverts commit 07d9db20c3.

* 添加缺少物料："plate_well_G12",

* add

* fix tip resource data

* liquid states

* change to debug level

* Revert "change to debug level"

This reverts commit 5d9953c3e5.

* Reapply "change to debug level"

This reverts commit 2487bb6ffc.

* fix tip resource data

* add full device

* add moveit yaml

* 修复moveit
增加post_init阶段，给予ros_node反向

* remove necessary node

* fix moveit action client

* remove necessary imports

* Update moveit_interface.py

* fix handler_key uppercase

* json add liquids

* fix setup

* add

* change to "sources" and "targets" for lh

* bump version

* remove parent's parent link

* change arm's name

* change name

* fix ik error

* 修改moveit_interface，并在mqtt上报时发送一个时间戳

* 添加机械臂和移液站

* 添加

* 添加硬件

* update

* 添加

---------

Co-authored-by: Harvey Que <Q-Query@outlook.com>
Co-authored-by: wznln <18435084+Xuwznln@users.noreply.github.com>
Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: Junhan Chang <changjh@pku.edu.cn>

* 更新注册表

---------

Co-authored-by: Junhan Chang <changjh@pku.edu.cn>
Co-authored-by: Guangxin Zhang <guangxin.zhang.bio@gmail.com>
Co-authored-by: qxw138 <qxw@stu.pku.edu.cn>
Co-authored-by: q434343 <73513873+q434343@users.noreply.github.com>
Co-authored-by: Harvey Que <Q-Query@outlook.com>
Co-authored-by: Kongchang Feng <2100011801@stu.pku.edu.cn>
Co-authored-by: hh. <103566763+Mile-Away@users.noreply.github.com>
Co-authored-by: quehh <scienceol@outlook.com>
Co-authored-by: Harvey Que <quehaohui@dp.tech>
Co-authored-by: Junhan Chang <changjh@dp.tech>
Co-authored-by: ZiWei <131428629+ZiWei09@users.noreply.github.com>

unilabos/compile/__init__.py

@@ -21,16 +21,23 @@ from .dissolve_protocol import generate_dissolve_protocol
 from .filter_through_protocol import generate_filter_through_protocol
 from .run_column_protocol import generate_run_column_protocol
 from .wash_solid_protocol import generate_wash_solid_protocol
+from .adjustph_protocol import generate_adjust_ph_protocol
+from .reset_handling_protocol import generate_reset_handling_protocol
+from .dry_protocol import generate_dry_protocol
+from .recrystallize_protocol import generate_recrystallize_protocol
+from .hydrogenate_protocol import generate_hydrogenate_protocol
 
 
 # Define a dictionary of protocol generators.
 action_protocol_generators = {
     AddProtocol: generate_add_protocol,
     AGVTransferProtocol: generate_agv_transfer_protocol,
+    AdjustPHProtocol: generate_adjust_ph_protocol,
     CentrifugeProtocol: generate_centrifuge_protocol,
     CleanProtocol: generate_clean_protocol,
     CleanVesselProtocol: generate_clean_vessel_protocol,
     DissolveProtocol: generate_dissolve_protocol,
+    DryProtocol: generate_dry_protocol,
     EvacuateAndRefillProtocol: generate_evacuateandrefill_protocol,
     EvaporateProtocol: generate_evaporate_protocol,
     FilterProtocol: generate_filter_protocol,
@@ -38,7 +45,10 @@ action_protocol_generators = {
     HeatChillProtocol: generate_heat_chill_protocol,
     HeatChillStartProtocol: generate_heat_chill_start_protocol,
     HeatChillStopProtocol: generate_heat_chill_stop_protocol,
+    HydrogenateProtocol: generate_hydrogenate_protocol,
     PumpTransferProtocol: generate_pump_protocol_with_rinsing,
+    RecrystallizeProtocol: generate_recrystallize_protocol,
+    ResetHandlingProtocol: generate_reset_handling_protocol,
     RunColumnProtocol: generate_run_column_protocol,
     SeparateProtocol: generate_separate_protocol,
     StartStirProtocol: generate_start_stir_protocol,

unilabos/compile/adjustph_protocol.py

@@ -0,0 +1,657 @@
+import networkx as nx
+import logging
+from typing import List, Dict, Any, Union
+from .pump_protocol import generate_pump_protocol_with_rinsing
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    print(f"[ADJUST_PH] {message}", flush=True)
+    logger.info(f"[ADJUST_PH] {message}")
+
+# 🆕 创建进度日志动作
+def create_action_log(message: str, emoji: str = "📝") -> Dict[str, Any]:
+    """创建一个动作日志"""
+    full_message = f"{emoji} {message}"
+    debug_print(full_message)
+    logger.info(full_message)
+    print(f"[ACTION] {full_message}", flush=True)
+    
+    return {
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": 0.1,
+            "log_message": full_message
+        }
+    }
+
+def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
+    """
+    查找酸碱试剂容器，支持多种匹配模式
+    
+    Args:
+        G: 网络图
+        reagent: 试剂名称（如 "hydrochloric acid", "sodium hydroxide"）
+    
+    Returns:
+        str: 试剂容器ID
+    """
+    debug_print(f"🔍 正在查找试剂 '{reagent}' 的容器...")
+    
+    # 常见酸碱试剂的别名映射
+    reagent_aliases = {
+        "hydrochloric acid": ["HCl", "hydrochloric_acid", "hcl", "muriatic_acid"],
+        "sodium hydroxide": ["NaOH", "sodium_hydroxide", "naoh", "caustic_soda"],
+        "sulfuric acid": ["H2SO4", "sulfuric_acid", "h2so4"],
+        "nitric acid": ["HNO3", "nitric_acid", "hno3"],
+        "acetic acid": ["CH3COOH", "acetic_acid", "glacial_acetic_acid"],
+        "ammonia": ["NH3", "ammonium_hydroxide", "nh3"],
+        "potassium hydroxide": ["KOH", "potassium_hydroxide", "koh"]
+    }
+    
+    # 构建搜索名称列表
+    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:
+        name_clean = name.replace(" ", "_").replace("-", "_")
+        possible_names.extend([
+            f"flask_{name_clean}",
+            f"bottle_{name_clean}",
+            f"reagent_{name_clean}",
+            f"acid_{name_clean}" if "acid" in name else f"base_{name_clean}",
+            f"{name_clean}_bottle",
+            f"{name_clean}_flask",
+            name_clean
+        ])
+    
+    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} 🎯")
+            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()
+            
+            # 检查是否包含任何搜索名称
+            for search_name in search_names:
+                if search_name in node_id.lower() or search_name in node_name:
+                    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', {})
+            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()
+                    
+                    for search_name in search_names:
+                        if search_name in liquid_type or search_name in reagent_name:
+                            debug_print(f"✅ 通过液体类型匹配找到容器: {node_id} 💧")
+                            return node_id
+    
+    # 列出可用容器帮助调试
+    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
+    
+    Args:
+        target_ph_value: 目标pH值
+        reagent: 试剂名称
+        vessel_volume: 容器体积 (mL)
+    
+    Returns:
+        float: 估算的试剂体积 (mL)
+    """
+    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  # 5%
+            debug_print(f"  💪 强酸性 (pH<3): 使用 5% 体积")
+        elif target_ph_value < 5:
+            volume = vessel_volume * 0.02  # 2%
+            debug_print(f"  🔸 中酸性 (pH<5): 使用 2% 体积")
+        else:
+            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  # 5%
+            debug_print(f"  💪 强碱性 (pH>11): 使用 5% 体积")
+        elif target_ph_value > 9:
+            volume = vessel_volume * 0.02  # 2%
+            debug_print(f"  🔸 中碱性 (pH>9): 使用 2% 体积")
+        else:
+            volume = vessel_volume * 0.01  # 1%
+            debug_print(f"  🔹 弱碱性 (pH≤9): 使用 1% 体积")
+    
+    else:
+        # 未知试剂，使用默认值
+        volume = vessel_volume * 0.01
+        debug_print(f"❓ 未知试剂类型，使用默认 1% 体积")
+    
+    debug_print(f"📊 计算结果: {volume:.2f}mL")
+    return volume
+
+def generate_adjust_ph_protocol(
+    G: nx.DiGraph,
+    vessel:Union[dict,str],  # 🔧 修改：从字符串改为字典类型
+    ph_value: float,
+    reagent: str,
+    **kwargs
+) -> List[Dict[str, Any]]:
+    """
+    生成调节pH的协议序列
+    
+    Args:
+        G: 有向图，节点为容器和设备
+        vessel: 目标容器字典（需要调节pH的容器）
+        ph_value: 目标pH值（从XDL传入）
+        reagent: 酸碱试剂名称（从XDL传入）
+        **kwargs: 其他可选参数，使用默认值
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
+    """
+    
+    # 统一处理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 = G.nodes[vessel_id].get("data", {}) if vessel_id in G.nodes() else {}
+    
+    if not vessel_id:
+        debug_print(f"❌ vessel 参数无效，必须包含id字段或直接提供容器ID. vessel: {vessel}")
+        raise ValueError("vessel 参数无效，必须包含id字段或直接提供容器ID")
+    
+    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)  # 默认平衡时间
+    
+    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)  # 默认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)
+        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("准备启动搅拌器", "🌪️"))
+        
+        try:
+            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({
+                    "device_id": stirrer_id,
+                    "action_name": "start_stir",
+                    "action_kwargs": {
+                        "vessel": vessel_id,
+                        "stir_speed": stir_speed,
+                        "purpose": f"pH调节: 启动搅拌，准备添加 {reagent}"
+                    }
+                })
+                
+                # 等待搅拌稳定
+                action_sequence.append(create_action_log("等待搅拌稳定...", "⏳"))
+                action_sequence.append({
+                    "action_name": "wait",
+                    "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)  # 至少30秒，每mL需要2秒
+    debug_print(f"⏱️ 计算添加时间: {addition_time}s (缓慢注入)")
+    action_sequence.append(create_action_log(f"设置添加时间: {addition_time:.0f}s (缓慢注入)", "⏱️"))
+    
+    try:
+        action_sequence.append(create_action_log("调用泵协议进行试剂转移", "🔄"))
+        
+        pump_actions = generate_pump_protocol_with_rinsing(
+            G=G,
+            from_vessel=reagent_vessel,
+            to_vessel=vessel_id,
+            volume=volume,
+            amount="",
+            time=addition_time,
+            viscous=False,
+            rinsing_solvent="",  # pH调节不需要清洗
+            rinsing_volume=0.0,
+            rinsing_repeats=0,
+            solid=False,
+            flowrate=0.5,  # 缓慢注入
+            transfer_flowrate=0.3
+        )
+        
+        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)}")
+                # 创建新的体积记录
+                vessel["data"]["liquid_volume"] = volume
+        else:
+            debug_print(f"📊 容器无液体体积数据，创建新记录: {volume:.2f}mL")
+            # 确保vessel有data字段
+            if "data" not in vessel:
+                vessel["data"] = {}
+            vessel["data"]["liquid_volume"] = volume
+            
+        # 🔧 同时更新图中的容器数据
+        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] += volume
+                else:
+                    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)}")
+        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({
+            "device_id": stirrer_id,
+            "action_name": "stir",
+            "action_kwargs": {
+                "stir_time": stir_time,
+                "stir_speed": stir_speed,
+                "settling_time": settling_time,
+                "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({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": settling_time,
+            "description": f"等待pH平衡到目标值 {ph_value}"
+        }
+    })
+    
+    # 9. 完成总结
+    total_time = addition_time + stir_time + settling_time
+    
+    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})"
+    action_sequence.append(create_action_log(summary_msg, "🎉"))
+    
+    return action_sequence
+
+def generate_adjust_ph_protocol_stepwise(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    ph_value: float,
+    reagent: str,
+    max_volume: float = 10.0,
+    steps: int = 3
+) -> List[Dict[str, Any]]:
+    """
+    分步调节pH的协议（更安全，避免过度调节）
+    
+    Args:
+        G: 网络图
+        vessel: 目标容器字典
+        ph_value: 目标pH值
+        reagent: 酸碱试剂
+        max_volume: 最大试剂体积
+        steps: 分步数量
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
+    """
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id = vessel["id"]
+    
+    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} 步开始", "🚀"))
+        
+        # 生成单步协议
+        step_actions = generate_adjust_ph_protocol(
+            G=G,
+            vessel=vessel,  # 🔧 直接传递vessel字典
+            ph_value=ph_value,
+            reagent=reagent,
+            volume=step_volume,
+            stir=True,
+            stir_speed=300.0,
+            stir_time=30.0,
+            settling_time=20.0
+        )
+        
+        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",
+                "action_kwargs": {
+                    "time": 30,
+                    "description": f"pH调节第{i+1}步完成，等待下一步"
+                }
+            })
+    
+    debug_print(f"🎉 分步pH调节完成，共 {len(action_sequence)} 个动作")
+    action_sequence.append(create_action_log("分步pH调节全部完成", "🎉"))
+    
+    return action_sequence
+
+# 便捷函数：常用pH调节
+def generate_acidify_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    target_ph: float = 2.0,
+    acid: str = "hydrochloric acid"
+) -> List[Dict[str, Any]]:
+    """酸化协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"🍋 生成酸化协议: {vessel_id} → pH {target_ph} (使用 {acid})")
+    return generate_adjust_ph_protocol(
+        G, vessel, target_ph, acid
+    )
+
+def generate_basify_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    target_ph: float = 12.0,
+    base: str = "sodium hydroxide"
+) -> List[Dict[str, Any]]:
+    """碱化协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"🧂 生成碱化协议: {vessel_id} → pH {target_ph} (使用 {base})")
+    return generate_adjust_ph_protocol(
+        G, vessel, target_ph, base
+    )
+
+def generate_neutralize_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    reagent: str = "sodium hydroxide"
+) -> List[Dict[str, Any]]:
+    """中和协议（pH=7）"""
+    vessel_id = vessel["id"]
+    debug_print(f"⚖️ 生成中和协议: {vessel_id} → pH 7.0 (使用 {reagent})")
+    return generate_adjust_ph_protocol(
+        G, vessel, 7.0, reagent
+    )
+
+# 测试函数
+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),
+        (12.0, "sodium hydroxide", 100.0),
+        (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("✅ 测试完成")
+
+if __name__ == "__main__":
+    test_adjust_ph_protocol()

unilabos/compile/clean_vessel_protocol.py

@@ -145,7 +145,7 @@ def find_connected_heatchill(G: nx.DiGraph, vessel: str) -> str:
 
 def generate_clean_vessel_protocol(
     G: nx.DiGraph,
-    vessel: str,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
     solvent: str,
     volume: float,
     temp: float,
@@ -165,7 +165,7 @@ def generate_clean_vessel_protocol(
     
     Args:
         G: 有向图，节点为设备和容器，边为流体管道
-        vessel: 要清洗的容器名称
+        vessel: 要清洗的容器字典（包含id字段）
         solvent: 用于清洗的溶剂名称  
         volume: 每次清洗使用的溶剂体积
         temp: 清洗时的温度
@@ -178,20 +178,32 @@ def generate_clean_vessel_protocol(
         ValueError: 当找不到必要的容器或设备时抛出异常
     
     Examples:
-        clean_protocol = generate_clean_vessel_protocol(G, "main_reactor", "water", 100.0, 60.0, 2)
+        clean_protocol = generate_clean_vessel_protocol(G, {"id": "main_reactor"}, "water", 100.0, 60.0, 2)
     """
+    # 🔧 核心修改：从字典中提取容器ID
+    # 统一处理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 = G.nodes[vessel_id].get("data", {}) if vessel_id in G.nodes() else {}
+    
     action_sequence = []
     
     print(f"CLEAN_VESSEL: 开始生成容器清洗协议")
-    print(f"  - 目标容器: {vessel}")
+    print(f"  - 目标容器: {vessel} (ID: {vessel_id})")
     print(f"  - 清洗溶剂: {solvent}")
     print(f"  - 清洗体积: {volume} mL")
     print(f"  - 清洗温度: {temp}°C")
     print(f"  - 重复次数: {repeats}")
     
     # 验证目标容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"目标容器 '{vessel}' 不存在于系统中")
+    if vessel_id not in G.nodes():
+        raise ValueError(f"目标容器 '{vessel_id}' 不存在于系统中")
     
     # 查找溶剂容器
     try:
@@ -208,12 +220,23 @@ def generate_clean_vessel_protocol(
         raise ValueError(f"无法找到废液容器: {str(e)}")
     
     # 查找加热设备（可选）
-    heatchill_id = find_connected_heatchill(G, vessel)
+    heatchill_id = find_connected_heatchill(G, vessel_id)  # 🔧 使用 vessel_id
     if heatchill_id:
         print(f"CLEAN_VESSEL: 找到加热设备: {heatchill_id}")
     else:
         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"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            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:
         print(f"CLEAN_VESSEL: 启动加热至 {temp}°C")
@@ -221,7 +244,7 @@ def generate_clean_vessel_protocol(
             "device_id": heatchill_id,
             "action_name": "heat_chill_start",
             "action_kwargs": {
-                "vessel": vessel,
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
                 "temp": temp,
                 "purpose": f"cleaning with {solvent}"
             }
@@ -240,18 +263,61 @@ def generate_clean_vessel_protocol(
         print(f"CLEAN_VESSEL: 执行第 {repeat + 1} 次清洗")
         
         # 2a. 使用 pump_protocol 将溶剂转移到目标容器
-        print(f"CLEAN_VESSEL: 将 {volume} mL {solvent} 转移到 {vessel}")
+        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,
+                to_vessel=vessel_id,  # 🔧 使用 vessel_id
                 volume=volume,
                 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
+                    else:
+                        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)}")
         
@@ -265,18 +331,52 @@ def generate_clean_vessel_protocol(
         action_sequence.append(wait_action)
         
         # 2c. 使用 pump_protocol 将清洗液转移到废液容器
-        print(f"CLEAN_VESSEL: 将清洗液从 {vessel} 转移到废液容器")
+        print(f"CLEAN_VESSEL: 将清洗液从 {vessel_id} 转移到废液容器")
         try:
             # 调用成熟的 pump_protocol 算法
             remove_waste_actions = generate_pump_protocol(
                 G=G,
-                from_vessel=vessel,
+                from_vessel=vessel_id,  # 🔧 使用 vessel_id
                 to_vessel=waste_vessel,
                 volume=volume,
                 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)
+                    else:
+                        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)}")
         
@@ -296,13 +396,24 @@ def generate_clean_vessel_protocol(
             "device_id": heatchill_id,
             "action_name": "heat_chill_stop",
             "action_kwargs": {
-                "vessel": vessel
+                "vessel": vessel_id  # 🔧 使用 vessel_id
             }
         }
         action_sequence.append(heatchill_stop_action)
     
-    print(f"CLEAN_VESSEL: 生成了 {len(action_sequence)} 个动作")
-    print(f"CLEAN_VESSEL: 清洗协议生成完成")
+    # 🔧 新增：清洗完成后的状态报告
+    final_liquid_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            final_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            final_liquid_volume = current_volume
+    
+    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
 
@@ -310,7 +421,7 @@ def generate_clean_vessel_protocol(
 # 便捷函数：常用清洗方案
 def generate_quick_clean_protocol(
     G: nx.DiGraph, 
-    vessel: str, 
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
     solvent: str = "water", 
     volume: float = 100.0
 ) -> List[Dict[str, Any]]:
@@ -320,7 +431,7 @@ def generate_quick_clean_protocol(
 
 def generate_thorough_clean_protocol(
     G: nx.DiGraph, 
-    vessel: str, 
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
     solvent: str = "water", 
     volume: float = 150.0,
     temp: float = 60.0
@@ -331,7 +442,7 @@ def generate_thorough_clean_protocol(
 
 def generate_organic_clean_protocol(
     G: nx.DiGraph, 
-    vessel: str, 
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
     volume: float = 100.0
 ) -> List[Dict[str, Any]]:
     """有机清洗：先用有机溶剂，再用水清洗"""

unilabos/compile/dry_protocol.py

@@ -0,0 +1,333 @@
+import networkx as nx
+from typing import List, Dict, Any
+
+
+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  # 接收其他可能的参数但不使用
+) -> List[Dict[str, Any]]:
+    """
+    生成干燥协议序列
+    
+    Args:
+        G: 有向图，节点为容器和设备
+        vessel: 目标容器字典（从XDL传入）
+        compound: 化合物名称（从XDL传入，可选）
+        **kwargs: 其他可选参数，但不使用
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
+    """
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id = vessel["id"]
+    
+    action_sequence = []
+    
+    # 默认参数
+    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"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            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():
+        print(f"⚠️ DRY: 警告 - 容器 '{vessel_id}' 不存在于系统中，跳过干燥 😢")
+        return action_sequence
+    print(f"✅ 容器 '{vessel_id}' 验证通过!")
+    
+    # 2. 查找相连的加热器
+    print(f"\n🔍 步骤2: 查找与容器相连的加热器...")
+    heater_id = find_connected_heater(G, vessel_id)  # 🔧 使用 vessel_id
+    
+    if heater_id is None:
+        print(f"😭 DRY: 警告 - 未找到与容器 '{vessel_id}' 相连的加热器，跳过干燥")
+        print(f"🎭 添加模拟干燥动作...")
+        # 添加一个等待动作，表示干燥过程（模拟）
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {
+                "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):
+                    if len(current_volume) > 0:
+                        vessel["data"]["liquid_volume"][0] = new_volume
+                    else:
+                        vessel["data"]["liquid_volume"] = [new_volume]
+                elif isinstance(current_volume, (int, float)):
+                    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
+            
+            print(f"📊 模拟干燥体积变化: {original_liquid_volume:.2f}mL → {new_volume:.2f}mL (-{volume_loss:.2f}mL)")
+        
+        print(f"📄 DRY: 协议生成完成，共 {len(action_sequence)} 个动作 🎯")
+        return action_sequence
+    
+    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": 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": {
+            "time": 10.0,
+            "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": 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  # 每秒每°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):
+                if len(current_volume) > 0:
+                    vessel["data"]["liquid_volume"][0] = new_volume
+                else:
+                    vessel["data"]["liquid_volume"] = [new_volume]
+            elif isinstance(current_volume, (int, float)):
+                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
+        
+        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": vessel_id,  # 🔧 使用 vessel_id
+            "purpose": f"干燥完成，停止加热"
+        }
+    })
+    print(f"  ✅ 停止加热命令已添加 🛑")
+    
+    # 3.5 等待冷却
+    print(f"  ❄️ 动作5: 等待冷却...")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "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"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            final_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            final_liquid_volume = current_volume
+    
+    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 = "", 
+                               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 = "", 
+                                  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 = "", 
+                                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():
+    """测试干燥协议"""
+    print("=== DRY PROTOCOL 测试 ===")
+    print("测试完成")
+
+
+if __name__ == "__main__":
+    test_dry_protocol()

unilabos/compile/evaporate_protocol.py

@@ -1,326 +1,479 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional, Union
 import networkx as nx
-from .pump_protocol import generate_pump_protocol
+import logging
+import re
 
+logger = logging.getLogger(__name__)
 
-def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
+def debug_print(message):
+    """调试输出"""
+    print(f"🧪 [EVAPORATE] {message}", flush=True)
+    logger.info(f"[EVAPORATE] {message}")
+
+def parse_time_input(time_input: Union[str, float]) -> float:
     """
-    获取容器中的液体体积
+    解析时间输入，支持带单位的字符串
+    
+    Args:
+        time_input: 时间输入（如 "3 min", "180", "0.5 h" 等）
+    
+    Returns:
+        float: 时间（秒）
     """
-    if vessel not in G.nodes():
-        return 0.0
+    if isinstance(time_input, (int, float)):
+        debug_print(f"⏱️ 时间输入为数字: {time_input}s ✨")
+        return float(time_input)  # 🔧 确保返回float
     
-    vessel_data = G.nodes[vessel].get('data', {})
-    liquids = vessel_data.get('liquid', [])
+    if not time_input or not str(time_input).strip():
+        debug_print(f"⚠️ 时间输入为空，使用默认值: 180s (3分钟) 🕐")
+        return 180.0  # 默认3分钟
     
-    total_volume = 0.0
-    for liquid in liquids:
-        if isinstance(liquid, dict) and 'liquid_volume' in liquid:
-            total_volume += liquid['liquid_volume']
+    time_str = str(time_input).lower().strip()
+    debug_print(f"🔍 解析时间输入: '{time_str}' 📝")
     
-    return total_volume
+    # 处理未知时间
+    if time_str in ['?', 'unknown', 'tbd']:
+        default_time = 180.0  # 默认3分钟
+        debug_print(f"❓ 检测到未知时间，使用默认值: {default_time}s (3分钟) 🤷‍♀️")
+        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:
+        # 如果无法解析，尝试直接转换为数字（默认秒）
+        try:
+            value = float(time_str)
+            debug_print(f"✅ 时间解析成功: {time_str} → {value}s（无单位，默认秒）⏰")
+            return float(value)  # 🔧 确保返回float
+        except ValueError:
+            debug_print(f"❌ 无法解析时间: '{time_str}'，使用默认值180s (3分钟) 😅")
+            return 180.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}s ⏰")
+    elif unit in ['h', 'hr', 'hour']:
+        time_sec = value * 3600.0  # h -> s
+        debug_print(f"🕐 时间转换: {value} 小时 → {time_sec}s ({time_sec/60:.1f}分钟) ⏰")
+    elif unit in ['d', 'day']:
+        time_sec = value * 86400.0  # d -> s
+        debug_print(f"🕐 时间转换: {value} 天 → {time_sec}s ({time_sec/3600:.1f}小时) ⏰")
+    else:  # s, sec, second 或默认
+        time_sec = value  # 已经是s
+        debug_print(f"🕐 时间转换: {value}s → {time_sec}s (已是秒) ⏰")
+    
+    return float(time_sec)  # 🔧 确保返回float
 
+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} ✨")
+                return vessel
+            elif node_type == 'device':
+                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} 🏆")
+        return selected
+    
+    debug_print("😭 未找到旋转蒸发仪设备 💔")
+    return None
 
-def find_rotavap_device(G: nx.DiGraph) -> str:
-    """查找旋转蒸发仪设备"""
-    rotavap_nodes = [node for node in G.nodes() 
-                    if (G.nodes[node].get('class') or '') == 'virtual_rotavap']
+def find_connected_vessel(G: nx.DiGraph, rotavap_device: str) -> Optional[str]:
+    """
+    查找与旋转蒸发仪连接的容器
     
-    if rotavap_nodes:
-        return rotavap_nodes[0]
+    Args:
+        G: 设备图
+        rotavap_device: 旋转蒸发仪设备ID
     
-    raise ValueError("系统中未找到旋转蒸发仪设备")
-
-
-def find_solvent_recovery_vessel(G: nx.DiGraph) -> str:
-    """查找溶剂回收容器"""
-    possible_names = [
-        "flask_distillate",
-        "bottle_distillate", 
-        "vessel_distillate",
-        "distillate",
-        "solvent_recovery",
-        "flask_solvent_recovery",
-        "collection_flask"
-    ]
+    Returns:
+        str: 连接的容器ID，如果没找到返回None
+    """
+    debug_print(f"🔗 查找与 {rotavap_device} 连接的容器... 🥽")
     
-    for vessel_name in possible_names:
-        if vessel_name in G.nodes():
-            return vessel_name
+    # 查看旋转蒸发仪的子设备
+    rotavap_data = G.nodes[rotavap_device]
+    children = rotavap_data.get('children', [])
     
-    # 如果找不到专门的回收容器，使用废液容器
-    waste_names = ["waste_workup", "flask_waste", "bottle_waste", "waste"]
-    for vessel_name in waste_names:
-        if vessel_name in G.nodes():
-            return vessel_name
+    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} 🥽✨")
+                return child_id
     
-    raise ValueError(f"未找到溶剂回收容器。尝试了以下名称: {possible_names + waste_names}")
-
+    # 查看邻接的容器
+    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} 🥽✨")
+            return neighbor
+    
+    debug_print("😞 未找到连接的容器 💔")
+    return None
 
 def generate_evaporate_protocol(
     G: nx.DiGraph,
-    vessel: str,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
     pressure: float = 0.1,
     temp: float = 60.0,
-    time: float = 1800.0,
-    stir_speed: float = 100.0
+    time: Union[str, float] = "180",     # 🔧 修改：支持字符串时间
+    stir_speed: float = 100.0,
+    solvent: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成蒸发操作的协议序列
-    
-    蒸发流程：
-    1. 液体转移：将待蒸发溶液从源容器转移到旋转蒸发仪
-    2. 蒸发操作：执行旋转蒸发
-    3. (可选) 溶剂回收：将冷凝的溶剂转移到回收容器
-    4. 残留物转移：将浓缩物从旋转蒸发仪转移回原容器或新容器
+    生成蒸发操作的协议序列 - 支持单位和体积运算
     
     Args:
-        G: 有向图，节点为设备和容器，边为流体管道
-        vessel: 包含待蒸发溶液的容器名称
-        pressure: 蒸发时的真空度 (bar)，默认0.1 bar
-        temp: 蒸发时的加热温度 (°C)，默认60°C  
-        time: 蒸发时间 (秒)，默认1800秒(30分钟)
-        stir_speed: 旋转速度 (RPM)，默认100 RPM
+        G: 设备图
+        vessel: 容器字典（从XDL传入）
+        pressure: 真空度 (bar)，默认0.1
+        temp: 加热温度 (°C)，默认60
+        time: 蒸发时间（支持 "3 min", "180", "0.5 h" 等）
+        stir_speed: 旋转速度 (RPM)，默认100
+        solvent: 溶剂名称（用于参数优化）
+        **kwargs: 其他参数（兼容性）
     
     Returns:
-        List[Dict[str, Any]]: 蒸发操作的动作序列
-    
-    Raises:
-        ValueError: 当找不到必要的设备时抛出异常
-    
-    Examples:
-        evaporate_actions = generate_evaporate_protocol(G, "reaction_mixture", 0.05, 80.0, 3600.0)
+        List[Dict[str, Any]]: 动作序列
     """
+    
+    # 🔧 核心修改：从字典中提取容器ID
+    # 统一处理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 = G.nodes[vessel_id].get("data", {}) if vessel_id in G.nodes() else {}
+    
+    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"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            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}分钟) ⏰✨")
+    
+    # === 步骤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("🔥 高沸点溶剂：提高温度，降低真空度 🌡️💨")
+        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:
+        # 基础蒸发速率（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  # 水蒸发较慢
+            elif any(s in solvent_lower for s in ['ethanol', 'methanol', 'acetone']):
+                solvent_factor = 1.5  # 易挥发溶剂蒸发快
+            elif any(s in solvent_lower for s in ['dmso', 'dmi']):
+                solvent_factor = 0.3  # 高沸点溶剂蒸发慢
+        
+        # 计算总蒸发量
+        total_evap_rate = base_evap_rate * temp_factor * vacuum_factor * solvent_factor
+        evaporation_volume = min(
+            original_liquid_volume * 0.95,  # 最多蒸发95%
+            total_evap_rate * (final_time / 60.0)  # 时间相关的蒸发量
+        )
+        
+        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 = []
     
-    print(f"EVAPORATE: 开始生成蒸发协议")
-    print(f"  - 源容器: {vessel}")
-    print(f"  - 真空度: {pressure} bar")
-    print(f"  - 温度: {temp}°C")
-    print(f"  - 时间: {time}s ({time/60:.1f}分钟)")
-    print(f"  - 旋转速度: {stir_speed} RPM")
-    
-    # 验证源容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"源容器 '{vessel}' 不存在于系统中")
-    
-    # 获取源容器中的液体体积
-    source_volume = get_vessel_liquid_volume(G, vessel)
-    print(f"EVAPORATE: 源容器 {vessel} 中有 {source_volume} mL 液体")
-    
-    # 查找旋转蒸发仪
-    try:
-        rotavap_id = find_rotavap_device(G)
-        print(f"EVAPORATE: 找到旋转蒸发仪: {rotavap_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到旋转蒸发仪: {str(e)}")
-    
-    # 查找旋转蒸发仪样品容器
-    rotavap_vessel = None
-    possible_rotavap_vessels = ["rotavap_flask", "rotavap", "flask_rotavap", "evaporation_flask"]
-    for rv in possible_rotavap_vessels:
-        if rv in G.nodes():
-            rotavap_vessel = rv
-            break
-    
-    if not rotavap_vessel:
-        raise ValueError(f"未找到旋转蒸发仪样品容器。尝试了: {possible_rotavap_vessels}")
-    
-    print(f"EVAPORATE: 找到旋转蒸发仪样品容器: {rotavap_vessel}")
-    
-    # 查找溶剂回收容器
-    try:
-        distillate_vessel = find_solvent_recovery_vessel(G)
-        print(f"EVAPORATE: 找到溶剂回收容器: {distillate_vessel}")
-    except ValueError as e:
-        print(f"EVAPORATE: 警告 - {str(e)}")
-        distillate_vessel = None
-    
-    # === 简化的体积计算策略 ===
-    if source_volume > 0:
-        # 如果能检测到液体体积，使用实际体积的大部分
-        transfer_volume = min(source_volume * 0.9, 250.0)  # 90%或最多250mL
-        print(f"EVAPORATE: 检测到液体体积，将转移 {transfer_volume} mL")
-    else:
-        # 如果检测不到液体体积，默认转移一整瓶 250mL
-        transfer_volume = 250.0
-        print(f"EVAPORATE: 未检测到液体体积，默认转移整瓶 {transfer_volume} mL")
-    
-    # === 第一步：将待蒸发溶液转移到旋转蒸发仪 ===
-    print(f"EVAPORATE: 将 {transfer_volume} mL 溶液从 {vessel} 转移到 {rotavap_vessel}")
-    try:
-        transfer_to_rotavap_actions = generate_pump_protocol(
-            G=G,
-            from_vessel=vessel,
-            to_vessel=rotavap_vessel,
-            volume=transfer_volume,
-            flowrate=2.0,
-            transfer_flowrate=2.0
-        )
-        action_sequence.extend(transfer_to_rotavap_actions)
-    except Exception as e:
-        raise ValueError(f"无法将溶液转移到旋转蒸发仪: {str(e)}")
-    
-    # 转移后等待
-    wait_action = {
+    # 1. 等待稳定
+    debug_print("  🔄 动作1: 添加初始等待稳定... ⏳")
+    action_sequence.append({
         "action_name": "wait",
         "action_kwargs": {"time": 10}
-    }
-    action_sequence.append(wait_action)
+    })
+    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")
     
-    # === 第二步：执行旋转蒸发 ===
-    print(f"EVAPORATE: 执行旋转蒸发操作")
     evaporate_action = {
-        "device_id": rotavap_id,
+        "device_id": rotavap_device,
         "action_name": "evaporate",
         "action_kwargs": {
-            "vessel": rotavap_vessel,
-            "pressure": pressure,
-            "temp": temp,
-            "time": time,
-            "stir_speed": stir_speed
+            "vessel": target_vessel,
+            "pressure": float(pressure),
+            "temp": float(temp),
+            "time": float(final_time),  # 🔧 强制转换为float类型
+            "stir_speed": float(stir_speed),
+            "solvent": str(solvent)
         }
     }
     action_sequence.append(evaporate_action)
+    debug_print("  ✅ 蒸发动作已添加 🌪️✨")
     
-    # 蒸发后等待系统稳定
-    wait_action = {
-        "action_name": "wait",
-        "action_kwargs": {"time": 30}
-    }
-    action_sequence.append(wait_action)
-    
-    # === 第三步：溶剂回收（如果有回收容器）===
-    if distillate_vessel:
-        print(f"EVAPORATE: 回收冷凝溶剂到 {distillate_vessel}")
-        try:
-            condenser_vessel = "rotavap_condenser"
-            if condenser_vessel in G.nodes():
-                # 估算回收体积（约为转移体积的70% - 大部分溶剂被蒸发回收）
-                recovery_volume = transfer_volume * 0.7
-                print(f"EVAPORATE: 预计回收 {recovery_volume} mL 溶剂")
-                
-                recovery_actions = generate_pump_protocol(
-                    G=G,
-                    from_vessel=condenser_vessel,
-                    to_vessel=distillate_vessel,
-                    volume=recovery_volume,
-                    flowrate=3.0,
-                    transfer_flowrate=3.0
-                )
-                action_sequence.extend(recovery_actions)
+    # 🔧 新增：蒸发过程中的体积变化
+    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):
+                if len(current_volume) > 0:
+                    vessel["data"]["liquid_volume"][0] = new_volume
+                else:
+                    vessel["data"]["liquid_volume"] = [new_volume]
+            elif isinstance(current_volume, (int, float)):
+                vessel["data"]["liquid_volume"] = new_volume
             else:
-                print("EVAPORATE: 未找到冷凝器容器，跳过溶剂回收")
-        except Exception as e:
-            print(f"EVAPORATE: 溶剂回收失败: {str(e)}")
-    
-    # === 第四步：将浓缩物转移回原容器 ===
-    print(f"EVAPORATE: 将浓缩物从旋转蒸发仪转移回 {vessel}")
-    try:
-        # 估算浓缩物体积（约为转移体积的20% - 大部分溶剂已蒸发）
-        concentrate_volume = transfer_volume * 0.2
-        print(f"EVAPORATE: 预计浓缩物体积 {concentrate_volume} mL")
+                vessel["data"]["liquid_volume"] = new_volume
         
-        transfer_back_actions = generate_pump_protocol(
-            G=G,
-            from_vessel=rotavap_vessel,
-            to_vessel=vessel,
-            volume=concentrate_volume,
-            flowrate=1.0,  # 浓缩物可能粘稠，用较慢流速
-            transfer_flowrate=1.0
-        )
-        action_sequence.extend(transfer_back_actions)
-    except Exception as e:
-        print(f"EVAPORATE: 将浓缩物转移回容器失败: {str(e)}")
-    
-    # === 第五步：清洗旋转蒸发仪 ===
-    print(f"EVAPORATE: 清洗旋转蒸发仪")
-    try:
-        # 查找清洗溶剂
-        cleaning_solvent = None
-        for solvent in ["flask_ethanol", "flask_acetone", "flask_water"]:
-            if solvent in G.nodes():
-                cleaning_solvent = solvent
-                break
-        
-        if cleaning_solvent and distillate_vessel:
-            # 用固定量溶剂清洗（不依赖检测体积）
-            cleaning_volume = 50.0  # 固定50mL清洗
-            print(f"EVAPORATE: 用 {cleaning_volume} mL {cleaning_solvent} 清洗")
+        # 🔧 同时更新图中的容器数据
+        if vessel_id in G.nodes():
+            if 'data' not in G.nodes[vessel_id]:
+                G.nodes[vessel_id]['data'] = {}
             
-            # 清洗溶剂加入
-            cleaning_actions = generate_pump_protocol(
-                G=G,
-                from_vessel=cleaning_solvent,
-                to_vessel=rotavap_vessel,
-                volume=cleaning_volume,
-                flowrate=2.0,
-                transfer_flowrate=2.0
-            )
-            action_sequence.extend(cleaning_actions)
+            vessel_node_data = G.nodes[vessel_id]['data']
+            current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
             
-            # 将清洗液转移到废液/回收容器
-            waste_actions = generate_pump_protocol(
-                G=G,
-                from_vessel=rotavap_vessel,
-                to_vessel=distillate_vessel,  # 使用回收容器作为废液
-                volume=cleaning_volume,
-                flowrate=2.0,
-                transfer_flowrate=2.0
-            )
-            action_sequence.extend(waste_actions)
+            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
         
-    except Exception as e:
-        print(f"EVAPORATE: 清洗步骤失败: {str(e)}")
+        debug_print(f"  📊 蒸发体积变化: {original_liquid_volume:.2f}mL → {new_volume:.2f}mL (-{evaporation_volume:.2f}mL)")
     
-    print(f"EVAPORATE: 生成了 {len(action_sequence)} 个动作")
-    print(f"EVAPORATE: 蒸发协议生成完成")
-    print(f"EVAPORATE: 总处理体积: {transfer_volume} 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"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            final_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            final_liquid_volume = current_volume
+    
+    # === 总结 ===
+    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
-
-
-# 便捷函数：常用蒸发方案 - 都使用250mL标准瓶体积
-def generate_quick_evaporate_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float = 40.0,
-    time: float = 900.0  # 15分钟
-) -> List[Dict[str, Any]]:
-    """快速蒸发：低温、短时间、整瓶处理"""
-    return generate_evaporate_protocol(G, vessel, 0.2, temp, time, 80.0)
-
-
-def generate_gentle_evaporate_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float = 50.0,
-    time: float = 2700.0  # 45分钟
-) -> List[Dict[str, Any]]:
-    """温和蒸发：中等条件、较长时间、整瓶处理"""
-    return generate_evaporate_protocol(G, vessel, 0.1, temp, time, 60.0)
-
-
-def generate_high_vacuum_evaporate_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float = 35.0,
-    time: float = 3600.0  # 1小时
-) -> List[Dict[str, Any]]:
-    """高真空蒸发：低温、高真空、长时间、整瓶处理"""
-    return generate_evaporate_protocol(G, vessel, 0.01, temp, time, 120.0)
-
-
-def generate_standard_evaporate_protocol(
-    G: nx.DiGraph,
-    vessel: str
-) -> List[Dict[str, Any]]:
-    """标准蒸发：常用参数、整瓶250mL处理"""
-    return generate_evaporate_protocol(
-        G=G,
-        vessel=vessel, 
-        pressure=0.1,      # 标准真空度
-        temp=60.0,         # 适中温度
-        time=1800.0,       # 30分钟
-        stir_speed=100.0   # 适中旋转速度
-    )

unilabos/compile/filter_protocol.py

@@ -1,304 +1,375 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 import networkx as nx
-from .pump_protocol import generate_pump_protocol
+import logging
+from .pump_protocol import generate_pump_protocol_with_rinsing
 
+logger = logging.getLogger(__name__)
 
-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) and 'liquid_volume' in liquid:
-            total_volume += liquid['liquid_volume']
-    
-    return total_volume
-
+def debug_print(message):
+    """调试输出"""
+    print(f"🧪 [FILTER] {message}", flush=True)
+    logger.info(f"[FILTER] {message}")
 
 def find_filter_device(G: nx.DiGraph) -> str:
     """查找过滤器设备"""
-    filter_nodes = [node for node in G.nodes() 
-                   if (G.nodes[node].get('class') or '') == 'virtual_filter']
+    debug_print("🔍 查找过滤器设备... 🌊")
     
-    if filter_nodes:
-        return filter_nodes[0]
+    # 查找过滤器设备
+    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} ✨")
+            return node
     
-    raise ValueError("系统中未找到过滤器设备")
+    # 如果没找到，寻找可能的过滤器名称
+    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} ✨")
+            return name
+    
+    debug_print("😭 未找到过滤器设备 💔")
+    raise ValueError("未找到过滤器设备")
 
-
-def find_filter_vessel(G: nx.DiGraph) -> str:
-    """查找过滤器专用容器"""
-    possible_names = [
-        "filter_vessel",        # 标准过滤器容器
-        "filtration_vessel",    # 备选名称
-        "vessel_filter",        # 备选名称
-        "filter_unit",          # 备选名称
-        "filter"               # 简单名称
-    ]
+def validate_vessel(G: nx.DiGraph, vessel: str, vessel_type: str = "容器") -> None:
+    """验证容器是否存在"""
+    debug_print(f"🔍 验证{vessel_type}: '{vessel}' 🧪")
     
-    for vessel_name in possible_names:
-        if vessel_name in G.nodes():
-            return vessel_name
+    if not vessel:
+        debug_print(f"❌ {vessel_type}不能为空! 😱")
+        raise ValueError(f"{vessel_type}不能为空")
     
-    raise ValueError(f"未找到过滤器容器。尝试了以下名称: {possible_names}")
-
-
-def find_filtrate_vessel(G: nx.DiGraph, filtrate_vessel: str = "") -> str:
-    """查找滤液收集容器"""
-    if filtrate_vessel and filtrate_vessel in G.nodes():
-        return filtrate_vessel
+    if vessel not in G.nodes():
+        debug_print(f"❌ {vessel_type} '{vessel}' 不存在于系统中! 😞")
+        raise ValueError(f"{vessel_type} '{vessel}' 不存在于系统中")
     
-    # 自动查找滤液容器
-    possible_names = [
-        "filtrate_vessel",
-        "collection_bottle_1",
-        "collection_bottle_2",
-        "waste_workup"
-    ]
-    
-    for vessel_name in possible_names:
-        if vessel_name in G.nodes():
-            return vessel_name
-    
-    raise ValueError(f"未找到滤液收集容器。尝试了以下名称: {possible_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') == '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]
-    
-    raise ValueError(f"未找到与容器 {vessel} 相连的加热搅拌器")
-
+    debug_print(f"✅ {vessel_type} '{vessel}' 验证通过 🎯")
 
 def generate_filter_protocol(
     G: nx.DiGraph,
-    vessel: str,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
     filtrate_vessel: str = "",
-    stir: bool = False,
-    stir_speed: float = 300.0,
-    temp: float = 25.0,
-    continue_heatchill: bool = False,
-    volume: float = 0.0
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成过滤操作的协议序列，复用 pump_protocol 的成熟算法
-    
-    过滤流程：
-    1. 液体转移：将待过滤溶液从源容器转移到过滤器
-    2. 启动加热搅拌：设置温度和搅拌
-    3. 执行过滤：通过过滤器分离固液
-    4. (可选) 继续或停止加热搅拌
+    生成过滤操作的协议序列 - 支持体积运算
     
     Args:
-        G: 有向图，节点为设备和容器，边为流体管道
-        vessel: 包含待过滤溶液的容器名称
-        filtrate_vessel: 滤液收集容器（可选，自动查找）
-        stir: 是否在过滤过程中搅拌
-        stir_speed: 搅拌速度 (RPM)
-        temp: 过滤温度 (°C)
-        continue_heatchill: 过滤后是否继续加热搅拌
-        volume: 预期过滤体积 (mL)，0表示全部过滤
+        G: 设备图
+        vessel: 过滤容器字典（必需）- 包含需要过滤的混合物
+        filtrate_vessel: 滤液容器名称（可选）- 如果提供则收集滤液
+        **kwargs: 其他参数（兼容性）
     
     Returns:
         List[Dict[str, Any]]: 过滤操作的动作序列
     """
+    
+    # 🔧 核心修改：从字典中提取容器ID
+    # 统一处理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 = G.nodes[vessel_id].get("data", {}) if vessel_id in G.nodes() else {}
+    
+    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 = []
     
-    print(f"FILTER: 开始生成过滤协议")
-    print(f"  - 源容器: {vessel}")
-    print(f"  - 滤液容器: {filtrate_vessel}")
-    print(f"  - 搅拌: {stir} ({stir_speed} RPM)" if stir else "  - 搅拌: 否")
-    print(f"  - 过滤温度: {temp}°C")
-    print(f"  - 预期过滤体积: {volume} mL" if volume > 0 else "  - 预期过滤体积: 全部")
-    print(f"  - 继续加热搅拌: {continue_heatchill}")
+    # 🔧 新增：记录过滤前的容器状态
+    debug_print("🔍 记录过滤前容器状态...")
+    original_liquid_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            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")
     
-    # 验证源容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"源容器 '{vessel}' 不存在于系统中")
+    # === 参数验证 ===
+    debug_print("📍 步骤1: 参数验证... 🔧")
     
-    # 获取源容器中的液体体积
-    source_volume = get_vessel_liquid_volume(G, vessel)
-    print(f"FILTER: 源容器 {vessel} 中有 {source_volume} mL 液体")
+    # 验证必需参数
+    debug_print("  🔍 验证必需参数...")
+    validate_vessel(G, vessel_id, "过滤容器")  # 🔧 使用 vessel_id
+    debug_print("  ✅ 必需参数验证完成 🎯")
     
-    # 查找过滤器设备
-    try:
-        filter_id = find_filter_device(G)
-        print(f"FILTER: 找到过滤器: {filter_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到过滤器: {str(e)}")
-    
-    # 查找过滤器容器
-    try:
-        filter_vessel_id = find_filter_vessel(G)
-        print(f"FILTER: 找到过滤器容器: {filter_vessel_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到过滤器容器: {str(e)}")
-    
-    # 查找滤液收集容器
-    try:
-        actual_filtrate_vessel = find_filtrate_vessel(G, filtrate_vessel)
-        print(f"FILTER: 找到滤液收集容器: {actual_filtrate_vessel}")
-    except ValueError as e:
-        raise ValueError(f"无法找到滤液收集容器: {str(e)}")
-    
-    # 查找加热搅拌器（如果需要温度控制或搅拌）
-    heatchill_id = None
-    if temp != 25.0 or stir or continue_heatchill:
-        try:
-            heatchill_id = find_connected_heatchill(G, filter_vessel_id)
-            print(f"FILTER: 找到加热搅拌器: {heatchill_id}")
-        except ValueError as e:
-            print(f"FILTER: 警告 - {str(e)}")
-    
-    # === 简化的体积计算策略 ===
-    if volume > 0:
-        transfer_volume = min(volume, source_volume if source_volume > 0 else volume)
-        print(f"FILTER: 指定过滤体积 {transfer_volume} mL")
-    elif source_volume > 0:
-        transfer_volume = source_volume * 0.9  # 90%
-        print(f"FILTER: 检测到液体体积，将过滤 {transfer_volume} mL")
+    # 验证可选参数
+    debug_print("  🔍 验证可选参数...")
+    if filtrate_vessel:
+        validate_vessel(G, filtrate_vessel, "滤液容器")
+        debug_print("  🌊 模式: 过滤并收集滤液 💧")
     else:
-        transfer_volume = 50.0  # 默认过滤量
-        print(f"FILTER: 未检测到液体体积，默认过滤 {transfer_volume} mL")
+        debug_print("  🧱 模式: 过滤并收集固体 🔬")
+    debug_print("  ✅ 可选参数验证完成 🎯")
     
-    # === 第一步：启动加热搅拌器（在转移前预热） ===
-    if heatchill_id and (temp != 25.0 or stir):
-        print(f"FILTER: 启动加热搅拌器，温度: {temp}°C，搅拌: {stir}")
-        
-        heatchill_action = {
-            "device_id": heatchill_id,
-            "action_name": "heat_chill_start",
-            "action_kwargs": {
-                "vessel": filter_vessel_id,
-                "temp": temp,
-                "purpose": f"过滤过程温度控制和搅拌"
-            }
-        }
-        action_sequence.append(heatchill_action)
-        
-        # 等待温度稳定
-        if temp != 25.0:
-            wait_time = min(30, abs(temp - 25.0) * 1.0)  # 根据温差估算预热时间
-            action_sequence.append({
-                "action_name": "wait",
-                "action_kwargs": {"time": wait_time}
-            })
+    # === 查找设备 ===
+    debug_print("📍 步骤2: 查找设备... 🔍")
     
-    # === 第二步：将待过滤溶液转移到过滤器 ===
-    print(f"FILTER: 将 {transfer_volume} mL 溶液从 {vessel} 转移到 {filter_vessel_id}")
     try:
-        # 使用成熟的 pump_protocol 算法进行液体转移
-        transfer_to_filter_actions = generate_pump_protocol(
-            G=G,
-            from_vessel=vessel,
-            to_vessel=filter_vessel_id,
-            volume=transfer_volume,
-            flowrate=1.0,  # 过滤转移用较慢速度，避免扰动
-            transfer_flowrate=1.5
-        )
-        action_sequence.extend(transfer_to_filter_actions)
+        debug_print("  🔎 搜索过滤器设备...")
+        filter_device = find_filter_device(G)
+        debug_print(f"  🎉 使用过滤器设备: {filter_device} 🌊✨")
+        
     except Exception as e:
-        raise ValueError(f"无法将溶液转移到过滤器: {str(e)}")
+        debug_print(f"  ❌ 设备查找失败: {str(e)} 😭")
+        raise ValueError(f"设备查找失败: {str(e)}")
     
-    # 转移后等待
-    action_sequence.append({
-        "action_name": "wait",
-        "action_kwargs": {"time": 5}
-    })
+    # 🔧 新增：过滤效率和体积分配估算
+    debug_print("📍 步骤2.5: 过滤体积分配估算... 📊")
     
-    # === 第三步：执行过滤操作（完全按照 Filter.action 参数） ===
-    print(f"FILTER: 执行过滤操作")
+    # 估算过滤分离比例（基于经验数据）
+    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:
+            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}%)")
+    
+    # === 转移到过滤器（如果需要）===
+    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=vessel_id,  # 🔧 使用 vessel_id
+                to_vessel=filter_device,
+                volume=0.0,  # 转移所有液体
+                amount="",
+                time=0.0,
+                viscous=False,
+                rinsing_solvent="",
+                rinsing_volume=0.0,
+                rinsing_repeats=0,
+                solid=False,
+                flowrate=2.0,
+                transfer_flowrate=2.0
+            )
+            
+            if transfer_actions:
+                action_sequence.extend(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("  🔄 继续执行，可能是直接连接的过滤器 🤞")
+    else:
+        debug_print("  ✅ 过滤容器就是过滤器，无需转移 🎯")
+    
+    # === 执行过滤操作 ===
+    debug_print("📍 步骤4: 执行过滤操作... 🌊")
+    
+    # 构建过滤动作参数
+    debug_print("  ⚙️ 构建过滤参数...")
+    filter_kwargs = {
+        "vessel": filter_device,  # 过滤器设备
+        "filtrate_vessel": filtrate_vessel,  # 滤液容器（可能为空）
+        "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)  # 0表示过滤所有
+    }
+    
+    debug_print(f"  📋 过滤参数: {filter_kwargs}")
+    debug_print("  🌊 开始过滤操作...")
+    
+    # 过滤动作
     filter_action = {
-        "device_id": filter_id,
+        "device_id": filter_device,
         "action_name": "filter",
-        "action_kwargs": {
-            "vessel": filter_vessel_id,
-            "filtrate_vessel": actual_filtrate_vessel,
-            "stir": stir,
-            "stir_speed": stir_speed,
-            "temp": temp,
-            "continue_heatchill": continue_heatchill,
-            "volume": transfer_volume
-        }
+        "action_kwargs": filter_kwargs
     }
     action_sequence.append(filter_action)
+    debug_print("  ✅ 过滤动作已添加 🌊✨")
     
     # 过滤后等待
+    debug_print("  ⏳ 添加过滤后等待...")
     action_sequence.append({
         "action_name": "wait",
-        "action_kwargs": {"time": 10}
+        "action_kwargs": {"time": 10.0}
     })
+    debug_print("  ✅ 过滤后等待动作已添加 ⏰✨")
     
-    # === 第四步：如果不继续加热搅拌，停止加热器 ===
-    if heatchill_id and not continue_heatchill and (temp != 25.0 or stir):
-        print(f"FILTER: 停止加热搅拌器")
+    # === 收集滤液（如果需要）===
+    debug_print("📍 步骤5: 收集滤液... 💧")
+    
+    if filtrate_vessel:
+        debug_print(f"  🧪 收集滤液: {filter_device} → {filtrate_vessel} 💧")
         
-        stop_action = {
-            "device_id": heatchill_id,
-            "action_name": "heat_chill_stop",
-            "action_kwargs": {
-                "vessel": filter_vessel_id
-            }
-        }
-        action_sequence.append(stop_action)
+        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,  # 收集所有滤液
+                amount="",
+                time=0.0,
+                viscous=False,
+                rinsing_solvent="",
+                rinsing_volume=0.0,
+                rinsing_repeats=0,
+                solid=False,
+                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 in G.nodes():
+                    if 'data' not in G.nodes[filtrate_vessel]:
+                        G.nodes[filtrate_vessel]['data'] = {}
+                    
+                    current_filtrate_volume = G.nodes[filtrate_vessel]['data'].get('liquid_volume', 0.0)
+                    if isinstance(current_filtrate_volume, list):
+                        if len(current_filtrate_volume) > 0:
+                            G.nodes[filtrate_vessel]['data']['liquid_volume'][0] += expected_filtrate_volume
+                        else:
+                            G.nodes[filtrate_vessel]['data']['liquid_volume'] = [expected_filtrate_volume]
+                    else:
+                        G.nodes[filtrate_vessel]['data']['liquid_volume'] = current_filtrate_volume + expected_filtrate_volume
+                    
+                    debug_print(f"  📊 滤液容器 {filtrate_vessel} 体积增加 {expected_filtrate_volume:.2f}mL")
+                
+            else:
+                debug_print("  ⚠️ 收集协议返回空序列 🤔")
+                
+        except Exception as e:
+            debug_print(f"  ❌ 收集滤液失败: {str(e)} 😞")
+            debug_print("  🔄 继续执行，可能滤液直接流入指定容器 🤞")
+    else:
+        debug_print("  🧱 未指定滤液容器，固体保留在过滤器中 🔬")
     
-    print(f"FILTER: 生成了 {len(action_sequence)} 个动作")
-    print(f"FILTER: 过滤协议生成完成")
+    # 🔧 新增：过滤完成后的容器状态更新
+    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"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            final_vessel_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            final_vessel_volume = current_volume
+    
+    # === 总结 ===
+    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 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
 
-
-# 便捷函数：常用过滤方案
-def generate_gravity_filter_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    filtrate_vessel: str = ""
-) -> List[Dict[str, Any]]:
-    """重力过滤：室温，无搅拌"""
-    return generate_filter_protocol(G, vessel, filtrate_vessel, False, 0.0, 25.0, False, 0.0)
-
-
-def generate_hot_filter_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    filtrate_vessel: str = "",
-    temp: float = 60.0
-) -> List[Dict[str, Any]]:
-    """热过滤：高温过滤，防止结晶析出"""
-    return generate_filter_protocol(G, vessel, filtrate_vessel, False, 0.0, temp, False, 0.0)
-
-
-def generate_stirred_filter_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    filtrate_vessel: str = "",
-    stir_speed: float = 200.0
-) -> List[Dict[str, Any]]:
-    """搅拌过滤：低速搅拌，防止滤饼堵塞"""
-    return generate_filter_protocol(G, vessel, filtrate_vessel, True, stir_speed, 25.0, False, 0.0)
-
-
-def generate_hot_stirred_filter_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    filtrate_vessel: str = "",
-    temp: float = 60.0,
-    stir_speed: float = 300.0
-) -> List[Dict[str, Any]]:
-    """热搅拌过滤：高温搅拌过滤"""
-    return generate_filter_protocol(G, vessel, filtrate_vessel, True, stir_speed, temp, False, 0.0)

unilabos/compile/heatchill_protocol.py

@@ -1,373 +1,405 @@
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Union
 import networkx as nx
+import logging
+import re
 
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    print(f"🌡️ [HEATCHILL] {message}", flush=True)
+    logger.info(f"[HEATCHILL] {message}")
+
+def parse_time_input(time_input: Union[str, float, int]) -> float:
+    """
+    解析时间输入（统一函数）
+    
+    Args:
+        time_input: 时间输入（如 "30 min", "1 h", "300", "?", 60.0）
+    
+    Returns:
+        float: 时间（秒）
+    """
+    if not time_input:
+        return 300.0
+    
+    # 🔢 处理数值输入
+    if isinstance(time_input, (int, float)):
+        result = float(time_input)
+        debug_print(f"⏰ 数值时间: {time_input} → {result}s")
+        return result
+    
+    # 📝 处理字符串输入
+    time_str = str(time_input).lower().strip()
+    debug_print(f"🔍 解析时间: '{time_str}'")
+    
+    # ❓ 特殊值处理
+    special_times = {
+        '?': 300.0, 'unknown': 300.0, 'tbd': 300.0,
+        'overnight': 43200.0, 'several hours': 10800.0, 
+        'few hours': 7200.0, 'long time': 3600.0, 'short time': 300.0
+    }
+    
+    if time_str in special_times:
+        result = special_times[time_str]
+        debug_print(f"🎯 特殊时间: '{time_str}' → {result}s ({result/60:.1f}分钟)")
+        return result
+    
+    # 🔢 纯数字处理
+    try:
+        result = float(time_str)
+        debug_print(f"⏰ 纯数字: {time_str} → {result}s")
+        return result
+    except ValueError:
+        pass
+    
+    # 📐 正则表达式解析
+    pattern = r'(\d+\.?\d*)\s*([a-z]*)'
+    match = re.match(pattern, time_str)
+    
+    if not match:
+        debug_print(f"⚠️ 无法解析时间: '{time_str}'，使用默认值: 300s")
+        return 300.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or 's'
+    
+    # 📏 单位转换
+    unit_multipliers = {
+        's': 1.0, 'sec': 1.0, 'second': 1.0, 'seconds': 1.0,
+        'm': 60.0, 'min': 60.0, 'mins': 60.0, 'minute': 60.0, 'minutes': 60.0,
+        'h': 3600.0, 'hr': 3600.0, 'hrs': 3600.0, 'hour': 3600.0, 'hours': 3600.0,
+        'd': 86400.0, 'day': 86400.0, 'days': 86400.0
+    }
+    
+    multiplier = unit_multipliers.get(unit, 1.0)
+    result = value * multiplier
+    
+    debug_print(f"✅ 时间解析: '{time_str}' → {value} {unit} → {result}s ({result/60:.1f}分钟)")
+    return result
+
+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:
-    """
-    查找与指定容器相连的加热/冷却设备
-    """
-    # 查找所有加热/冷却设备节点
-    heatchill_nodes = [node for node in G.nodes() 
-                      if (G.nodes[node].get('class') or '') == 'virtual_heatchill']
+    """查找与指定容器相连的加热/冷却设备"""
+    debug_print(f"🔍 查找加热设备，目标容器: {vessel}")
     
-    # 检查哪个加热/冷却设备与目标容器相连（机械连接）
-    for heatchill in heatchill_nodes:
-        if G.has_edge(heatchill, vessel) or G.has_edge(vessel, heatchill):
-            return heatchill
+    # 🔧 查找所有加热设备
+    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:
-        return heatchill_nodes[0]
+        selected = heatchill_nodes[0]
+        debug_print(f"🔧 使用第一个加热设备: {selected}")
+        return selected
     
-    raise ValueError("系统中未找到可用的加热/冷却设备")
+    # 🆘 默认设备
+    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(
     G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    time: float,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    temp: float = 25.0,
+    time: Union[str, float] = "300",
+    temp_spec: str = "",
+    time_spec: str = "",
+    pressure: str = "",
+    reflux_solvent: str = "",
     stir: bool = False,
     stir_speed: float = 300.0,
-    purpose: str = "加热/冷却操作"
+    purpose: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成加热/冷却操作的协议序列 - 带时间限制的完整操作
+    生成加热/冷却操作的协议序列 - 支持vessel字典
+    
+    Args:
+        G: 设备图
+        vessel: 容器字典（从XDL传入）
+        temp: 目标温度 (°C)
+        time: 加热时间（支持字符串如 "30 min"）
+        temp_spec: 温度规格说明（优先级高于temp）
+        time_spec: 时间规格说明（优先级高于time）
+        pressure: 压力设置
+        reflux_solvent: 回流溶剂
+        stir: 是否搅拌
+        stir_speed: 搅拌速度 (RPM)
+        purpose: 操作目的说明
+        **kwargs: 其他参数（兼容性）
+    
+    Returns:
+        List[Dict[str, Any]]: 加热/冷却操作的动作序列
     """
-    action_sequence = []
     
-    print(f"HEATCHILL: 开始生成加热/冷却协议")
-    print(f"  - 容器: {vessel}")
-    print(f"  - 目标温度: {temp}°C")
-    print(f"  - 持续时间: {time}秒")
-    print(f"  - 使用内置搅拌: {stir}, 速度: {stir_speed} RPM")
-    print(f"  - 目的: {purpose}")
+    # 🔧 核心修改：从字典中提取容器ID
+    # 统一处理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 = G.nodes[vessel_id].get("data", {}) if vessel_id in G.nodes() else {}
     
-    # 1. 验证容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
+    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)
     
-    # 2. 查找加热/冷却设备
+    # 📋 参数验证
+    debug_print("📍 步骤1: 参数验证... 🔧")
+    if not vessel_id:  # 🔧 使用 vessel_id
+        debug_print("❌ vessel 参数不能为空! 😱")
+        raise ValueError("vessel 参数不能为空")
+    
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print(f"❌ 容器 '{vessel_id}' 不存在于系统中! 😞")
+        raise ValueError(f"容器 '{vessel_id}' 不存在于系统中")
+    
+    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("📍 步骤3: 查找加热设备... 🔍")
     try:
-        heatchill_id = find_connected_heatchill(G, vessel)
-        print(f"HEATCHILL: 找到加热/冷却设备: {heatchill_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到加热/冷却设备: {str(e)}")
+        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)}")
     
-    # 3. 执行加热/冷却操作
+    # 🚀 生成动作
+    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/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": vessel,
-            "temp": temp,
-            "time": time,
-            "stir": stir,
-            "stir_speed": stir_speed,
-            "status": "start"
+            "vessel": vessel_id,  # 🔧 使用 vessel_id
+            "temp": float(final_temp),
+            "time": float(final_time),
+            "stir": bool(stir),
+            "stir_speed": float(stir_speed),
+            "purpose": str(purpose or f"加热到 {final_temp}°C") + (f" (模拟时间: {final_time}s)" if original_time != final_time else "")
         }
     }
-    
     action_sequence.append(heatchill_action)
+    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)
     
-    print(f"HEATCHILL: 生成了 {len(action_sequence)} 个动作")
     return action_sequence
 
-
-def generate_heat_chill_start_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    purpose: str = "开始加热/冷却"
-) -> List[Dict[str, Any]]:
-    """
-    生成开始加热/冷却操作的协议序列
-    """
-    action_sequence = []
-    
-    print(f"HEATCHILL_START: 开始生成加热/冷却启动协议")
-    print(f"  - 容器: {vessel}")
-    print(f"  - 目标温度: {temp}°C")
-    print(f"  - 目的: {purpose}")
-    
-    # 1. 验证容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
-    
-    # 2. 查找加热/冷却设备
-    try:
-        heatchill_id = find_connected_heatchill(G, vessel)
-        print(f"HEATCHILL_START: 找到加热/冷却设备: {heatchill_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到加热/冷却设备: {str(e)}")
-    
-    # 3. 执行开始加热/冷却操作
-    heatchill_start_action = {
-        "device_id": heatchill_id,
-        "action_name": "heat_chill_start",
-        "action_kwargs": {
-            "vessel": vessel,
-            "temp": temp,
-            "purpose": purpose
-        }
-    }
-    
-    action_sequence.append(heatchill_start_action)
-    
-    print(f"HEATCHILL_START: 生成了 {len(action_sequence)} 个动作")
-    return action_sequence
-
-
-def generate_heat_chill_stop_protocol(
-    G: nx.DiGraph,
-    vessel: str
-) -> List[Dict[str, Any]]:
-    """
-    生成停止加热/冷却操作的协议序列
-    """
-    action_sequence = []
-    
-    print(f"HEATCHILL_STOP: 开始生成加热/冷却停止协议")
-    print(f"  - 容器: {vessel}")
-    
-    # 1. 验证容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
-    
-    # 2. 查找加热/冷却设备
-    try:
-        heatchill_id = find_connected_heatchill(G, vessel)
-        print(f"HEATCHILL_STOP: 找到加热/冷却设备: {heatchill_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到加热/冷却设备: {str(e)}")
-    
-    # 3. 执行停止加热/冷却操作
-    heatchill_stop_action = {
-        "device_id": heatchill_id,
-        "action_name": "heat_chill_stop",
-        "action_kwargs": {
-            "vessel": vessel
-        }
-    }
-    
-    action_sequence.append(heatchill_stop_action)
-    
-    print(f"HEATCHILL_STOP: 生成了 {len(action_sequence)} 个动作")
-    return action_sequence
-
-
 def generate_heat_chill_to_temp_protocol(
     G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    active: bool = True,
-    continue_heatchill: bool = False,
-    stir: bool = False,
-    stir_speed: Optional[float] = None,
-    purpose: Optional[str] = None
+    vessel: dict,  # 🔧 修改参数类型
+    temp: float = 25.0,
+    time: Union[str, float] = 100.0,
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成加热/冷却到指定温度的协议序列 - 智能温控协议
+    """生成加热到指定温度的协议（简化版）"""
+    vessel_id = vessel["id"]
+    debug_print(f"🌡️ 生成加热到温度协议: {vessel_id} → {temp}°C")
+    return generate_heat_chill_protocol(G, vessel, temp, time, **kwargs)
+
+def generate_heat_chill_start_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改参数类型
+    temp: float = 25.0,
+    purpose: str = "",
+    **kwargs
+) -> List[Dict[str, Any]]:
+    """生成开始加热操作的协议序列"""
     
-    **关键修复**: 学习 pump_protocol 的模式，直接使用设备基础动作，不依赖特定的 Action 文件
-    """
-    action_sequence = []
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id = vessel["id"]
     
-    # 设置默认值
-    if stir_speed is None:
-        stir_speed = 300.0
-    if purpose is None:
-        purpose = f"智能温控到 {temp}°C"
+    debug_print("🔥 开始生成启动加热协议 ✨")
+    debug_print(f"🥽 vessel: {vessel} (ID: {vessel_id}), 🌡️ temp: {temp}°C")
     
-    print(f"HEATCHILL_TO_TEMP: 开始生成智能温控协议")
-    print(f"  - 容器: {vessel}")
-    print(f"  - 目标温度: {temp}°C")
-    print(f"  - 主动控温: {active}")
-    print(f"  - 达到温度后继续: {continue_heatchill}")
-    print(f"  - 搅拌: {stir}, 速度: {stir_speed} RPM")
-    print(f"  - 目的: {purpose}")
+    # 基础验证
+    if not vessel_id or vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print("❌ 容器验证失败!")
+        raise ValueError("vessel 参数无效")
     
-    # 1. 验证容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
+    # 查找设备
+    heatchill_id = find_connected_heatchill(G, vessel_id)  # 🔧 使用 vessel_id
     
-    # 2. 查找加热/冷却设备
-    try:
-        heatchill_id = find_connected_heatchill(G, vessel)
-        print(f"HEATCHILL_TO_TEMP: 找到加热/冷却设备: {heatchill_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到加热/冷却设备: {str(e)}")
+    # 生成动作
+    action_sequence = [{
+        "device_id": heatchill_id,
+        "action_name": "heat_chill_start",
+        "action_kwargs": {
+            "vessel": vessel_id,  # 🔧 使用 vessel_id
+            "temp": temp,
+            "purpose": purpose or f"开始加热到 {temp}°C"
+        }
+    }]
     
-    # 3. 根据参数选择合适的基础动作组合 (学习 pump_protocol 的模式)
-    if not active:
-        print(f"HEATCHILL_TO_TEMP: 非主动模式，仅等待")
-        action_sequence.append({
-            "action_name": "wait",
-            "action_kwargs": {
-                "time": 10.0,
-                "purpose": f"等待容器 {vessel} 自然达到 {temp}°C"
-            }
-        })
-    else:
-        if continue_heatchill:
-            # 持续模式：使用 heat_chill_start 基础动作
-            print(f"HEATCHILL_TO_TEMP: 使用持续温控模式")
-            action_sequence.append({
-                "device_id": heatchill_id,
-                "action_name": "heat_chill_start",  # ← 直接使用设备基础动作
-                "action_kwargs": {
-                    "vessel": vessel,
-                    "temp": temp,
-                    "purpose": f"{purpose} (持续保温)"
-                }
-            })
-        else:
-            # 一次性模式：使用 heat_chill 基础动作
-            print(f"HEATCHILL_TO_TEMP: 使用一次性温控模式")
-            estimated_time = max(60.0, min(900.0, abs(temp - 25.0) * 30.0))
-            print(f"HEATCHILL_TO_TEMP: 估算所需时间: {estimated_time}秒")
-            
-            action_sequence.append({
-                "device_id": heatchill_id,
-                "action_name": "heat_chill",  # ← 直接使用设备基础动作
-                "action_kwargs": {
-                    "vessel": vessel,
-                    "temp": temp,
-                    "time": estimated_time,
-                    "stir": stir,
-                    "stir_speed": stir_speed,
-                    "status": "start"
-                }
-            })
-    
-    print(f"HEATCHILL_TO_TEMP: 生成了 {len(action_sequence)} 个动作")
+    debug_print(f"✅ 启动加热协议生成完成 🎯")
     return action_sequence
 
-
-# 扩展版本的加热/冷却协议，集成智能温控功能
-def generate_smart_heat_chill_protocol(
+def generate_heat_chill_stop_protocol(
     G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    time: float = 0.0,  # 0表示自动估算
-    active: bool = True,
-    continue_heatchill: bool = False,
-    stir: bool = False,
-    stir_speed: float = 300.0,
-    purpose: str = "智能加热/冷却"
+    vessel: dict,  # 🔧 修改参数类型
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    这个函数集成了 generate_heat_chill_to_temp_protocol 的智能逻辑，
-    但使用现有的 Action 类型
-    """
-    # 如果时间为0，自动估算
-    if time == 0.0:
-        estimated_time = max(60.0, min(900.0, abs(temp - 25.0) * 30.0))
-        time = estimated_time
+    """生成停止加热操作的协议序列"""
     
-    if continue_heatchill:
-        # 使用持续模式
-        return generate_heat_chill_start_protocol(G, vessel, temp, purpose)
-    else:
-        # 使用定时模式
-        return generate_heat_chill_protocol(G, vessel, temp, time, stir, stir_speed, purpose)
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id = vessel["id"]
+    
+    debug_print("🛑 开始生成停止加热协议 ✨")
+    debug_print(f"🥽 vessel: {vessel} (ID: {vessel_id})")
+    
+    # 基础验证
+    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)  # 🔧 使用 vessel_id
+    
+    # 生成动作
+    action_sequence = [{
+        "device_id": heatchill_id,
+        "action_name": "heat_chill_stop",
+        "action_kwargs": {
+            "vessel": vessel_id  # 🔧 使用 vessel_id
+        }
+    }]
+    
+    debug_print(f"✅ 停止加热协议生成完成 🎯")
+    return action_sequence
 
-
-# 便捷函数
-def generate_heating_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    time: float = 300.0,
-    stir: bool = True,
-    stir_speed: float = 300.0
-) -> List[Dict[str, Any]]:
-    """生成加热协议的便捷函数"""
-    return generate_heat_chill_protocol(
-        G=G, vessel=vessel, temp=temp, time=time, 
-        stir=stir, stir_speed=stir_speed, purpose=f"加热到 {temp}°C"
-    )
-
-
-def generate_cooling_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    time: float = 600.0,
-    stir: bool = True,
-    stir_speed: float = 200.0
-) -> List[Dict[str, Any]]:
-    """生成冷却协议的便捷函数"""
-    return generate_heat_chill_protocol(
-        G=G, vessel=vessel, temp=temp, time=time,
-        stir=stir, stir_speed=stir_speed, purpose=f"冷却到 {temp}°C"
-    )
-
-
-# # 温度预设快捷函数
-# def generate_room_temp_protocol(
-#     G: nx.DiGraph,
-#     vessel: str,
-#     stir: bool = False
-# ) -> List[Dict[str, Any]]:
-#     """返回室温的快捷函数"""
-#     return generate_heat_chill_to_temp_protocol(
-#         G=G,
-#         vessel=vessel,
-#         temp=25.0,
-#         active=True,
-#         continue_heatchill=False,
-#         stir=stir,
-#         purpose="冷却到室温"
-#     )
-
-
-# def generate_reflux_heating_protocol(
-#     G: nx.DiGraph,
-#     vessel: str,
-#     temp: float,
-#     time: float = 3600.0  # 1小时回流
-# ) -> List[Dict[str, Any]]:
-#     """回流加热的快捷函数"""
-#     return generate_heat_chill_protocol(
-#         G=G,
-#         vessel=vessel,
-#         temp=temp,
-#         time=time,
-#         stir=True,
-#         stir_speed=400.0,  # 回流时较快搅拌
-#         purpose=f"回流加热到 {temp}°C"
-#     )
-
-
-# def generate_ice_bath_protocol(
-#     G: nx.DiGraph,
-#     vessel: str,
-#     time: float = 600.0  # 10分钟冰浴
-# ) -> List[Dict[str, Any]]:
-#     """冰浴冷却的快捷函数"""
-#     return generate_heat_chill_protocol(
-#         G=G,
-#         vessel=vessel,
-#         temp=0.0,
-#         time=time,
-#         stir=True,
-#         stir_speed=150.0,  # 冰浴时缓慢搅拌
-#         purpose="冰浴冷却到 0°C"
-#     )
-
-
-# 测试函数
-def test_heatchill_protocol():
-    """测试加热/冷却协议的示例"""
-    print("=== HEAT CHILL PROTOCOL 测试 ===")
-    print("完整的四个协议函数：")
-    print("1. generate_heat_chill_protocol - 带时间限制的完整操作")
-    print("2. generate_heat_chill_start_protocol - 持续加热/冷却")
-    print("3. generate_heat_chill_stop_protocol - 停止加热/冷却")
-    print("4. generate_heat_chill_to_temp_protocol - 智能温控 (您的 HeatChillToTemp)")
-    print("测试完成")
-
-
-if __name__ == "__main__":
-    test_heatchill_protocol()

unilabos/compile/hydrogenate_protocol.py

@@ -0,0 +1,466 @@
+import networkx as nx
+from typing import List, Dict, Any, Optional
+
+
+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() 
+        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']
+        device_class = 'virtual_heatchill'
+    elif device_type == 'stirrer':
+        keywords = ['stirrer', 'stir']
+        device_class = 'virtual_stirrer'
+    elif device_type == 'gas_source':
+        keywords = ['gas', 'h2', 'hydrogen']
+        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)
+    
+    print(f"HYDROGENATE: 找到的{device_type}节点: {device_nodes}")
+    
+    # 检查是否有设备与目标容器相连
+    for device in device_nodes:
+        if G.has_edge(device, vessel) or G.has_edge(vessel, 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个中间节点
+                print(f"HYDROGENATE: 找到距离较近的{device_type}: {device}")
+                return device
+        except nx.NetworkXNoPath:
+            continue
+    
+    print(f"HYDROGENATE: 未找到与容器 '{vessel}' 相连的{device_type}")
+    return None
+
+
+def generate_hydrogenate_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    temp: str,
+    time: str,
+    **kwargs  # 接收其他可能的参数但不使用
+) -> List[Dict[str, Any]]:
+    """
+    生成氢化反应协议序列 - 支持vessel字典
+    
+    Args:
+        G: 有向图，节点为容器和设备
+        vessel: 反应容器字典（从XDL传入）
+        temp: 反应温度（如 "45 °C"）
+        time: 反应时间（如 "2 h"）
+        **kwargs: 其他可选参数，但不使用
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
+    """
+    
+    # 🔧 核心修改：从字典中提取容器ID
+    # 统一处理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 = G.nodes[vessel_id].get("data", {}) if vessel_id in G.nodes() else {}
+    
+    action_sequence = []
+    
+    # 解析参数
+    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"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            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("📍 步骤1: 验证目标容器...")
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        print(f"⚠️ HYDROGENATE: 警告 - 容器 '{vessel_id}' 不存在于系统中，跳过氢化反应")
+        return action_sequence
+    print(f"✅ 容器 '{vessel_id}' 验证通过")
+    
+    # 2. 查找相连的设备
+    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": vessel_id,  # 🔧 使用 vessel_id
+                "stir_speed": 300.0,
+                "purpose": "氢化反应: 开始搅拌"
+            }
+        })
+        print("✅ 搅拌器启动动作已添加")
+    else:
+        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",
+            "action_kwargs": {
+                "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",
+                "action_kwargs": {
+                    "command": "OPEN"
+                }
+            })
+        print("✅ 氢气源启动动作已添加")
+    else:
+        print(f"⚠️ HYDROGENATE: 警告 - 未找到气源，继续执行")
+    
+    # 5. 等待气体稳定
+    print("📍 步骤5: 等待气体环境稳定...")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": 30.0,
+            "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": vessel_id,  # 🔧 使用 vessel_id
+                "temp": temperature,
+                "purpose": f"氢化反应: 加热到 {temperature}°C"
+            }
+        })
+        
+        # 等待温度稳定
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {
+                "time": 20.0,
+                "description": f"等待温度稳定到 {temperature}°C"
+            }
+        })
+        
+        # 🕐 模拟运行时间优化
+        print("  ⏰ 检查模拟运行时间限制...")
+        original_reaction_time = reaction_time
+        simulation_time_limit = 60.0  # 模拟运行时间限制：60秒
+        
+        if reaction_time > simulation_time_limit:
+            reaction_time = simulation_time_limit
+            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": 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:
+        print(f"⚠️ HYDROGENATE: 警告 - 未找到加热器，使用室温反应")
+        
+        # 🕐 室温反应也需要时间优化
+        print("  ⏰ 检查室温反应模拟时间限制...")
+        original_reaction_time = reaction_time
+        simulation_time_limit = 60.0  # 模拟运行时间限制：60秒
+        
+        if reaction_time > simulation_time_limit:
+            reaction_time = simulation_time_limit
+            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",
+            "action_kwargs": {
+                "time": reaction_time,
+                "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": vessel_id,  # 🔧 使用 vessel_id
+                "purpose": "氢化反应完成，停止加热"
+            }
+        })
+        print("✅ 停止加热动作已添加")
+    
+    # 8. 等待冷却
+    print("📍 步骤8: 等待冷却...")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": 300.0,
+            "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",
+                "action_kwargs": {
+                    "command": "CLOSED"
+                }
+            })
+        
+        # 再关闭气源
+        action_sequence.append({
+            "device_id": gas_source_id,
+            "action_name": "set_status",
+            "action_kwargs": {
+                "string": "OFF"
+            }
+        })
+        print("✅ 氢气源停止动作已添加")
+    
+    # 10. 停止搅拌
+    print("📍 步骤10: 停止搅拌...")
+    if stirrer_id:
+        action_sequence.append({
+            "device_id": stirrer_id,
+            "action_name": "stop_stir",
+            "action_kwargs": {
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
+                "purpose": "氢化反应完成，停止搅拌"
+            }
+        })
+        print("✅ 停止搅拌动作已添加")
+    
+    # 🔧 新增：氢化完成后的状态（氢化反应通常不改变体积）
+    final_liquid_volume = original_liquid_volume  # 氢化反应体积基本不变
+    
+    # 总结
+    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()

unilabos/compile/recrystallize_protocol.py

@@ -0,0 +1,598 @@
+import networkx as nx
+import re
+import logging
+from typing import List, Dict, Any, Tuple, Union
+from .pump_protocol import generate_pump_protocol_with_rinsing
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    print(f"💎 [RECRYSTALLIZE] {message}", flush=True)
+    logger.info(f"[RECRYSTALLIZE] {message}")
+
+
+def parse_volume_with_units(volume_input: Union[str, float, int], default_unit: str = "mL") -> float:
+    """
+    解析带单位的体积输入
+    
+    Args:
+        volume_input: 体积输入（如 "100 mL", "2.5 L", "500", "?", 100.0）
+        default_unit: 默认单位（默认为毫升）
+    
+    Returns:
+        float: 体积（毫升）
+    """
+    if not volume_input:
+        debug_print("⚠️ 体积输入为空，返回 0.0mL 📦")
+        return 0.0
+    
+    # 处理数值输入
+    if isinstance(volume_input, (int, float)):
+        result = float(volume_input)
+        debug_print(f"🔢 数值体积输入: {volume_input} → {result}mL（默认单位）💧")
+        return result
+    
+    # 处理字符串输入
+    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
+    
+    # 如果是纯数字，使用默认单位
+    try:
+        value = float(volume_str)
+        if default_unit.lower() in ["ml", "milliliter"]:
+            result = value
+        elif default_unit.lower() in ["l", "liter"]:
+            result = value * 1000.0
+        elif default_unit.lower() in ["μl", "ul", "microliter"]:
+            result = value / 1000.0
+        else:
+            result = value  # 默认mL
+        debug_print(f"🔢 纯数字输入: {volume_str} → {result}mL（单位: {default_unit}）📏")
+        return result
+    except ValueError:
+        pass
+    
+    # 移除空格并提取数字和单位
+    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 default_unit.lower()
+    
+    # 转换为毫升
+    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"📏 毫升单位: {value}mL → {volume}mL 💧")
+    
+    debug_print(f"✅ 体积解析完成: '{volume_str}' → {volume}mL ✨")
+    return volume
+
+
+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
+        
+        # 默认 1:1
+        debug_print(f"⚠️ 无法解析比例 '{ratio_str}'，使用默认比例 1:1 🎭")
+        return 1.0, 1.0
+    
+    except ValueError:
+        debug_print(f"❌ 比例解析错误 '{ratio_str}'，使用默认比例 1:1 🎭")
+        return 1.0, 1.0
+
+
+def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
+    """
+    查找溶剂容器
+    
+    Args:
+        G: 网络图
+        solvent: 溶剂名称
+    
+    Returns:
+        str: 溶剂容器ID
+    """
+    debug_print(f"🔍 正在查找溶剂 '{solvent}' 的容器... 🧪")
+    
+    # 构建可能的容器名称
+    possible_names = [
+        f"flask_{solvent}",
+        f"bottle_{solvent}",
+        f"reagent_{solvent}",
+        f"reagent_bottle_{solvent}",
+        f"{solvent}_flask",
+        f"{solvent}_bottle",
+        f"{solvent}",
+        f"vessel_{solvent}",
+    ]
+    
+    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
+    
+    # 第二步：通过模糊匹配（节点ID和名称）
+    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} (名称: {node_name}) ✨")
+                return node_id
+    
+    # 第三步：通过配置中的试剂信息匹配
+    debug_print("  🧪 步骤3: 配置试剂信息匹配...")
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            # 检查 config 中的 reagent 字段
+            node_config = G.nodes[node_id].get('config', {})
+            config_reagent = node_config.get('reagent', '').lower()
+            
+            if config_reagent and solvent.lower() == config_reagent:
+                debug_print(f"  🎉 通过config.reagent匹配找到容器: {node_id} (试剂: {config_reagent}) ✨")
+                return node_id
+    
+    # 第四步：通过数据中的试剂信息匹配
+    debug_print("  🧪 步骤4: 数据试剂信息匹配...")
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            vessel_data = G.nodes[node_id].get('data', {})
+            
+            # 检查 data 中的 reagent_name 字段
+            reagent_name = vessel_data.get('reagent_name', '').lower()
+            if reagent_name and solvent.lower() == reagent_name:
+                debug_print(f"  🎉 通过data.reagent_name匹配找到容器: {node_id} (试剂: {reagent_name}) ✨")
+                return node_id
+            
+            # 检查 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()
+                    
+                    if solvent.lower() in liquid_type:
+                        debug_print(f"  🎉 通过液体类型匹配找到容器: {node_id} (液体类型: {liquid_type}) ✨")
+                        return node_id
+    
+    # 第五步：部分匹配（如果前面都没找到）
+    debug_print("  🔍 步骤5: 部分匹配...")
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            node_config = G.nodes[node_id].get('config', {})
+            node_data = G.nodes[node_id].get('data', {})
+            node_name = G.nodes[node_id].get('name', '').lower()
+            
+            config_reagent = node_config.get('reagent', '').lower()
+            data_reagent = node_data.get('reagent_name', '').lower()
+            
+            # 检查是否包含溶剂名称
+            if (solvent.lower() in config_reagent or 
+                solvent.lower() in data_reagent or 
+                solvent.lower() in node_name or
+                solvent.lower() in node_id.lower()):
+                debug_print(f"  🎉 通过部分匹配找到容器: {node_id} ✨")
+                debug_print(f"    - 节点名称: {node_name}")
+                debug_print(f"    - 配置试剂: {config_reagent}")
+                debug_print(f"    - 数据试剂: {data_reagent}")
+                return node_id
+    
+    # 调试信息：列出所有容器
+    debug_print("  🔎 调试信息：列出所有容器...")
+    container_list = []
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            node_config = G.nodes[node_id].get('config', {})
+            node_data = G.nodes[node_id].get('data', {})
+            node_name = G.nodes[node_id].get('name', '')
+            
+            container_info = {
+                'id': node_id,
+                'name': node_name,
+                'config_reagent': node_config.get('reagent', ''),
+                'data_reagent': node_data.get('reagent_name', '')
+            }
+            container_list.append(container_info)
+            debug_print(f"    - 容器: {node_id}, 名称: {node_name}, config试剂: {node_config.get('reagent', '')}, data试剂: {node_data.get('reagent_name', '')}")
+    
+    debug_print(f"❌ 找不到溶剂 '{solvent}' 对应的容器 😭")
+    debug_print(f"🔍 查找的溶剂: '{solvent}' (小写: '{solvent.lower()}')")
+    debug_print(f"📊 总共发现 {len(container_list)} 个容器")
+    
+    raise ValueError(f"找不到溶剂 '{solvent}' 对应的容器")
+
+
+def generate_recrystallize_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    ratio: str,
+    solvent1: str,
+    solvent2: str,
+    volume: Union[str, float],  # 支持字符串和数值
+    **kwargs
+) -> List[Dict[str, Any]]:
+    """
+    生成重结晶协议序列 - 支持vessel字典和体积运算
+    
+    Args:
+        G: 有向图，节点为容器和设备
+        vessel: 目标容器字典（从XDL传入）
+        ratio: 溶剂比例（如 "1:1", "3:7"）
+        solvent1: 第一种溶剂名称
+        solvent2: 第二种溶剂名称
+        volume: 总体积（支持 "100 mL", "50", "2.5 L" 等）
+        **kwargs: 其他可选参数
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
+    """
+    
+    # 🔧 核心修改：从字典中提取容器ID
+    # 统一处理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 = G.nodes[vessel_id].get("data", {}) if vessel_id in G.nodes() else {}
+    
+    action_sequence = []
+    
+    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"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            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: 验证目标容器... 🔧")
+    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_with_units(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 ({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)  # 🔧 使用 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)  # 🔧 使用 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,  # 🔧 使用 vessel_id
+            volume=volume1,             # 使用解析后的体积
+            amount="",
+            time=0.0,
+            viscous=False,
+            rinsing_solvent="",  # 重结晶不需要清洗
+            rinsing_volume=0.0,
+            rinsing_repeats=0,
+            solid=False,
+            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后
+    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):
+            if len(current_volume) > 0:
+                vessel["data"]["liquid_volume"][0] = new_volume_after_solvent1
+            else:
+                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
+            else:
+                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,  # 缩短等待时间
+            "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,  # 🔧 使用 vessel_id
+            volume=volume2,             # 使用解析后的体积
+            amount="",
+            time=0.0,
+            viscous=False,
+            rinsing_solvent="",  # 重结晶不需要清洗
+            rinsing_volume=0.0,
+            rinsing_repeats=0,
+            solid=False,
+            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后
+    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):
+            if len(current_volume) > 0:
+                vessel["data"]["liquid_volume"][0] = final_liquid_volume
+            else:
+                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
+            else:
+                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,  # 缩短等待时间
+            "description": f"等待溶剂2 {solvent2} 稳定"
+        }
+    })
+    debug_print("  ✅ 溶剂2稳定等待已添加 ⏰✨")
+    
+    # 11. 等待重结晶完成
+    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/60:.1f}分钟 → {final_crystallize_time/60:.1f}分钟 🚀")
+    else:
+        debug_print(f"  ✅ 时间在限制内: {final_crystallize_time}s 保持不变 🎯")
+    
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": final_crystallize_time,
+            "description": f"等待重结晶完成（{solvent1}:{solvent2} = {ratio}，总体积 {final_volume}mL）" + (f" (模拟时间)" if original_crystallize_time != final_crystallize_time else "")
+        }
+    })
+    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("💧 测试体积解析...")
+    test_volumes = ["100 mL", "2.5 L", "500", "50.5", "?", "invalid"]
+    for vol in test_volumes:
+        parsed = parse_volume_with_units(vol)
+        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("✅ 测试完成 🎉")
+
+if __name__ == "__main__":
+    test_recrystallize_protocol()

unilabos/compile/reset_handling_protocol.py

@@ -0,0 +1,387 @@
+import networkx as nx
+import logging
+import sys
+from typing import List, Dict, Any, Optional
+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)
+        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,  # 🆕 新增可选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
+
+    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(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(create_action_log("使用默认目标容器: main_reactor", "⚙️"))
+    else:
+        action_sequence.append(create_action_log(f"使用指定目标容器: {vessel}", "🎯"))
+    
+    # 1. 验证目标容器存在
+    debug_print("🔍 步骤1: 验证目标容器...")
+    action_sequence.append(create_action_log("正在验证目标容器...", "🔍"))
+    
+    if target_vessel not in G.nodes():
+        debug_print(f"❌ 目标容器 '{target_vessel}' 不存在于系统中!")
+        action_sequence.append(create_action_log(f"目标容器 '{target_vessel}' 不存在", "❌"))
+        raise ValueError(f"目标容器 '{target_vessel}' 不存在于系统中")
+    
+    debug_print(f"✅ 目标容器 '{target_vessel}' 验证通过")
+    action_sequence.append(create_action_log(f"目标容器验证通过: {target_vessel}", "✅"))
+    
+    # 2. 查找溶剂容器
+    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(create_action_log(f"找到溶剂容器: {solvent_vessel}", "✅"))
+    except ValueError as e:
+        debug_print(f"❌ 溶剂容器查找失败: {str(e)}")
+        action_sequence.append(create_action_log(f"溶剂容器查找失败: {str(e)}", "❌"))
+        raise ValueError(f"无法找到溶剂 '{solvent}': {str(e)}")
+    
+    # 3. 验证路径存在
+    debug_print("🔍 步骤3: 验证传输路径...")
+    action_sequence.append(create_action_log("正在验证传输路径...", "🛤️"))
+    
+    try:
+        path = nx.shortest_path(G, source=solvent_vessel, target=target_vessel)
+        debug_print(f"✅ 找到路径: {' → '.join(path)}")
+        action_sequence.append(create_action_log(f"传输路径: {' → '.join(path)}", "🛤️"))
+    except nx.NetworkXNoPath:
+        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转移溶剂
+    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:
+        debug_print("🔄 生成泵送协议...")
+        action_sequence.append(create_action_log("正在生成泵送协议...", "🔄"))
+        
+        pump_actions = generate_pump_protocol_with_rinsing(
+            G=G,
+            from_vessel=solvent_vessel,
+            to_vessel=target_vessel,
+            volume=volume,
+            amount="",
+            time=0.0,
+            viscous=False,
+            rinsing_solvent="",  # 重置处理不需要清洗
+            rinsing_volume=0.0,
+            rinsing_repeats=0,
+            solid=False,
+            flowrate=2.5,  # 正常流速
+            transfer_flowrate=0.5  # 正常转移流速
+        )
+        
+        action_sequence.extend(pump_actions)
+        debug_print(f"✅ 泵送协议已添加: {len(pump_actions)} 个动作")
+        action_sequence.append(create_action_log(f"泵送协议完成 ({len(pump_actions)} 个操作)", "✅"))
+        
+    except Exception as e:
+        debug_print(f"❌ 泵送协议生成失败: {str(e)}")
+        action_sequence.append(create_action_log(f"泵送协议生成失败: {str(e)}", "❌"))
+        raise ValueError(f"生成泵协议时出错: {str(e)}")
+    
+    # 5. 等待溶剂稳定
+    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:
+        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:
+        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": {
+            "time": final_wait_time,
+            "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:
+        debug_print(f"🎭 模拟优化说明: 原计划 {original_wait_time}s，实际模拟 {final_wait_time}s")
+        action_sequence.append(create_action_log("应用模拟时间优化", "🎭"))
+    
+    # 总结
+    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(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("🧪 测试常用溶剂名称...")
+    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()

unilabos/compile/separate_protocol.py

@@ -1,230 +1,749 @@
-import numpy as np
 import networkx as nx
+import re
+import logging
+import sys
+from typing import List, Dict, Any, Union
+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)
+        print(f"🌀 [SEPARATE] {safe_message}", flush=True)
+        logger.info(f"[SEPARATE] {safe_message}")
+    except UnicodeEncodeError:
+        # 如果编码失败，尝试替换不支持的字符
+        safe_message = str(message).encode('utf-8', errors='replace').decode('utf-8')
+        print(f"🌀 [SEPARATE] {safe_message}", flush=True)
+        logger.info(f"[SEPARATE] {safe_message}")
+    except Exception as e:
+        # 最后的安全措施
+        fallback_message = f"日志输出错误: {repr(message)}"
+        print(f"🌀 [SEPARATE] {fallback_message}", flush=True)
+        logger.info(f"[SEPARATE] {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 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",  # 液体处理器也可能用于分离
+        "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：查找第一个分离器设备
+    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 generate_separate_protocol(
-    G: nx.DiGraph, 
-    purpose: str,  # 'wash' or 'extract'. 'wash' means that product phase will not be the added solvent phase, 'extract' means product phase will be the added solvent phase. If no solvent is added just use 'extract'.
-    product_phase: str, # 'top' or 'bottom'. Phase that product will be in.
-    from_vessel: str, #Contents of from_vessel are transferred to separation_vessel and separation is performed.
-    separation_vessel: str, # Vessel in which separation of phases will be carried out.
-    to_vessel: str, # Vessel to send product phase to.
-    waste_phase_to_vessel: str, # Optional. Vessel to send waste phase to.
-    solvent: str, # Optional. Solvent to add to separation vessel after contents of from_vessel has been transferred to create two phases.
-    solvent_volume: float = 50, # Optional. Volume of solvent to add (mL).
-    through: str = "", # Optional. Solid chemical to send product phase through on way to to_vessel, e.g. 'celite'.
-    repeats: int = 1, # Optional. Number of separations to perform.
-    stir_time: float = 30, # Optional. Time stir for after adding solvent, before separation of phases.
-    stir_speed: float = 300, # Optional. Speed to stir at after adding solvent, before separation of phases.
-    settling_time: float = 300 # Optional. Time
-) -> list[dict]:
+    G: nx.DiGraph,
+    # 🔧 基础参数，支持XDL的vessel参数
+    vessel: dict = None,             # 🔧 修改：从字符串改为字典类型
+    purpose: str = "separate",       # 分离目的
+    product_phase: str = "top",      # 产物相
+    # 🔧 可选的详细参数
+    from_vessel: Union[str, dict] = "",   # 源容器（通常在separate前已经transfer了）
+    separation_vessel: Union[str, dict] = "",  # 分离容器（与vessel同义）
+    to_vessel: Union[str, dict] = "",         # 目标容器（可选）
+    waste_phase_to_vessel: Union[str, dict] = "",  # 废相目标容器
+    product_vessel: Union[str, dict] = "",    # XDL: 产物容器（与to_vessel同义）
+    waste_vessel: Union[str, dict] = "",      # XDL: 废液容器（与waste_phase_to_vessel同义）
+    # 🔧 溶剂相关参数
+    solvent: str = "",                   # 溶剂名称
+    solvent_volume: Union[str, float] = 0.0,  # 溶剂体积
+    volume: Union[str, float] = 0.0,     # XDL: 体积（与solvent_volume同义）
+    # 🔧 操作参数
+    through: str = "",                   # 通过材料
+    repeats: int = 1,                    # 重复次数
+    stir_time: float = 30.0,             # 搅拌时间（秒）
+    stir_speed: float = 300.0,           # 搅拌速度
+    settling_time: float = 300.0,        # 沉降时间（秒）
+    **kwargs
+) -> List[Dict[str, Any]]:
     """
-    Generate a protocol to clean a vessel with a solvent.
+    生成分离操作的协议序列 - 支持vessel字典和体积运算
     
-    :param G: Directed graph. Nodes are containers and pumps, edges are fluidic connections.
-    :param vessel: Vessel to clean.
-    :param solvent: Solvent to clean vessel with.
-    :param volume: Volume of solvent to clean vessel with.
-    :param temp: Temperature to heat vessel to while cleaning.
-    :param repeats: Number of cleaning cycles to perform.
-    :return: List of actions to clean vessel.
+    支持XDL参数格式：
+    - vessel: 分离容器字典（必需）
+    - purpose: "wash", "extract", "separate"
+    - product_phase: "top", "bottom"
+    - product_vessel: 产物收集容器
+    - waste_vessel: 废液收集容器
+    - solvent: 溶剂名称
+    - volume: "200 mL", "?" 或数值
+    - repeats: 重复次数
+    
+    分离流程：
+    1. （可选）添加溶剂到分离容器
+    2. 搅拌混合
+    3. 静置分层
+    4. 收集指定相到目标容器
+    5. 重复指定次数
     """
     
-    # 生成泵操作的动作序列
-    pump_action_sequence = []
-    reactor_volume = 500.0
-    waste_vessel = waste_phase_to_vessel
+    # 🔧 核心修改：vessel参数兼容处理
+    if vessel is None:
+        if isinstance(separation_vessel, dict):
+            vessel = separation_vessel
+        else:
+            raise ValueError("必须提供vessel字典参数")
     
-    # TODO：通过物料管理系统找到溶剂的容器
-    if "," in solvent:
-        solvents = solvent.split(",")
-        assert len(solvents) == repeats, "Number of solvents must match number of repeats."
+    # 🔧 核心修改：从字典中提取容器ID
+        # 统一处理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 = G.nodes[vessel_id].get("data", {}) if vessel_id in G.nodes() else {}
+    
+    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 = []
+    
+    # 🔧 新增：记录分离前的容器状态
+    debug_print("🔍 记录分离前容器状态...")
+    original_liquid_volume = get_vessel_liquid_volume(vessel)
+    debug_print(f"📊 分离前液体体积: {original_liquid_volume:.2f}mL")
+    
+    # === 参数验证和标准化 ===
+    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}", "📊"))
+    
+    # 统一容器参数 - 支持字典和字符串
+    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 ""
+    
+    final_vessel_id = vessel_id
+    final_to_vessel_id = extract_vessel_id(to_vessel) or extract_vessel_id(product_vessel)
+    final_waste_vessel_id = extract_vessel_id(waste_phase_to_vessel) or extract_vessel_id(waste_vessel)
+    
+    # 统一体积参数
+    final_volume = parse_volume_input(volume or solvent_volume)
+    
+    # 🔧 修复：确保repeats至少为1
+    if repeats <= 0:
+        repeats = 1
+        debug_print(f"⚠️ 重复次数参数 <= 0，自动设置为 1")
+    
+    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(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:
+        purpose = "separate"
+    if not product_phase:
+        product_phase = "top"
+    if purpose not in ["wash", "extract", "separate"]:
+        debug_print(f"⚠️ 未知的分离目的 '{purpose}'，使用默认值 'separate'")
+        purpose = "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(create_action_log(f"未知相别，使用: {product_phase}", "⚠️"))
+    
+    debug_print("✅ 参数验证通过")
+    action_sequence.append(create_action_log("参数验证通过", "✅"))
+    
+    # === 查找设备 ===
+    debug_print("🔍 步骤2: 查找设备...")
+    action_sequence.append(create_action_log("正在查找相关设备...", "🔍"))
+    
+    # 查找分离器设备
+    separator_device = find_separator_device(G, final_vessel_id)  # 🔧 使用 final_vessel_id
+    if separator_device:
+        action_sequence.append(create_action_log(f"找到分离器设备: {separator_device}", "🧪"))
     else:
-        solvents = [solvent] * repeats
+        debug_print("⚠️ 未找到分离器设备，可能无法执行分离")
+        action_sequence.append(create_action_log("未找到分离器设备", "⚠️"))
     
-    # TODO: 通过设备连接图找到分离容器的控制器、底部出口
-    separator_controller = f"{separation_vessel}_controller"
-    separation_vessel_bottom = f"flask_{separation_vessel}"
+    # 查找搅拌器
+    stirrer_device = find_connected_stirrer(G, final_vessel_id)  # 🔧 使用 final_vessel_id
+    if stirrer_device:
+        action_sequence.append(create_action_log(f"找到搅拌器: {stirrer_device}", "🌪️"))
+    else:
+        action_sequence.append(create_action_log("未找到搅拌器", "⚠️"))
     
-    transfer_flowrate = flowrate = 2.5
+    # 查找溶剂容器（如果需要）
+    solvent_vessel = ""
+    if solvent and solvent.strip():
+        solvent_vessel = find_solvent_vessel(G, solvent)
+        if solvent_vessel:
+            action_sequence.append(create_action_log(f"找到溶剂容器: {solvent_vessel}", "💧"))
+        else:
+            action_sequence.append(create_action_log(f"未找到溶剂容器: {solvent}", "⚠️"))
     
-    if from_vessel != separation_vessel:
-        pump_action_sequence.append(
-            {
-                "device_id": "", 
-                "action_name": "PumpTransferProtocol",
-                "action_kwargs": {
-                    "from_vessel": from_vessel,
-                    "to_vessel": separation_vessel,
-                    "volume": reactor_volume,
-                    "time": reactor_volume / flowrate,
-                    # "transfer_flowrate": transfer_flowrate,
+    debug_print(f"📊 设备配置:")
+    debug_print(f"  🧪 分离器设备: '{separator_device}'")
+    debug_print(f"  🌪️ 搅拌器设备: '{stirrer_device}'")
+    debug_print(f"  💧 溶剂容器: '{solvent_vessel}'")
+    
+    # === 执行分离流程 ===
+    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}轮: 开始分离循环 {cycle_num}/{repeats}")
+            action_sequence.append(create_action_log(f"分离循环 {cycle_num}/{repeats} 开始", "🔄"))
+            
+            # 步骤3.1: 添加溶剂（如果需要）
+            if solvent_vessel and final_volume > 0:
+                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,  # 🔧 使用 final_vessel_id
+                        volume=final_volume,
+                        amount="",
+                        time=0.0,
+                        viscous=False,
+                        rinsing_solvent="",
+                        rinsing_volume=0.0,
+                        rinsing_repeats=0,
+                        solid=False,
+                        flowrate=2.5,
+                        transfer_flowrate=0.5,
+                        rate_spec="",
+                        event="",
+                        through="",
+                        **kwargs
+                    )
+                    action_sequence.extend(pump_actions)
+                    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(create_action_log(f"溶剂添加失败: {str(e)}", "❌"))
+            else:
+                debug_print(f"🔄 第{cycle_num}轮 步骤1: 无需添加溶剂")
+                action_sequence.append(create_action_log("无需添加溶剂", "⏭️"))
+            
+            # 步骤3.2: 启动搅拌（如果有搅拌器）
+            if stirrer_device and stir_time > 0:
+                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": final_vessel_id,  # 🔧 使用 final_vessel_id
+                        "stir_speed": stir_speed,
+                        "purpose": f"分离混合 - {purpose}"
+                    }
+                })
+                
+                # 搅拌等待
+                stir_minutes = stir_time / 60
+                action_sequence.append(create_action_log(f"搅拌中，持续 {stir_minutes:.1f} 分钟", "⏱️"))
+                action_sequence.append({
+                    "action_name": "wait",
+                    "action_kwargs": {"time": stir_time}
+                })
+                
+                # 停止搅拌
+                action_sequence.append(create_action_log("停止搅拌器", "🛑"))
+                action_sequence.append({
+                    "device_id": stirrer_device,
+                    "action_name": "stop_stir",
+                    "action_kwargs": {"vessel": final_vessel_id}  # 🔧 使用 final_vessel_id
+                })
+                
+            else:
+                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(create_action_log(f"静置分层 ({settling_minutes:.1f} 分钟)", "⚖️"))
+                action_sequence.append({
+                    "action_name": "wait",
+                    "action_kwargs": {"time": settling_time}
+                })
+            else:
+                debug_print(f"🔄 第{cycle_num}轮 步骤3: 未指定静置时间")
+                action_sequence.append(create_action_log("未指定静置时间", "⏭️"))
+            
+            # 步骤3.4: 执行分离操作
+            if separator_device:
+                debug_print(f"🔄 第{cycle_num}轮 步骤4: 执行分离操作")
+                action_sequence.append(create_action_log(f"执行分离: 收集{product_phase}相", "🧪"))
+                
+                # 调用分离器设备的separate方法
+                separate_action = {
+                    "device_id": separator_device,
+                    "action_name": "separate",
+                    "action_kwargs": {
+                        "purpose": purpose,
+                        "product_phase": product_phase,
+                        "from_vessel": extract_vessel_id(from_vessel) or final_vessel_id,  # 🔧 使用vessel_id
+                        "separation_vessel": final_vessel_id,   # 🔧 使用 final_vessel_id
+                        "to_vessel": final_to_vessel_id or final_vessel_id,       # 🔧 使用vessel_id
+                        "waste_phase_to_vessel": final_waste_vessel_id or final_vessel_id,  # 🔧 使用vessel_id
+                        "solvent": solvent,
+                        "solvent_volume": final_volume,
+                        "through": through,
+                        "repeats": 1,  # 每次调用只做一次分离
+                        "stir_time": 0,  # 已经在上面完成
+                        "stir_speed": stir_speed,
+                        "settling_time": 0  # 已经在上面完成
+                    }
                 }
+                action_sequence.append(separate_action)
+                debug_print(f"✅ 分离操作已添加")
+                action_sequence.append(create_action_log("分离操作完成", "✅"))
+                
+                # 🔧 新增：分离后体积估算（分离通常不改变总体积，但会重新分配）
+                # 假设分离后保持体积（实际情况可能有少量损失）
+                separated_volume = current_volume * 0.95  # 假设5%损失
+                update_vessel_volume(vessel, G, separated_volume, f"分离操作后（第{cycle_num}轮）")
+                current_volume = separated_volume
+                
+                # 收集结果
+                if final_to_vessel_id:
+                    action_sequence.append(create_action_log(f"产物 ({product_phase}相) 收集到: {final_to_vessel_id}", "📦"))
+                if final_waste_vessel_id:
+                    action_sequence.append(create_action_log(f"废相收集到: {final_waste_vessel_id}", "🗑️"))
+            
+            else:
+                debug_print(f"🔄 第{cycle_num}轮 步骤4: 无分离器设备，跳过分离")
+                action_sequence.append(create_action_log("无分离器设备可用", "❌"))
+                # 添加等待时间模拟分离
+                action_sequence.append({
+                    "action_name": "wait",
+                    "action_kwargs": {"time": 10.0}
+                })
+            
+            # 循环间等待（除了最后一次）
+            if repeat_idx < repeats - 1:
+                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(create_action_log(f"分离循环 {cycle_num}/{repeats} 完成", "🌟"))
+    
+    except Exception as e:
+        debug_print(f"❌ 分离工作流程执行失败: {str(e)}")
+        action_sequence.append(create_action_log(f"分离工作流程失败: {str(e)}", "❌"))
+        # 添加错误日志
+        action_sequence.append({
+            "device_id": "system",
+            "action_name": "log_message",
+            "action_kwargs": {
+                "message": f"分离操作失败: {str(e)}"
             }
-        )
-        
-        # for i in range(2):
-        #     pump_action_sequence.append(
-        #         {
-        #             "device_id": "", 
-        #             "action_name": "CleanProtocol",
-        #             "action_kwargs": {
-        #                 "vessel": from_vessel,
-        #                 "solvent": "H2O", # Solvent to clean vessel with.
-        #                 "volume": solvent_volume, # Optional. Volume of solvent to clean vessel with.
-        #                 "temp": 25.0, # Optional. Temperature to heat vessel to while cleaning.
-        #                 "repeats": 1
-        #             }
-        #         }
-        #     )
-        #     pump_action_sequence.append(
-        #         {
-        #             "device_id": "", 
-        #             "action_name": "CleanProtocol",
-        #             "action_kwargs": {
-        #                 "vessel": from_vessel,
-        #                 "solvent": "CH2Cl2", # Solvent to clean vessel with.
-        #                 "volume": solvent_volume, # Optional. Volume of solvent to clean vessel with.
-        #                 "temp": 25.0, # Optional. Temperature to heat vessel to while cleaning.
-        #                 "repeats": 1
-        #             }
-        #         }
-        #     )
+        })
     
-    # 生成泵操作的动作序列
-    for i in range(repeats):
-        # 找到当次萃取所用溶剂
-        solvent_thistime = solvents[i]
-        solvent_vessel = f"flask_{solvent_thistime}"
-        
-        pump_action_sequence.append(
-            {
-                "device_id": "", 
-                "action_name": "PumpTransferProtocol",
-                "action_kwargs": {
-                    "from_vessel": solvent_vessel,
-                    "to_vessel": separation_vessel,
-                    "volume": solvent_volume,
-                    "time": solvent_volume / flowrate,
-                    # "transfer_flowrate": transfer_flowrate,
-                }
-            }
-        )
-        pump_action_sequence.extend([
-            # 搅拌、静置
-            {
-                "device_id": separator_controller, 
-                "action_name": "stir",
-                "action_kwargs": {
-                    "stir_time": stir_time,
-                    "stir_speed": stir_speed,
-                    "settling_time": settling_time
-                }
-            },
-            # 分液（判断电导突跃）
-            {
-                "device_id": separator_controller, 
-                "action_name": "valve_open",
-                "action_kwargs": {
-                    "command": "delta > 0.05"
-                }
-            }
-        ])
-        
-        if product_phase == "bottom":
-            # 产物转移到目标瓶
-            pump_action_sequence.append(
-                {
-                    "device_id": "", 
-                    "action_name": "PumpTransferProtocol",
-                    "action_kwargs": {
-                        "from_vessel": separation_vessel_bottom,
-                        "to_vessel": to_vessel,
-                        "volume": 250.0,
-                        "time": 250.0 / flowrate,
-                        # "transfer_flowrate": transfer_flowrate,
-                    }
-                }
-            )
-            # 放出上面那一相，60秒后关阀门
-            pump_action_sequence.append(
-                {
-                    "device_id": separator_controller, 
-                    "action_name": "valve_open",
-                    "action_kwargs": {
-                        "command": "time > 60"
-                    }
-                }
-            )
-            # 弃去上面那一相进废液
-            pump_action_sequence.append(
-                {
-                    "device_id": "", 
-                    "action_name": "PumpTransferProtocol",
-                    "action_kwargs": {
-                        "from_vessel": separation_vessel_bottom,
-                        "to_vessel": waste_vessel,
-                        "volume": 250.0,
-                        "time": 250.0 / flowrate,
-                        # "transfer_flowrate": transfer_flowrate,
-                    }
-                }
-            )
-        elif product_phase == "top":
-            # 弃去下面那一相进废液
-            pump_action_sequence.append(
-                {
-                    "device_id": "", 
-                    "action_name": "PumpTransferProtocol",
-                    "action_kwargs": {
-                        "from_vessel": separation_vessel_bottom,
-                        "to_vessel": waste_vessel,
-                        "volume": 250.0,
-                        "time": 250.0 / flowrate,
-                        # "transfer_flowrate": transfer_flowrate,
-                    }
-                }
-            )
-            # 放出上面那一相
-            pump_action_sequence.append(
-                {
-                    "device_id": separator_controller, 
-                    "action_name": "valve_open",
-                    "action_kwargs": {
-                        "command": "time > 60"
-                    }
-                }
-            )
-            # 产物转移到目标瓶
-            pump_action_sequence.append(
-                {
-                    "device_id": "", 
-                    "action_name": "PumpTransferProtocol",
-                    "action_kwargs": {
-                        "from_vessel": separation_vessel_bottom,
-                        "to_vessel": to_vessel,
-                        "volume": 250.0,
-                        "time": 250.0 / flowrate,
-                        # "transfer_flowrate": transfer_flowrate,
-                    }
-                }
-            )
-        elif product_phase == "organic":
-            pass
-        
-        # 如果不是最后一次，从中转瓶转移回分液漏斗
-        if i < repeats - 1:
-            pump_action_sequence.append(
-                {
-                    "device_id": "", 
-                    "action_name": "PumpTransferProtocol",
-                    "action_kwargs": {
-                        "from_vessel": to_vessel,
-                        "to_vessel": separation_vessel,
-                        "volume": 250.0,
-                        "time": 250.0 / flowrate,
-                        # "transfer_flowrate": transfer_flowrate,
-                    }
-                }
-            )
-    return pump_action_sequence
+    # 🔧 新增：分离完成后的最终状态报告
+    final_liquid_volume = get_vessel_liquid_volume(vessel)
+    
+    # === 最终结果 ===
+    total_time = (stir_time + settling_time + 15) * repeats  # 估算总时间
+    
+    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(create_action_log(summary_msg, "🎉"))
+    
+    return action_sequence
+

unilabos/compile/stir_protocol.py

@@ -1,166 +1,545 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Union
 import networkx as nx
+import logging
+import re
 
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    print(f"🌪️ [STIR] {message}", flush=True)
+    logger.info(f"[STIR] {message}")
+
+def parse_time_input(time_input: Union[str, float, int], default_unit: str = "s") -> float:
+    """
+    统一的时间解析函数（精简版）
+    
+    Args:
+        time_input: 时间输入（如 "30 min", "1 h", "300", "?", 60.0）
+        default_unit: 默认单位（默认为秒）
+    
+    Returns:
+        float: 时间（秒）
+    """
+    if not time_input:
+        return 100.0  # 默认100秒
+    
+    # 🔢 处理数值输入
+    if isinstance(time_input, (int, float)):
+        result = float(time_input)
+        debug_print(f"⏰ 数值时间: {time_input} → {result}s")
+        return result
+    
+    # 📝 处理字符串输入
+    time_str = str(time_input).lower().strip()
+    debug_print(f"🔍 解析时间: '{time_str}'")
+    
+    # ❓ 特殊值处理
+    special_times = {
+        '?': 300.0, 'unknown': 300.0, 'tbd': 300.0,
+        'briefly': 30.0, 'quickly': 60.0, 'slowly': 600.0,
+        'several minutes': 300.0, 'few minutes': 180.0, 'overnight': 3600.0
+    }
+    
+    if time_str in special_times:
+        result = special_times[time_str]
+        debug_print(f"🎯 特殊时间: '{time_str}' → {result}s ({result/60:.1f}分钟)")
+        return result
+    
+    # 🔢 纯数字处理
+    try:
+        result = float(time_str)
+        debug_print(f"⏰ 纯数字: {time_str} → {result}s")
+        return result
+    except ValueError:
+        pass
+    
+    # 📐 正则表达式解析
+    pattern = r'(\d+\.?\d*)\s*([a-z]*)'
+    match = re.match(pattern, time_str)
+    
+    if not match:
+        debug_print(f"⚠️ 无法解析时间: '{time_str}'，使用默认值: 100s")
+        return 100.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or default_unit
+    
+    # 📏 单位转换
+    unit_multipliers = {
+        's': 1.0, 'sec': 1.0, 'second': 1.0, 'seconds': 1.0,
+        'm': 60.0, 'min': 60.0, 'mins': 60.0, 'minute': 60.0, 'minutes': 60.0,
+        'h': 3600.0, 'hr': 3600.0, 'hrs': 3600.0, 'hour': 3600.0, 'hours': 3600.0,
+        'd': 86400.0, 'day': 86400.0, 'days': 86400.0
+    }
+    
+    multiplier = unit_multipliers.get(unit, 1.0)
+    result = value * multiplier
+    
+    debug_print(f"✅ 时间解析: '{time_str}' → {value} {unit} → {result}s ({result/60:.1f}分钟)")
+    return result
 
 def find_connected_stirrer(G: nx.DiGraph, vessel: str = None) -> str:
-    """
-    查找与指定容器相连的搅拌设备，或查找可用的搅拌设备
-    """
-    # 查找所有搅拌设备节点
-    stirrer_nodes = [node for node in G.nodes() 
-                    if (G.nodes[node].get('class') or '') == 'virtual_stirrer']
+    """查找与指定容器相连的搅拌设备"""
+    debug_print(f"🔍 查找搅拌设备，目标容器: {vessel} 🥽")
     
-    if 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:
-        return stirrer_nodes[0]
+        selected = stirrer_nodes[0]
+        debug_print(f"🔧 使用第一个搅拌设备: {selected} 🌪️")
+        return selected
     
-    raise ValueError("系统中未找到可用的搅拌设备")
+    # 🆘 默认设备
+    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 🕐")
+        stir_time = 100.0
+    elif stir_time > 100:  # 限制为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 🌪️")
+        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 ⏱️")
+        settling_time = 60.0
+    else:
+        debug_print(f"✅ 沉降时间 {settling_time}s 在正常范围内 ⏱️")
+    
+    return stir_time, stir_speed, settling_time
+
+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: 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,
-    stir_time: float,
-    stir_speed: float,
-    settling_time: float
+    vessel: Union[str, dict],  # 支持vessel字典或字符串
+    time: Union[str, float, int] = "300",
+    stir_time: Union[str, float, int] = "0",
+    time_spec: str = "",
+    event: str = "",
+    stir_speed: float = 300.0,
+    settling_time: Union[str, float] = "60",
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成搅拌操作的协议序列 - 定时搅拌 + 沉降
-    """
-    action_sequence = []
+    """生成搅拌操作的协议序列 - 修复vessel参数传递"""
     
-    print(f"STIR: 开始生成搅拌协议")
-    print(f"  - 搅拌时间: {stir_time}秒")
-    print(f"  - 搅拌速度: {stir_speed} RPM")
-    print(f"  - 沉降时间: {settling_time}秒")
+    # 🔧 核心修改：正确处理vessel参数
+    vessel_id = extract_vessel_id(vessel)
+    vessel_display = get_vessel_display_info(vessel)
     
-    # 查找搅拌设备
+    # 🔧 关键修复：确保vessel_resource是完整的Resource对象
+    if isinstance(vessel, dict):
+        vessel_resource = vessel  # 已经是完整的Resource字典
+        debug_print(f"✅ 使用传入的vessel Resource对象")
+    else:
+        # 如果只是字符串，构建一个基本的Resource对象
+        vessel_resource = {
+            "id": vessel,
+            "name": "",
+            "category": "",
+            "children": [],
+            "config": "",
+            "data": "",
+            "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": ""
+        }
+        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():  # 🔧 使用 vessel_id
+        debug_print(f"❌ 容器 '{vessel_id}' 不存在于系统中! 😞")
+        raise ValueError(f"容器 '{vessel_id}' 不存在于系统中")
+    
+    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("📍 步骤3: 查找搅拌设备... 🔍")
     try:
-        stirrer_id = find_connected_stirrer(G)
-        print(f"STIR: 找到搅拌设备: {stirrer_id}")
-    except ValueError as e:
+        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": {
-            "stir_time": stir_time,
-            "stir_speed": stir_speed,
-            "settling_time": settling_time
+            # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
+            "vessel": vessel_id,  # 传递字符串ID，不是Resource对象
+            "time": str(time),
+            "event": event,
+            "time_spec": time_spec,
+            "stir_time": float(parsed_time),
+            "stir_speed": float(stir_speed),
+            "settling_time": float(parsed_settling_time)
         }
     }
-    
     action_sequence.append(stir_action)
+    debug_print("✅ 搅拌动作已添加 🌪️✨")
+    
+    # 显示时间优化信息
+    if original_stir_time != parsed_time or original_settling_time != parsed_settling_time:
+        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)
     
-    print(f"STIR: 生成了 {len(action_sequence)} 个动作")
     return action_sequence
 
-
 def generate_start_stir_protocol(
     G: nx.DiGraph,
-    vessel: str,
-    stir_speed: float,
-    purpose: str
+    vessel: Union[str, dict],
+    stir_speed: float = 300.0,
+    purpose: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成开始搅拌操作的协议序列 - 持续搅拌
-    """
-    action_sequence = []
+    """生成开始搅拌操作的协议序列 - 修复vessel参数传递"""
     
-    print(f"START_STIR: 开始生成启动搅拌协议")
-    print(f"  - 容器: {vessel}")
-    print(f"  - 搅拌速度: {stir_speed} RPM")
-    print(f"  - 目的: {purpose}")
+    # 🔧 核心修改：正确处理vessel参数
+    vessel_id = extract_vessel_id(vessel)
+    vessel_display = get_vessel_display_info(vessel)
     
-    # 验证容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
+    # 🔧 关键修复：确保vessel_resource是完整的Resource对象
+    if isinstance(vessel, dict):
+        vessel_resource = vessel  # 已经是完整的Resource字典
+        debug_print(f"✅ 使用传入的vessel Resource对象")
+    else:
+        # 如果只是字符串，构建一个基本的Resource对象
+        vessel_resource = {
+            "id": vessel,
+            "name": "",
+            "category": "",
+            "children": [],
+            "config": "",
+            "data": "",
+            "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": ""
+        }
+        debug_print(f"🔧 构建了基本的vessel Resource对象: {vessel}")
     
-    # 查找搅拌设备
-    try:
-        stirrer_id = find_connected_stirrer(G, vessel)
-        print(f"START_STIR: 找到搅拌设备: {stirrer_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到搅拌设备: {str(e)}")
+    debug_print("🔄 开始生成启动搅拌协议（修复vessel参数）✨")
+    debug_print(f"🥽 vessel: {vessel_display} (ID: {vessel_id})")
+    debug_print(f"🌪️ speed: {stir_speed} RPM")
+    debug_print(f"🎯 purpose: {purpose}")
     
-    # 执行开始搅拌操作
-    start_stir_action = {
+    # 基础验证
+    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": vessel,
+            # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
+            "vessel": vessel_id,  # 传递字符串ID，不是Resource对象
             "stir_speed": stir_speed,
-            "purpose": purpose
+            "purpose": purpose or f"启动搅拌 {stir_speed} RPM"
         }
-    }
+    }]
     
-    action_sequence.append(start_stir_action)
-    
-    print(f"START_STIR: 生成了 {len(action_sequence)} 个动作")
+    debug_print(f"✅ 启动搅拌协议生成完成 🎯")
     return action_sequence
 
-
 def generate_stop_stir_protocol(
     G: nx.DiGraph,
-    vessel: str
+    vessel: Union[str, dict],
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成停止搅拌操作的协议序列
-    """
-    action_sequence = []
+    """生成停止搅拌操作的协议序列 - 修复vessel参数传递"""
     
-    print(f"STOP_STIR: 开始生成停止搅拌协议")
-    print(f"  - 容器: {vessel}")
+    # 🔧 核心修改：正确处理vessel参数
+    vessel_id = extract_vessel_id(vessel)
+    vessel_display = get_vessel_display_info(vessel)
     
-    # 验证容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
+    # 🔧 关键修复：确保vessel_resource是完整的Resource对象
+    if isinstance(vessel, dict):
+        vessel_resource = vessel  # 已经是完整的Resource字典
+        debug_print(f"✅ 使用传入的vessel Resource对象")
+    else:
+        # 如果只是字符串，构建一个基本的Resource对象
+        vessel_resource = {
+            "id": vessel,
+            "name": "",
+            "category": "",
+            "children": [],
+            "config": "",
+            "data": "",
+            "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": ""
+        }
+        debug_print(f"🔧 构建了基本的vessel Resource对象: {vessel}")
     
-    # 查找搅拌设备
-    try:
-        stirrer_id = find_connected_stirrer(G, vessel)
-        print(f"STOP_STIR: 找到搅拌设备: {stirrer_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到搅拌设备: {str(e)}")
+    debug_print("🛑 开始生成停止搅拌协议（修复vessel参数）✨")
+    debug_print(f"🥽 vessel: {vessel_display} (ID: {vessel_id})")
     
-    # 执行停止搅拌操作
-    stop_stir_action = {
+    # 基础验证
+    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": vessel
+            # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
+            "vessel": vessel_id  # 传递字符串ID，不是Resource对象
         }
-    }
+    }]
     
-    action_sequence.append(stop_stir_action)
-    
-    print(f"STOP_STIR: 生成了 {len(action_sequence)} 个动作")
+    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)")
+    return generate_stir_protocol(G, vessel, time="30", stir_speed=speed)
 
-# 便捷函数
-def generate_fast_stir_protocol(
-    G: nx.DiGraph,
-    time: float = 300.0,
-    speed: float = 800.0,
-    settling: float = 60.0
-) -> List[Dict[str, Any]]:
-    """快速搅拌的便捷函数"""
-    return generate_stir_protocol(G, time, speed, settling)
+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")
+    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")
+    return generate_stir_protocol(G, vessel, time=time, stir_speed=800.0)
 
-def generate_gentle_stir_protocol(
-    G: nx.DiGraph,
-    time: float = 600.0,
-    speed: float = 200.0,
-    settling: float = 120.0
-) -> List[Dict[str, Any]]:
-    """温和搅拌的便捷函数"""
-    return generate_stir_protocol(G, time, speed, settling)
+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")
+    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")
+    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")
+    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")
+    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")
+    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}")
+    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}")
+    
+    # 测试字符串格式
+    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("✅ 测试完成 🎉")
+
+if __name__ == "__main__":
+    test_stir_protocol()

unilabos/compile/utils/unit_parser.py

@@ -0,0 +1,206 @@
+"""
+统一的单位解析工具模块
+支持时间、体积、质量等各种单位的解析
+"""
+
+import re
+import logging
+from typing import Union
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message, prefix="[UNIT_PARSER]"):
+    """调试输出"""
+    print(f"{prefix} {message}", flush=True)
+    logger.info(f"{prefix} {message}")
+
+def parse_time_with_units(time_input: Union[str, float, int], default_unit: str = "s") -> float:
+    """
+    解析带单位的时间输入
+    
+    Args:
+        time_input: 时间输入（如 "30 min", "1 h", "300", "?", 60.0）
+        default_unit: 默认单位（默认为秒）
+    
+    Returns:
+        float: 时间（秒）
+    """
+    if not time_input:
+        return 0.0
+    
+    # 处理数值输入
+    if isinstance(time_input, (int, float)):
+        result = float(time_input)
+        debug_print(f"数值时间输入: {time_input} → {result}s（默认单位）")
+        return result
+    
+    # 处理字符串输入
+    time_str = str(time_input).lower().strip()
+    debug_print(f"解析时间字符串: '{time_str}'")
+    
+    # 处理特殊值
+    if time_str in ['?', 'unknown', 'tbd', 'to be determined']:
+        default_time = 300.0  # 5分钟默认值
+        debug_print(f"检测到未知时间，使用默认值: {default_time}s")
+        return default_time
+    
+    # 如果是纯数字，使用默认单位
+    try:
+        value = float(time_str)
+        if default_unit == "s":
+            result = value
+        elif default_unit in ["min", "minute"]:
+            result = value * 60.0
+        elif default_unit in ["h", "hour"]:
+            result = value * 3600.0
+        else:
+            result = value  # 默认秒
+        debug_print(f"纯数字输入: {time_str} → {result}s（单位: {default_unit}）")
+        return result
+    except ValueError:
+        pass
+    
+    # 使用正则表达式匹配数字和单位
+    pattern = r'(\d+\.?\d*)\s*([a-z]*)'
+    match = re.match(pattern, time_str)
+    
+    if not match:
+        debug_print(f"⚠️ 无法解析时间: '{time_str}'，使用默认值: 60s")
+        return 60.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or default_unit
+    
+    # 单位转换映射
+    unit_multipliers = {
+        # 秒
+        's': 1.0,
+        'sec': 1.0,
+        'second': 1.0,
+        'seconds': 1.0,
+        
+        # 分钟
+        'm': 60.0,
+        'min': 60.0,
+        'mins': 60.0,
+        'minute': 60.0,
+        'minutes': 60.0,
+        
+        # 小时
+        'h': 3600.0,
+        'hr': 3600.0,
+        'hrs': 3600.0,
+        'hour': 3600.0,
+        'hours': 3600.0,
+        
+        # 天
+        'd': 86400.0,
+        'day': 86400.0,
+        'days': 86400.0,
+    }
+    
+    multiplier = unit_multipliers.get(unit, 1.0)
+    result = value * multiplier
+    
+    debug_print(f"时间解析: '{time_str}' → {value} {unit} → {result}s")
+    return result
+
+def parse_volume_with_units(volume_input: Union[str, float, int], default_unit: str = "mL") -> float:
+    """
+    解析带单位的体积输入
+    
+    Args:
+        volume_input: 体积输入（如 "100 mL", "2.5 L", "500", "?", 100.0）
+        default_unit: 默认单位（默认为毫升）
+    
+    Returns:
+        float: 体积（毫升）
+    """
+    if not volume_input:
+        return 0.0
+    
+    # 处理数值输入
+    if isinstance(volume_input, (int, float)):
+        result = float(volume_input)
+        debug_print(f"数值体积输入: {volume_input} → {result}mL（默认单位）")
+        return result
+    
+    # 处理字符串输入
+    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
+    
+    # 如果是纯数字，使用默认单位
+    try:
+        value = float(volume_str)
+        if default_unit.lower() in ["ml", "milliliter"]:
+            result = value
+        elif default_unit.lower() in ["l", "liter"]:
+            result = value * 1000.0
+        elif default_unit.lower() in ["μl", "ul", "microliter"]:
+            result = value / 1000.0
+        else:
+            result = value  # 默认mL
+        debug_print(f"纯数字输入: {volume_str} → {result}mL（单位: {default_unit}）")
+        return result
+    except ValueError:
+        pass
+    
+    # 移除空格并提取数字和单位
+    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 default_unit.lower()
+    
+    # 转换为毫升
+    if unit in ['l', 'liter']:
+        volume = value * 1000.0  # L -> mL
+    elif unit in ['μl', 'ul', 'microliter']:
+        volume = value / 1000.0  # μL -> mL
+    else:  # ml, milliliter 或默认
+        volume = value  # 已经是mL
+    
+    debug_print(f"体积解析: '{volume_str}' → {value} {unit} → {volume}mL")
+    return volume
+
+# 测试函数
+def test_unit_parser():
+    """测试单位解析功能"""
+    print("=== 单位解析器测试 ===")
+    
+    # 测试时间解析
+    time_tests = [
+        "30 min", "1 h", "300", "5.5 h", "?", 60.0, "2 hours", "30 s"
+    ]
+    
+    print("\n时间解析测试:")
+    for time_input in time_tests:
+        result = parse_time_with_units(time_input)
+        print(f"  {time_input} → {result}s ({result/60:.1f}min)")
+    
+    # 测试体积解析
+    volume_tests = [
+        "100 mL", "2.5 L", "500", "?", 100.0, "500 μL", "1 liter"
+    ]
+    
+    print("\n体积解析测试:")
+    for volume_input in volume_tests:
+        result = parse_volume_with_units(volume_input)
+        print(f"  {volume_input} → {result}mL")
+    
+    print("\n✅ 测试完成")
+
+if __name__ == "__main__":
+    test_unit_parser()

unilabos/compile/wash_solid_protocol.py

@@ -1,216 +1,652 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Union
 import networkx as nx
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    print(f"🧼 [WASH_SOLID] {message}", flush=True)
+    logger.info(f"[WASH_SOLID] {message}")
+
+def parse_time_input(time_input: Union[str, float, int]) -> float:
+    """统一时间解析函数（精简版）"""
+    if not time_input:
+        return 0.0
+    
+    # 🔢 处理数值输入
+    if isinstance(time_input, (int, float)):
+        result = float(time_input)
+        debug_print(f"⏰ 数值时间: {time_input} → {result}s")
+        return result
+    
+    # 📝 处理字符串输入
+    time_str = str(time_input).lower().strip()
+    
+    # ❓ 特殊值快速处理
+    special_times = {
+        '?': 60.0, 'unknown': 60.0, 'briefly': 30.0, 
+        'quickly': 45.0, 'slowly': 120.0
+    }
+    
+    if time_str in special_times:
+        result = special_times[time_str]
+        debug_print(f"🎯 特殊时间: '{time_str}' → {result}s")
+        return result
+    
+    # 🔢 数字提取（简化正则）
+    try:
+        # 提取数字
+        numbers = re.findall(r'\d+\.?\d*', time_str)
+        if numbers:
+            value = float(numbers[0])
+            
+            # 简化单位判断
+            if any(unit in time_str for unit in ['min', 'm']):
+                result = value * 60.0
+            elif any(unit in time_str for unit in ['h', 'hour']):
+                result = value * 3600.0
+            else:
+                result = value  # 默认秒
+            
+            debug_print(f"✅ 时间解析: '{time_str}' → {result}s")
+            return result
+    except:
+        pass
+    
+    debug_print(f"⚠️ 时间解析失败: '{time_str}'，使用默认60s")
+    return 60.0
+
+def parse_volume_input(volume: Union[float, str], volume_spec: str = "", mass: str = "") -> float:
+    """统一体积解析函数（精简版）"""
+    debug_print(f"💧 解析体积: volume={volume}, spec='{volume_spec}', mass='{mass}'")
+    
+    # 🎯 优先级1：volume_spec（快速映射）
+    if volume_spec:
+        spec_map = {
+            'small': 20.0, 'medium': 50.0, 'large': 100.0,
+            'minimal': 10.0, 'normal': 50.0, 'generous': 150.0
+        }
+        for key, val in spec_map.items():
+            if key in volume_spec.lower():
+                debug_print(f"🎯 规格匹配: '{volume_spec}' → {val}mL")
+                return val
+    
+    # 🧮 优先级2：mass转体积（简化：1g=1mL）
+    if mass:
+        try:
+            numbers = re.findall(r'\d+\.?\d*', mass)
+            if numbers:
+                value = float(numbers[0])
+                if 'mg' in mass.lower():
+                    result = value / 1000.0
+                elif 'kg' in mass.lower():
+                    result = value * 1000.0
+                else:
+                    result = value  # 默认g
+                debug_print(f"⚖️ 质量转换: {mass} → {result}mL")
+                return result
+        except:
+            pass
+    
+    # 📦 优先级3：volume
+    if volume:
+        if isinstance(volume, (int, float)):
+            result = float(volume)
+            debug_print(f"💧 数值体积: {volume} → {result}mL")
+            return result
+        elif isinstance(volume, str):
+            try:
+                # 提取数字
+                numbers = re.findall(r'\d+\.?\d*', volume)
+                if numbers:
+                    value = float(numbers[0])
+                    # 简化单位判断
+                    if 'l' in volume.lower() and 'ml' not in volume.lower():
+                        result = value * 1000.0  # L转mL
+                    else:
+                        result = value  # 默认mL
+                    debug_print(f"💧 字符串体积: '{volume}' → {result}mL")
+                    return result
+            except:
+                pass
+    
+    # 默认值
+    debug_print(f"⚠️ 体积解析失败，使用默认50mL")
+    return 50.0
+
+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}")
+            return pattern
+    
+    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}")
+            return vessel
+    
+    debug_print(f"⚠️ 使用默认滤液容器: waste_workup")
+    return "waste_workup"
+
+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: 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: str,
+    vessel: Union[str, dict],  # 🔧 修改：支持vessel字典
     solvent: str,
-    volume: float,
-    filtrate_vessel: str = "",
+    volume: Union[float, str] = "50",
+    filtrate_vessel: Union[str, dict] = "",  # 🔧 修改：支持vessel字典
     temp: float = 25.0,
     stir: bool = False,
     stir_speed: float = 0.0,
-    time: float = 0.0,
-    repeats: int = 1
+    time: Union[str, float] = "0",
+    repeats: int = 1,
+    volume_spec: str = "",
+    repeats_spec: str = "",
+    mass: str = "",
+    event: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成固体清洗的协议序列
+    生成固体清洗协议 - 支持vessel字典和体积运算
     
     Args:
-        G: 有向图，节点为设备和容器
-        vessel: 装有固体物质的容器名称
-        solvent: 用于清洗固体的溶剂名称
-        volume: 清洗溶剂的体积
-        filtrate_vessel: 滤液要收集到的容器名称，可选参数
-        temp: 清洗时的温度，可选参数
-        stir: 是否在清洗过程中搅拌，默认为 False
-        stir_speed: 搅拌速度，可选参数
-        time: 清洗的时间，可选参数
-        repeats: 清洗操作的重复次数，默认为 1
+        G: 有向图，节点为设备和容器，边为流体管道
+        vessel: 清洗容器字典（从XDL传入）或容器ID字符串
+        solvent: 清洗溶剂名称
+        volume: 溶剂体积（每次清洗）
+        filtrate_vessel: 滤液收集容器字典或容器ID字符串
+        temp: 清洗温度（°C）
+        stir: 是否搅拌
+        stir_speed: 搅拌速度（RPM）
+        time: 搅拌时间
+        repeats: 清洗重复次数
+        volume_spec: 体积规格（small/medium/large）
+        repeats_spec: 重复次数规格（few/several/many）
+        mass: 固体质量（用于计算溶剂用量）
+        event: 事件描述
+        **kwargs: 其他可选参数
     
     Returns:
         List[Dict[str, Any]]: 固体清洗操作的动作序列
-    
-    Raises:
-        ValueError: 当找不到必要的设备时抛出异常
-    
-    Examples:
-        wash_solid_protocol = generate_wash_solid_protocol(
-            G, "reactor", "ethanol", 100.0, "waste_flask", 60.0, True, 300.0, 600.0, 3
-        )
     """
+    
+    # 🔧 核心修改：从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("🧼" * 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_vessel_liquid_volume(vessel)
+        debug_print(f"📊 清洗前液体体积: {original_volume:.2f}mL")
+    else:
+        original_volume = 0.0
+        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))  # 限制1-5次
+    
+    # 🕐 模拟时间优化
+    debug_print("  ⏱️ 模拟时间优化...")
+    original_time = final_time
+    if final_time > 60.0:
+        final_time = 60.0  # 限制最长60秒
+        debug_print(f"  🎮 时间优化: {original_time}s → {final_time}s ⚡")
+    
+    # 参数修正
+    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 = []
     
-    # 验证容器是否存在
-    if vessel not in G.nodes():
-        raise ValueError(f"固体容器 {vessel} 不存在于图中")
+    # 🔧 新增：体积变化跟踪变量
+    current_volume = original_volume
+    total_solvent_used = 0.0
     
-    if filtrate_vessel and filtrate_vessel not in G.nodes():
-        raise ValueError(f"滤液容器 {filtrate_vessel} 不存在于图中")
-    
-    # 查找转移泵设备（用于添加溶剂和转移滤液）
-    pump_nodes = [node for node in G.nodes() 
-                  if G.nodes[node].get('class') == 'virtual_transfer_pump']
-    
-    if not pump_nodes:
-        raise ValueError("没有找到可用的转移泵设备")
-    
-    pump_id = pump_nodes[0]
-    
-    # 查找加热设备（如果需要加热）
-    heatchill_nodes = [node for node in G.nodes() 
-                      if G.nodes[node].get('class') == 'virtual_heatchill']
-    
-    heatchill_id = heatchill_nodes[0] if heatchill_nodes else None
-    
-    # 查找搅拌设备（如果需要搅拌）
-    stirrer_nodes = [node for node in G.nodes() 
-                    if G.nodes[node].get('class') == 'virtual_stirrer']
-    
-    stirrer_id = stirrer_nodes[0] if stirrer_nodes else None
-    
-    # 查找过滤设备（用于分离固体和滤液）
-    filter_nodes = [node for node in G.nodes() 
-                   if G.nodes[node].get('class') == 'virtual_filter']
-    
-    filter_id = filter_nodes[0] if filter_nodes else None
-    
-    # 查找溶剂容器
-    solvent_vessel = f"flask_{solvent}"
-    if solvent_vessel not in G.nodes():
-        # 如果没有找到特定溶剂容器，查找可用的源容器
-        available_vessels = [node for node in G.nodes() 
-                           if node.startswith('flask_') and 
-                           G.nodes[node].get('type') == 'container']
-        if available_vessels:
-            solvent_vessel = available_vessels[0]
-        else:
-            raise ValueError(f"没有找到溶剂容器 {solvent}")
-    
-    # 如果没有指定滤液容器，使用废液容器
-    if not filtrate_vessel:
-        waste_vessels = [node for node in G.nodes() 
-                        if 'waste' in node.lower() and 
-                        G.nodes[node].get('type') == 'container']
-        filtrate_vessel = waste_vessels[0] if waste_vessels else "waste_flask"
-    
-    # 重复清洗操作
-    for repeat in range(repeats):
-        repeat_num = repeat + 1
+    for cycle in range(final_repeats):
+        debug_print(f"  🔄 第{cycle+1}/{final_repeats}次清洗...")
         
-        # 步骤1：如果需要加热，先设置温度
-        if temp > 25.0 and heatchill_id:
-            action_sequence.append({
-                "device_id": heatchill_id,
-                "action_name": "heat_chill_start",
+        # 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,  # 🔧 使用 vessel_id
+                volume=final_volume,
+                amount="",
+                time=0.0,
+                viscous=False,
+                rinsing_solvent="",
+                rinsing_volume=0.0,
+                rinsing_repeats=0,
+                solid=False,
+                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, 
+                                       f"第{cycle+1}次清洗添加{final_volume}mL溶剂后")
+            
+        except Exception as 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": vessel,
-                    "temp": temp,
-                    "purpose": f"固体清洗 - 第 {repeat_num} 次"
+                    "vessel": vessel_id,  # 🔧 使用 vessel_id
+                    "time": str(time),
+                    "stir_time": final_time,
+                    "stir_speed": stir_speed,
+                    "settling_time": 10.0  # 🕐 缩短沉降时间
                 }
-            })
-        
-        # 步骤2：添加清洗溶剂到固体容器
-        action_sequence.append({
-            "device_id": pump_id,
-            "action_name": "transfer",
-            "action_kwargs": {
-                "from_vessel": solvent_vessel,
-                "to_vessel": vessel,
-                "volume": volume,
-                "amount": f"清洗溶剂 {solvent} - 第 {repeat_num} 次",
-                "time": 0.0,
-                "viscous": False,
-                "rinsing_solvent": "",
-                "rinsing_volume": 0.0,
-                "rinsing_repeats": 0,
-                "solid": False
             }
+            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": vessel_id,  # 🔧 使用 vessel_id
+                "filtrate_vessel": actual_filtrate_vessel,
+                "temp": temp,
+                "volume": final_volume
+            }
+        }
+        action_sequence.append(filter_action)
+        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, 
+                               f"第{cycle+1}次清洗过滤后")
+        
+        # 4. 等待（缩短时间）
+        wait_time = 5.0  # 🕐 缩短等待时间：10s → 5s
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {"time": wait_time}
         })
-        
-        # 步骤3：如果需要搅拌，开始搅拌
-        if stir and stir_speed > 0 and stirrer_id:
-            if time > 0:
-                # 定时搅拌
-                action_sequence.append({
-                    "device_id": stirrer_id,
-                    "action_name": "stir",
-                    "action_kwargs": {
-                        "stir_time": time,
-                        "stir_speed": stir_speed,
-                        "settling_time": 30.0  # 搅拌后静置30秒
-                    }
-                })
-            else:
-                # 开始搅拌（需要手动停止）
-                action_sequence.append({
-                    "device_id": stirrer_id,
-                    "action_name": "start_stir",
-                    "action_kwargs": {
-                        "vessel": vessel,
-                        "stir_speed": stir_speed,
-                        "purpose": f"固体清洗搅拌 - 第 {repeat_num} 次"
-                    }
-                })
-        
-        # 步骤4：如果指定了清洗时间但没有搅拌，等待清洗时间
-        if time > 0 and (not stir or stir_speed == 0):
-            # 这里可以添加等待操作，暂时跳过
-            pass
-        
-        # 步骤5：如果有搅拌且没有定时，停止搅拌
-        if stir and stir_speed > 0 and time == 0 and stirrer_id:
-            action_sequence.append({
-                "device_id": stirrer_id,
-                "action_name": "stop_stir",
-                "action_kwargs": {
-                    "vessel": vessel
-                }
-            })
-        
-        # 步骤6：过滤分离固体和滤液
-        if filter_id:
-            action_sequence.append({
-                "device_id": filter_id,
-                "action_name": "filter_sample",
-                "action_kwargs": {
-                    "vessel": vessel,
-                    "filtrate_vessel": filtrate_vessel,
-                    "stir": False,
-                    "stir_speed": 0.0,
-                    "temp": temp,
-                    "continue_heatchill": temp > 25.0,
-                    "volume": volume
-                }
-            })
-        else:
-            # 没有专门的过滤设备，使用转移泵模拟过滤过程
-            # 将滤液转移到滤液容器
-            action_sequence.append({
-                "device_id": pump_id,
-                "action_name": "transfer",
-                "action_kwargs": {
-                    "from_vessel": vessel,
-                    "to_vessel": filtrate_vessel,
-                    "volume": volume,
-                    "amount": f"转移滤液 - 第 {repeat_num} 次清洗",
-                    "time": 0.0,
-                    "viscous": False,
-                    "rinsing_solvent": "",
-                    "rinsing_volume": 0.0,
-                    "rinsing_repeats": 0,
-                    "solid": False
-                }
-            })
-        
-        # 步骤7：如果加热了，停止加热（在最后一次清洗后）
-        if temp > 25.0 and heatchill_id and repeat_num == repeats:
-            action_sequence.append({
-                "device_id": heatchill_id,
-                "action_name": "heat_chill_stop",
-                "action_kwargs": {
-                    "vessel": vessel
-                }
-            })
+        debug_print(f"    ✅ 等待: {wait_time}s ⏰")
     
-    return action_sequence
+    # 🔧 新增：清洗完成后的最终状态报告
+    if isinstance(vessel, dict):
+        final_volume_vessel = get_vessel_liquid_volume(vessel)
+    else:
+        final_volume_vessel = current_volume
+    
+    # 🎊 总结
+    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", 
+                   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", 
+                     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", 
+                     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", 
+                   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", 
+                          repeats: int = 1) -> List[Dict[str, Any]]:
+    """用冷溶剂清洗固体"""
+    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", 
+                         repeats: int = 1) -> List[Dict[str, Any]]:
+    """用热溶剂清洗固体"""
+    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", 
+                      repeats: int = 1) -> List[Dict[str, Any]]:
+    """带搅拌的溶剂清洗"""
+    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], 
+                 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], 
+               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], 
+                   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, 
+                                                   volume=volume, repeats=1)
+        action_sequence.extend(wash_actions)
+    
+    return action_sequence
+
+# 测试函数
+def test_wash_solid_protocol():
+    """测试固体清洗协议"""
+    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_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"  字符串格式: {vessel_str}")
+    debug_print(f"    → ID: {vessel_id}, 显示: {vessel_display}")
+    
+    debug_print("✅ 测试完成 🎉")
+
+if __name__ == "__main__":
+    test_wash_solid_protocol()