feat(workstation): update bioyond config migration and coin cell material search logic

- Migrate bioyond_cell config to JSON structure and remove global variable dependencies - Implement material search confirmation dialog auto-handling - Add documentation: 20260113_物料搜寻确认弹窗自动处理功能.md and 20260113_配置迁移修改总结.md
2026-03-24 18:19:20 +00:00 · 2026-01-14 09:55:25 +08:00
125 changed files with 4943 additions and 25106 deletions
--- a/.conda/base/recipe.yaml
+++ b/.conda/base/recipe.yaml
@@ -1,62 +0,0 @@
-# unilabos: Production package (depends on unilabos-env + pip unilabos)
-# For production deployment
-
-package:
-  name: unilabos
-  version: 0.10.18
-
-source:
-  path: ../../unilabos
-  target_directory: unilabos
-
-build:
-  python:
-    entry_points:
-    - unilab = unilabos.app.main:main
-  script:
-  - set PIP_NO_INDEX=
-  - if: win
-    then:
-    - copy %RECIPE_DIR%\..\..\MANIFEST.in %SRC_DIR%
-    - copy %RECIPE_DIR%\..\..\setup.cfg %SRC_DIR%
-    - copy %RECIPE_DIR%\..\..\setup.py %SRC_DIR%
-    - pip install %SRC_DIR%
-  - if: unix
-    then:
-    - cp $RECIPE_DIR/../../MANIFEST.in $SRC_DIR
-    - cp $RECIPE_DIR/../../setup.cfg $SRC_DIR
-    - cp $RECIPE_DIR/../../setup.py $SRC_DIR
-    - pip install $SRC_DIR
-
-requirements:
-  host:
-  - python ==3.11.14
-  - pip
-  - setuptools
-  - zstd
-  - zstandard
-  run:
-  - zstd
-  - zstandard
-  - networkx
-  - typing_extensions
-  - websockets
-  - pint
-  - fastapi
-  - jinja2
-  - requests
-  - uvicorn
-  - if: not osx
-    then:
-    - opcua
-  - pyserial
-  - pandas
-  - pymodbus
-  - matplotlib
-  - pylibftdi
-  - uni-lab::unilabos-env ==0.10.18
-
-about:
-  repository: https://github.com/deepmodeling/Uni-Lab-OS
-  license: GPL-3.0-only
-  description: "UniLabOS - Production package with minimal ROS2 dependencies"
--- a/.conda/environment/recipe.yaml
+++ b/.conda/environment/recipe.yaml
@@ -1,39 +0,0 @@
-# unilabos-env: conda environment dependencies (ROS2 + conda packages)
-
-package:
-  name: unilabos-env
-  version: 0.10.18
-
-build:
-  noarch: generic
-
-requirements:
-  run:
-  # Python
-  - zstd
-  - zstandard
-  - conda-forge::python ==3.11.14
-  - conda-forge::opencv
-  # ROS2 dependencies (from ci-check.yml)
-  - robostack-staging::ros-humble-ros-core
-  - robostack-staging::ros-humble-action-msgs
-  - robostack-staging::ros-humble-std-msgs
-  - robostack-staging::ros-humble-geometry-msgs
-  - robostack-staging::ros-humble-control-msgs
-  - robostack-staging::ros-humble-nav2-msgs
-  - robostack-staging::ros-humble-cv-bridge
-  - robostack-staging::ros-humble-vision-opencv
-  - robostack-staging::ros-humble-tf-transformations
-  - robostack-staging::ros-humble-moveit-msgs
-  - robostack-staging::ros-humble-tf2-ros
-  - robostack-staging::ros-humble-tf2-ros-py
-  - conda-forge::transforms3d
-  - conda-forge::uv
-
-  # UniLabOS custom messages
-  - uni-lab::ros-humble-unilabos-msgs
-
-about:
-  repository: https://github.com/deepmodeling/Uni-Lab-OS
-  license: GPL-3.0-only
-  description: "UniLabOS Environment - ROS2 and conda dependencies"
--- a/.conda/full/recipe.yaml
+++ b/.conda/full/recipe.yaml
@@ -1,42 +0,0 @@
-# unilabos-full: Full package with all features
-# Depends on unilabos + complete ROS2 desktop + dev tools
-
-package:
-  name: unilabos-full
-  version: 0.10.18
-
-build:
-  noarch: generic
-
-requirements:
-  run:
-  # Base unilabos package (includes unilabos-env)
-  - uni-lab::unilabos ==0.10.18
-  # Documentation tools
-  - sphinx
-  - sphinx_rtd_theme
-  # Web UI
-  - gradio
-  - flask
-  # Interactive development
-  - ipython
-  - jupyter
-  - jupyros
-  - colcon-common-extensions
-  # ROS2 full desktop (includes rviz2, gazebo, etc.)
-  - robostack-staging::ros-humble-desktop-full
-  # Navigation and motion control
-  - ros-humble-navigation2
-  - ros-humble-ros2-control
-  - ros-humble-robot-state-publisher
-  - ros-humble-joint-state-publisher
-  # MoveIt motion planning
-  - ros-humble-moveit
-  - ros-humble-moveit-servo
-  # Simulation
-  - ros-humble-simulation
-
-about:
-  repository: https://github.com/deepmodeling/Uni-Lab-OS
-  license: GPL-3.0-only
-  description: "UniLabOS Full - Complete package with ROS2 Desktop, MoveIt, Navigation2, Gazebo, Jupyter"
--- a/.conda/recipe.yaml
+++ b/.conda/recipe.yaml
@@ -0,0 +1,91 @@
+package:
+  name: unilabos
+  version: 0.10.15
+
+source:
+  path: ../unilabos
+  target_directory: unilabos
+
+build:
+  python:
+    entry_points:
+    - unilab = unilabos.app.main:main
+  script:
+  - set PIP_NO_INDEX=
+  - if: win
+    then:
+    - copy %RECIPE_DIR%\..\MANIFEST.in %SRC_DIR%
+    - copy %RECIPE_DIR%\..\setup.cfg %SRC_DIR%
+    - copy %RECIPE_DIR%\..\setup.py %SRC_DIR%
+    - call %PYTHON% -m pip install %SRC_DIR%
+  - if: unix
+    then:
+    - cp $RECIPE_DIR/../MANIFEST.in $SRC_DIR
+    - cp $RECIPE_DIR/../setup.cfg $SRC_DIR
+    - cp $RECIPE_DIR/../setup.py $SRC_DIR
+    - $PYTHON -m pip install $SRC_DIR
+
+requirements:
+  host:
+  - python ==3.11.11
+  - pip
+  - setuptools
+  - zstd
+  - zstandard
+  run:
+  - conda-forge::python ==3.11.11
+  - compilers
+  - cmake
+  - zstd
+  - zstandard
+  - ninja
+  - if: unix
+    then:
+    - make
+  - sphinx
+  - sphinx_rtd_theme
+  - numpy
+  - scipy
+  - pandas
+  - networkx
+  - matplotlib
+  - pint
+  - pyserial
+  - pyusb
+  - pylibftdi
+  - pymodbus
+  - python-can
+  - pyvisa
+  - opencv
+  - pydantic
+  - fastapi
+  - uvicorn
+  - gradio
+  - flask
+  - websockets
+  - ipython
+  - jupyter
+  - jupyros
+  - colcon-common-extensions
+  - robostack-staging::ros-humble-desktop-full
+  - robostack-staging::ros-humble-control-msgs
+  - robostack-staging::ros-humble-sensor-msgs
+  - robostack-staging::ros-humble-trajectory-msgs
+  - ros-humble-navigation2
+  - ros-humble-ros2-control
+  - ros-humble-robot-state-publisher
+  - ros-humble-joint-state-publisher
+  - ros-humble-rosbridge-server
+  - ros-humble-cv-bridge
+  - ros-humble-tf2
+  - ros-humble-moveit
+  - ros-humble-moveit-servo
+  - ros-humble-simulation
+  - ros-humble-tf-transformations
+  - transforms3d
+  - uni-lab::ros-humble-unilabos-msgs
+
+about:
+  repository: https://github.com/deepmodeling/Uni-Lab-OS
+  license: GPL-3.0-only
+  description: "Uni-Lab-OS"
--- a/.conda/scripts/post-link.bat
+++ b/.conda/scripts/post-link.bat
@@ -0,0 +1,9 @@
+@echo off
+setlocal enabledelayedexpansion
+
+REM upgrade pip
+"%PREFIX%\python.exe" -m pip install --upgrade pip
+
+REM install extra deps
+"%PREFIX%\python.exe" -m pip install paho-mqtt opentrons_shared_data
+"%PREFIX%\python.exe" -m pip install git+https://github.com/Xuwznln/pylabrobot.git
--- a/.conda/scripts/post-link.sh
+++ b/.conda/scripts/post-link.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -euxo pipefail
+
+# make sure pip is available
+"$PREFIX/bin/python" -m pip install --upgrade pip
+
+# install extra deps
+"$PREFIX/bin/python" -m pip install paho-mqtt opentrons_shared_data
+"$PREFIX/bin/python" -m pip install git+https://github.com/Xuwznln/pylabrobot.git
--- a/.cursorignore
+++ b/.cursorignore
@@ -0,0 +1,26 @@
+.conda
+# .github
+.idea
+# .vscode
+output
+pylabrobot_repo
+recipes
+scripts
+service
+temp
+# unilabos/test
+# unilabos/app/web
+unilabos/device_mesh
+unilabos_data
+unilabos_msgs
+unilabos.egg-info
+CONTRIBUTORS
+# LICENSE
+MANIFEST.in
+pyrightconfig.json
+# README.md
+# README_zh.md
+setup.py
+setup.cfg
+.gitattrubutes
+**/__pycache__
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,19 +0,0 @@
-version: 2
-updates:
-# GitHub Actions
- package-ecosystem: "github-actions"
-  directory: "/"
-  target-branch: "dev"
-  schedule:
-    interval: "weekly"
-    day: "monday"
-    time: "06:00"
-  open-pull-requests-limit: 5
-  reviewers:
-  - "msgcenterpy-team"
-  labels:
-  - "dependencies"
-  - "github-actions"
-  commit-message:
-    prefix: "ci"
-    include: "scope"
--- a/.github/workflows/ci-check.yml
+++ b/.github/workflows/ci-check.yml
@@ -1,67 +0,0 @@
-name: CI Check
-
-on:
-  push:
-    branches: [main, dev]
-  pull_request:
-    branches: [main, dev]
-
-jobs:
-  registry-check:
-    runs-on: windows-latest
-
-    env:
-      # Fix Unicode encoding issue on Windows runner (cp1252 -> utf-8)
-      PYTHONIOENCODING: utf-8
-      PYTHONUTF8: 1
-
-    defaults:
-      run:
-        shell: cmd
-
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - name: Setup Miniforge
-        uses: conda-incubator/setup-miniconda@v3
-        with:
-          miniforge-version: latest
-          use-mamba: true
-          channels: robostack-staging,conda-forge,uni-lab
-          channel-priority: flexible
-          activate-environment: check-env
-          auto-update-conda: false
-          show-channel-urls: true
-
-      - name: Install ROS dependencies, uv and unilabos-msgs
-        run: |
-          echo Installing ROS dependencies...
-          mamba install -n check-env conda-forge::uv conda-forge::opencv robostack-staging::ros-humble-ros-core robostack-staging::ros-humble-action-msgs robostack-staging::ros-humble-std-msgs robostack-staging::ros-humble-geometry-msgs robostack-staging::ros-humble-control-msgs robostack-staging::ros-humble-nav2-msgs uni-lab::ros-humble-unilabos-msgs robostack-staging::ros-humble-cv-bridge robostack-staging::ros-humble-vision-opencv robostack-staging::ros-humble-tf-transformations robostack-staging::ros-humble-moveit-msgs robostack-staging::ros-humble-tf2-ros robostack-staging::ros-humble-tf2-ros-py conda-forge::transforms3d -c robostack-staging -c conda-forge -c uni-lab -y
-
-      - name: Install pip dependencies and unilabos
-        run: |
-          call conda activate check-env
-          echo Installing pip dependencies...
-          uv pip install -r unilabos/utils/requirements.txt
-          uv pip install pywinauto git+https://github.com/Xuwznln/pylabrobot.git
-          uv pip uninstall enum34 || echo enum34 not installed, skipping
-          uv pip install .
-
-      - name: Run check mode (complete_registry)
-        run: |
-          call conda activate check-env
-          echo Running check mode...
-          python -m unilabos --check_mode --skip_env_check
-
-      - name: Check for uncommitted changes
-        shell: bash
-        run: |
-          if ! git diff --exit-code; then
-            echo "::error::检测到文件变化！请先在本地运行 'python -m unilabos --complete_registry' 并提交变更"
-            echo "变化的文件:"
-            git diff --name-only
-            exit 1
-          fi
-          echo "检查通过：无文件变化"
--- a/.github/workflows/conda-pack-build.yml
+++ b/.github/workflows/conda-pack-build.yml
@@ -13,11 +13,6 @@ on:
        required: false
        default: 'win-64'
        type: string
-      build_full:
-        description: '是否构建完整版 unilabos-full (默认构建轻量版 unilabos)'
-        required: false
-        default: false
-        type: boolean

 jobs:
  build-conda-pack:
@@ -62,7 +57,7 @@ jobs:
            echo "should_build=false" >> $GITHUB_OUTPUT
          fi

-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        if: steps.should_build.outputs.should_build == 'true'
        with:
          ref: ${{ github.event.inputs.branch }}
@@ -74,7 +69,7 @@ jobs:
        with:
          miniforge-version: latest
          use-mamba: true
-          python-version: '3.11.14'
+          python-version: '3.11.11'
          channels: conda-forge,robostack-staging,uni-lab,defaults
          channel-priority: flexible
          activate-environment: unilab
@@ -86,14 +81,7 @@ jobs:
        run: |
          echo Installing unilabos and dependencies to unilab environment...
          echo Using mamba for faster and more reliable dependency resolution...
-          echo Build full: ${{ github.event.inputs.build_full }}
-          if "${{ github.event.inputs.build_full }}"=="true" (
-            echo Installing unilabos-full ^(complete package^)...
-            mamba install -n unilab uni-lab::unilabos-full conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
-          ) else (
-            echo Installing unilabos ^(minimal package^)...
-            mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
-          )
+          mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y

      - name: Install conda-pack, unilabos and dependencies (Unix)
        if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
@@ -101,14 +89,7 @@ jobs:
        run: |
          echo "Installing unilabos and dependencies to unilab environment..."
          echo "Using mamba for faster and more reliable dependency resolution..."
-          echo "Build full: ${{ github.event.inputs.build_full }}"
-          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
-            echo "Installing unilabos-full (complete package)..."
-            mamba install -n unilab uni-lab::unilabos-full conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
-          else
-            echo "Installing unilabos (minimal package)..."
-            mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
-          fi
+          mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y

      - name: Get latest ros-humble-unilabos-msgs version (Windows)
        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
@@ -312,7 +293,7 @@ jobs:

      - name: Upload distribution package
        if: steps.should_build.outputs.should_build == 'true'
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
        with:
          name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}
          path: dist-package/
@@ -327,12 +308,7 @@ jobs:
          echo ==========================================
          echo Platform: ${{ matrix.platform }}
          echo Branch: ${{ github.event.inputs.branch }}
-          echo Python version: 3.11.14
-          if "${{ github.event.inputs.build_full }}"=="true" (
-            echo Package: unilabos-full ^(complete^)
-          ) else (
-            echo Package: unilabos ^(minimal^)
-          )
+          echo Python version: 3.11.11
          echo.
          echo Distribution package contents:
          dir dist-package
@@ -352,12 +328,7 @@ jobs:
          echo "=========================================="
          echo "Platform: ${{ matrix.platform }}"
          echo "Branch: ${{ github.event.inputs.branch }}"
-          echo "Python version: 3.11.14"
-          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
-            echo "Package: unilabos-full (complete)"
-          else
-            echo "Package: unilabos (minimal)"
-          fi
+          echo "Python version: 3.11.11"
          echo ""
          echo "Distribution package contents:"
          ls -lh dist-package/
--- a/.github/workflows/deploy-docs.yml
+++ b/.github/workflows/deploy-docs.yml
@@ -1,12 +1,10 @@
 name: Deploy Docs

 on:
-  # 在 CI Check 成功后自动触发（仅 main 分支）
-  workflow_run:
-    workflows: ["CI Check"]
-    types: [completed]
+  push:
+    branches: [main]
+  pull_request:
    branches: [main]
-  # 手动触发
  workflow_dispatch:
    inputs:
      branch:
@@ -35,19 +33,12 @@ concurrency:
 jobs:
  # Build documentation
  build:
-    # 只在以下情况运行：
-    # 1. workflow_run 触发且 CI Check 成功
-    # 2. 手动触发
-    if: |
-      github.event_name == 'workflow_dispatch' ||
-      (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success')
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
        with:
-          # workflow_run 时使用触发工作流的分支，手动触发时使用输入的分支
-          ref: ${{ github.event.workflow_run.head_branch || github.event.inputs.branch || github.ref }}
+          ref: ${{ github.event.inputs.branch || github.ref }}
          fetch-depth: 0

      - name: Setup Miniforge (with mamba)
@@ -55,7 +46,7 @@ jobs:
        with:
          miniforge-version: latest
          use-mamba: true
-          python-version: '3.11.14'
+          python-version: '3.11.11'
          channels: conda-forge,robostack-staging,uni-lab,defaults
          channel-priority: flexible
          activate-environment: unilab
@@ -84,10 +75,8 @@ jobs:

      - name: Setup Pages
        id: pages
-        uses: actions/configure-pages@v5
-        if: |
-          github.event.workflow_run.head_branch == 'main' ||
-          (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
+        uses: actions/configure-pages@v4
+        if: github.ref == 'refs/heads/main' || (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')

      - name: Build Sphinx documentation
        run: |
@@ -105,18 +94,14 @@ jobs:
          test -f docs/_build/html/index.html && echo "✓ index.html exists" || echo "✗ index.html missing"

      - name: Upload build artifacts
-        uses: actions/upload-pages-artifact@v4
-        if: |
-          github.event.workflow_run.head_branch == 'main' ||
-          (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
+        uses: actions/upload-pages-artifact@v3
+        if: github.ref == 'refs/heads/main' || (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
        with:
          path: docs/_build/html

  # Deploy to GitHub Pages
  deploy:
-    if: |
-      github.event.workflow_run.head_branch == 'main' ||
-      (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
+    if: github.ref == 'refs/heads/main' || (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
--- a/.github/workflows/multi-platform-build.yml
+++ b/.github/workflows/multi-platform-build.yml
@@ -1,16 +1,11 @@
 name: Multi-Platform Conda Build

 on:
-  # 在 CI Check 工作流完成后触发（仅限 main/dev 分支）
-  workflow_run:
-    workflows: ["CI Check"]
-    types:
-      - completed
-    branches: [main, dev]
-  # 支持 tag 推送（不依赖 CI Check）
  push:
+    branches: [main, dev]
    tags: ['v*']
-  # 手动触发
+  pull_request:
+    branches: [main, dev]
  workflow_dispatch:
    inputs:
      platforms:
@@ -22,37 +17,9 @@ on:
        required: false
        default: false
        type: boolean
-      skip_ci_check:
-        description: '跳过等待 CI Check (手动触发时可选)'
-        required: false
-        default: false
-        type: boolean

 jobs:
-  # 等待 CI Check 完成的 job (仅用于 workflow_run 触发)
-  wait-for-ci:
-    runs-on: ubuntu-latest
-    if: github.event_name == 'workflow_run'
-    outputs:
-      should_continue: ${{ steps.check.outputs.should_continue }}
-    steps:
-      - name: Check CI status
-        id: check
-        run: |
-          if [[ "${{ github.event.workflow_run.conclusion }}" == "success" ]]; then
-            echo "should_continue=true" >> $GITHUB_OUTPUT
-            echo "CI Check passed, proceeding with build"
-          else
-            echo "should_continue=false" >> $GITHUB_OUTPUT
-            echo "CI Check did not succeed (status: ${{ github.event.workflow_run.conclusion }}), skipping build"
-          fi
-
  build:
-    needs: [wait-for-ci]
-    # 运行条件：workflow_run 触发且 CI 成功，或者其他触发方式
-    if: |
-      always() &&
-      (needs.wait-for-ci.result == 'skipped' || needs.wait-for-ci.outputs.should_continue == 'true')
    strategy:
      fail-fast: false
      matrix:
@@ -77,10 +44,8 @@ jobs:
        shell: bash -l {0}

    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
-          # 如果是 workflow_run 触发，使用触发 CI Check 的 commit
-          ref: ${{ github.event.workflow_run.head_sha || github.ref }}
          fetch-depth: 0

      - name: Check if platform should be built
@@ -104,6 +69,7 @@ jobs:
          channels: conda-forge,robostack-staging,defaults
          channel-priority: strict
          activate-environment: build-env
+          auto-activate-base: false
          auto-update-conda: false
          show-channel-urls: true

@@ -149,7 +115,7 @@ jobs:

      - name: Upload conda package artifacts
        if: steps.should_build.outputs.should_build == 'true'
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
        with:
          name: conda-package-${{ matrix.platform }}
          path: conda-packages-temp
--- a/.github/workflows/unilabos-conda-build.yml
+++ b/.github/workflows/unilabos-conda-build.yml
@@ -1,62 +1,25 @@
 name: UniLabOS Conda Build

 on:
-  # 在 CI Check 成功后自动触发
-  workflow_run:
-    workflows: ["CI Check"]
-    types: [completed]
-    branches: [main, dev]
-  # 标签推送时直接触发（发布版本）
  push:
+    branches: [main, dev]
    tags: ['v*']
-  # 手动触发
+  pull_request:
+    branches: [main, dev]
  workflow_dispatch:
    inputs:
      platforms:
        description: '选择构建平台 (逗号分隔): linux-64, osx-64, osx-arm64, win-64'
        required: false
        default: 'linux-64'
-      build_full:
-        description: '是否构建 unilabos-full 完整包 (默认只构建 unilabos 基础包)'
-        required: false
-        default: false
-        type: boolean
      upload_to_anaconda:
        description: '是否上传到Anaconda.org'
        required: false
        default: false
        type: boolean
-      skip_ci_check:
-        description: '跳过等待 CI Check (手动触发时可选)'
-        required: false
-        default: false
-        type: boolean

 jobs:
-  # 等待 CI Check 完成的 job (仅用于 workflow_run 触发)
-  wait-for-ci:
-    runs-on: ubuntu-latest
-    if: github.event_name == 'workflow_run'
-    outputs:
-      should_continue: ${{ steps.check.outputs.should_continue }}
-    steps:
-      - name: Check CI status
-        id: check
-        run: |
-          if [[ "${{ github.event.workflow_run.conclusion }}" == "success" ]]; then
-            echo "should_continue=true" >> $GITHUB_OUTPUT
-            echo "CI Check passed, proceeding with build"
-          else
-            echo "should_continue=false" >> $GITHUB_OUTPUT
-            echo "CI Check did not succeed (status: ${{ github.event.workflow_run.conclusion }}), skipping build"
-          fi
-
  build:
-    needs: [wait-for-ci]
-    # 运行条件：workflow_run 触发且 CI 成功，或者其他触发方式
-    if: |
-      always() &&
-      (needs.wait-for-ci.result == 'skipped' || needs.wait-for-ci.outputs.should_continue == 'true')
    strategy:
      fail-fast: false
      matrix:
@@ -77,10 +40,8 @@ jobs:
        shell: bash -l {0}

    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
-          # 如果是 workflow_run 触发，使用触发 CI Check 的 commit
-          ref: ${{ github.event.workflow_run.head_sha || github.ref }}
          fetch-depth: 0

      - name: Check if platform should be built
@@ -104,6 +65,7 @@ jobs:
          channels: conda-forge,robostack-staging,uni-lab,defaults
          channel-priority: strict
          activate-environment: build-env
+          auto-activate-base: false
          auto-update-conda: false
          show-channel-urls: true

@@ -119,61 +81,12 @@ jobs:
          conda list | grep -E "(rattler-build|anaconda-client)"
          echo "Platform: ${{ matrix.platform }}"
          echo "OS: ${{ matrix.os }}"
-          echo "Build full package: ${{ github.event.inputs.build_full || 'false' }}"
-          echo "Building packages:"
-          echo "  - unilabos-env (environment dependencies)"
-          echo "  - unilabos (with pip package)"
-          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
-            echo "  - unilabos-full (complete package)"
-          fi
+          echo "Building UniLabOS package"

-      - name: Build unilabos-env (conda environment only, noarch)
+      - name: Build conda package
        if: steps.should_build.outputs.should_build == 'true'
        run: |
-          echo "Building unilabos-env (conda environment dependencies)..."
-          rattler-build build -r .conda/environment/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge
-
-      - name: Upload unilabos-env to Anaconda.org (if enabled)
-        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
-        run: |
-          echo "Uploading unilabos-env to uni-lab organization..."
-          for package in $(find ./output -name "unilabos-env*.conda"); do
-            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
-          done
-
-      - name: Build unilabos (with pip package)
-        if: steps.should_build.outputs.should_build == 'true'
-        run: |
-          echo "Building unilabos package..."
-          # 如果已上传到 Anaconda，从 uni-lab channel 获取 unilabos-env；否则从本地 output 获取
-          rattler-build build -r .conda/base/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge --channel ./output
-
-      - name: Upload unilabos to Anaconda.org (if enabled)
-        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
-        run: |
-          echo "Uploading unilabos to uni-lab organization..."
-          for package in $(find ./output -name "unilabos-0*.conda" -o -name "unilabos-[0-9]*.conda"); do
-            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
-          done
-
-      - name: Build unilabos-full - Only when explicitly requested
-        if: |
-          steps.should_build.outputs.should_build == 'true' && 
-          github.event.inputs.build_full == 'true'
-        run: |
-          echo "Building unilabos-full package on ${{ matrix.platform }}..."
-          rattler-build build -r .conda/full/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge --channel ./output
-
-      - name: Upload unilabos-full to Anaconda.org (if enabled)
-        if: |
-          steps.should_build.outputs.should_build == 'true' && 
-          github.event.inputs.build_full == 'true' &&
-          github.event.inputs.upload_to_anaconda == 'true'
-        run: |
-          echo "Uploading unilabos-full to uni-lab organization..."
-          for package in $(find ./output -name "unilabos-full*.conda"); do
-            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
-          done
+          rattler-build build -r .conda/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge

      - name: List built packages
        if: steps.should_build.outputs.should_build == 'true'
@@ -195,9 +108,17 @@ jobs:

      - name: Upload conda package artifacts
        if: steps.should_build.outputs.should_build == 'true'
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
        with:
          name: conda-package-unilabos-${{ matrix.platform }}
          path: conda-packages-temp
          if-no-files-found: warn
          retention-days: 30
+
+      - name: Upload to Anaconda.org (uni-lab organization)
+        if: github.event.inputs.upload_to_anaconda == 'true'
+        run: |
+          for package in $(find ./output -name "*.conda"); do
+            echo "Uploading $package to uni-lab organization..."
+            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
+          done
--- a/.gitignore
+++ b/.gitignore
@@ -4,7 +4,6 @@ temp/
 output/
 unilabos_data/
 pyrightconfig.json
-.cursorignore
 ## Python

 # Byte-compiled / optimized / DLL files
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,5 +1,4 @@
 recursive-include unilabos/test *
-recursive-include unilabos/utils *
 recursive-include unilabos/registry *.yaml
 recursive-include unilabos/app/web/static *
 recursive-include unilabos/app/web/templates *
--- a/README.md
+++ b/README.md
@@ -31,46 +31,26 @@ Detailed documentation can be found at:

 ## Quick Start

-### 1. Setup Conda Environment
+1. Setup Conda Environment

-Uni-Lab-OS recommends using `mamba` for environment management. Choose the package that fits your needs:
-
-| Package | Use Case | Contents |
-|---------|----------|----------|
-| `unilabos` | **Recommended for most users** | Complete package, ready to use |
-| `unilabos-env` | Developers (editable install) | Environment only, install unilabos via pip |
-| `unilabos-full` | Simulation/Visualization | unilabos + ROS2 Desktop + Gazebo + MoveIt |
+Uni-Lab-OS recommends using `mamba` for environment management:

 ```bash
 # Create new environment
-mamba create -n unilab python=3.11.14
+mamba create -n unilab python=3.11.11
 mamba activate unilab
-
-# Option A: Standard installation (recommended for most users)
-mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
-
-# Option B: For developers (editable mode development)
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-# Then install unilabos and dependencies:
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git && cd Uni-Lab-OS
-pip install -e .
-uv pip install -r unilabos/utils/requirements.txt
-
-# Option C: Full installation (simulation/visualization)
-mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```

-**When to use which?**
- **unilabos**: Standard installation for production deployment and general usage (recommended)
- **unilabos-env**: For developers who need `pip install -e .` editable mode, modify source code
- **unilabos-full**: For simulation (Gazebo), visualization (rviz2), and Jupyter notebooks
-
-### 2. Clone Repository (Optional, for developers)
+2. Install Dev Uni-Lab-OS

 ```bash
-# Clone the repository (only needed for development or examples)
+# Clone the repository
 git clone https://github.com/deepmodeling/Uni-Lab-OS.git
 cd Uni-Lab-OS
+
+# Install Uni-Lab-OS
+pip install .
 ```

 3. Start Uni-Lab System
--- a/README_zh.md
+++ b/README_zh.md
@@ -31,46 +31,26 @@ Uni-Lab-OS 是一个用于实验室自动化的综合平台，旨在连接和控

 ## 快速开始

-### 1. 配置 Conda 环境
+1. 配置 Conda 环境

-Uni-Lab-OS 建议使用 `mamba` 管理环境。根据您的需求选择合适的安装包：
-
-| 安装包 | 适用场景 | 包含内容 |
-|--------|----------|----------|
-| `unilabos` | **推荐大多数用户** | 完整安装包，开箱即用 |
-| `unilabos-env` | 开发者（可编辑安装） | 仅环境依赖，通过 pip 安装 unilabos |
-| `unilabos-full` | 仿真/可视化 | unilabos + ROS2 桌面版 + Gazebo + MoveIt |
+Uni-Lab-OS 建议使用 `mamba` 管理环境。根据您的操作系统选择适当的环境文件:

 ```bash
 # 创建新环境
-mamba create -n unilab python=3.11.14
+mamba create -n unilab python=3.11.11
 mamba activate unilab
-
-# 方案 A：标准安装（推荐大多数用户）
-mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
-
-# 方案 B：开发者环境（可编辑模式开发）
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-# 然后安装 unilabos 和依赖：
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git && cd Uni-Lab-OS
-pip install -e .
-uv pip install -r unilabos/utils/requirements.txt
-
-# 方案 C：完整安装（仿真/可视化）
-mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```

-**如何选择？**
- **unilabos**：标准安装，适用于生产部署和日常使用（推荐）
- **unilabos-env**：开发者使用，支持 `pip install -e .` 可编辑模式，可修改源代码
- **unilabos-full**：需要仿真（Gazebo）、可视化（rviz2）或 Jupyter Notebook
-
-### 2. 克隆仓库（可选，供开发者使用）
+2. 安装开发版 Uni-Lab-OS:

 ```bash
-# 克隆仓库（仅开发或查看示例时需要）
+# 克隆仓库
 git clone https://github.com/deepmodeling/Uni-Lab-OS.git
 cd Uni-Lab-OS
+
+# 安装 Uni-Lab-OS
+pip install .
 ```

 3. 启动 Uni-Lab 系统
--- a/docs/moveit2_integration_summary.md
+++ b/docs/moveit2_integration_summary.md
--- a/docs/user_guide/best_practice.md
+++ b/docs/user_guide/best_practice.md
@@ -31,14 +31,6 @@

 详细的安装步骤请参考 [安装指南](installation.md)。

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

 ```bash
@@ -46,30 +38,15 @@
 # 下载 Miniforge: https://github.com/conda-forge/miniforge/releases

 # 2. 创建 Conda 环境
-mamba create -n unilab python=3.11.14
+mamba create -n unilab python=3.11.11

 # 3. 激活环境
 mamba activate unilab

-# 4. 安装 Uni-Lab-OS（选择其一）
-
-# 方案 A：标准安装（推荐大多数用户）
+# 4. 安装 Uni-Lab-OS
 mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
-
-# 方案 B：开发者环境（可编辑模式开发）
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-pip install -e /path/to/Uni-Lab-OS  # 可编辑安装
-uv pip install -r unilabos/utils/requirements.txt  # 安装 pip 依赖
-
-# 方案 C：完整版（仿真/可视化）
-mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
 ```

-**选择建议：**
- **日常使用/生产部署**：使用 `unilabos`（推荐），完整功能，开箱即用
- **开发者**：使用 `unilabos-env` + `pip install -e .` + `uv pip install -r unilabos/utils/requirements.txt`，代码修改立即生效
- **仿真/可视化**：使用 `unilabos-full`，含 Gazebo、rviz2、MoveIt
-
 #### 1.2 验证安装

 ```bash
@@ -439,9 +416,6 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 1. 访问 Web 界面，进入"仪器耗材"模块
 2. 在"仪器设备"区域找到并添加上述设备
 3. 在"物料耗材"区域找到并添加容器
-4. 在workstation中配置protocol_type包含PumpTransferProtocol
-
-![添加Protocol类型](image/add_protocol.png)

 ![物料列表](image/material.png)

@@ -452,9 +426,8 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 **操作步骤：**

 1. 将两个 `container` 拖拽到 `workstation` 中
-2. 将 `virtual_multiway_valve` 拖拽到 `workstation` 中
-3. 将 `virtual_transfer_pump` 拖拽到 `workstation` 中
-4. 在画布上连接它们（建立父子关系）
+2. 将 `virtual_transfer_pump` 拖拽到 `workstation` 中
+3. 在画布上连接它们（建立父子关系）

 ![设备连接](image/links.png)

@@ -795,43 +768,7 @@ Waiting for host service...

 详细的设备驱动编写指南请参考 [添加设备驱动](../developer_guide/add_device.md)。

-#### 9.1 开发环境准备
-
-**推荐使用 `unilabos-env` + `pip install -e .` + `uv pip install`** 进行设备开发：
-
-```bash
-# 1. 创建环境并安装 unilabos-env（ROS2 + conda 依赖 + uv）
-mamba create -n unilab python=3.11.14
-conda activate unilab
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-
-# 2. 克隆代码
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
-cd Uni-Lab-OS
-
-# 3. 以可编辑模式安装（推荐使用脚本，自动检测中文环境）
-python scripts/dev_install.py
-
-# 或手动安装：
-pip install -e .
-uv pip install -r unilabos/utils/requirements.txt
-```
-
-**为什么使用这种方式？**
- `unilabos-env` 提供 ROS2 核心组件和 uv（通过 conda 安装，避免编译）
- `unilabos/utils/requirements.txt` 包含所有运行时需要的 pip 依赖
- `dev_install.py` 自动检测中文环境，中文系统自动使用清华镜像
- 使用 `uv` 替代 `pip`，安装速度更快
- 可编辑模式：代码修改**立即生效**，无需重新安装
-
-**如果安装失败或速度太慢**，可以手动执行（使用清华镜像）：
-
-```bash
-pip install -e . -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
-uv pip install -r unilabos/utils/requirements.txt -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
-```
-
-#### 9.2 为什么需要自定义设备？
+#### 9.1 为什么需要自定义设备？

 Uni-Lab-OS 内置了常见设备，但您的实验室可能有特殊设备需要集成：

@@ -840,7 +777,7 @@ Uni-Lab-OS 内置了常见设备，但您的实验室可能有特殊设备需要
 - 特殊的实验流程
 - 第三方设备集成

-#### 9.3 创建 Python 包
+#### 9.2 创建 Python 包

 为了方便开发和管理，建议为您的实验室创建独立的 Python 包。

@@ -877,7 +814,7 @@ touch my_lab_devices/my_lab_devices/__init__.py
 touch my_lab_devices/my_lab_devices/devices/__init__.py
 ```

-#### 9.4 创建 setup.py
+#### 9.3 创建 setup.py

 ```python
 # my_lab_devices/setup.py
@@ -908,7 +845,7 @@ setup(
 )
 ```

-#### 9.5 开发安装
+#### 9.4 开发安装

 使用 `-e` 参数进行可编辑安装，这样代码修改后立即生效：

@@ -923,7 +860,7 @@ pip install -e . -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 - 方便调试和测试
 - 支持版本控制（git）

-#### 9.6 编写设备驱动
+#### 9.5 编写设备驱动

 创建设备驱动文件：

@@ -1064,7 +1001,7 @@ class MyPump:
 - **返回 Dict**：所有动作方法返回字典类型
 - **文档字符串**：详细说明参数和功能

-#### 9.7 测试设备驱动
+#### 9.6 测试设备驱动

 创建简单的测试脚本：

--- a/docs/user_guide/image/add_protocol.png
+++ b/docs/user_guide/image/add_protocol.png
--- a/docs/user_guide/image/links.png
+++ b/docs/user_guide/image/links.png
--- a/docs/user_guide/installation.md
+++ b/docs/user_guide/installation.md
@@ -13,26 +13,15 @@
  - 开发者需要 Git 和基本的 Python 开发知识
  - 自定义 msgs 需要 GitHub 账号

-## 安装包选择
-
-Uni-Lab-OS 提供三个安装包版本，根据您的需求选择：
-
-| 安装包 | 适用场景 | 包含组件 | 磁盘占用 |
-|--------|----------|----------|----------|
-| **unilabos** | **推荐大多数用户**，生产部署 | 完整安装包，开箱即用 | ~2-3 GB |
-| **unilabos-env** | 开发者环境（可编辑安装） | 仅环境依赖，通过 pip 安装 unilabos | ~2 GB |
-| **unilabos-full** | 仿真可视化、完整功能体验 | unilabos + 完整 ROS2 桌面版 + Gazebo + MoveIt | ~8-10 GB |
-
 ## 安装方式选择

 根据您的使用场景，选择合适的安装方式：

-| 安装方式               | 适用人群             | 推荐安装包        | 特点                           | 安装时间                     |
-| ---------------------- | -------------------- | ----------------- | ------------------------------ | ---------------------------- |
-| **方式一：一键安装**   | 快速体验、演示       | 预打包环境        | 离线可用，无需配置             | 5-10 分钟 (网络良好的情况下) |
-| **方式二：手动安装**   | **大多数用户**       | `unilabos`        | 完整功能，开箱即用             | 10-20 分钟                   |
-| **方式三：开发者安装** | 开发者、需要修改源码 | `unilabos-env`    | 可编辑模式，支持自定义开发     | 20-30 分钟                   |
-| **仿真/可视化**        | 仿真测试、可视化调试 | `unilabos-full`   | 含 Gazebo、rviz2、MoveIt       | 30-60 分钟                   |
+| 安装方式               | 适用人群             | 特点                           | 安装时间                     |
+| ---------------------- | -------------------- | ------------------------------ | ---------------------------- |
+| **方式一：一键安装**   | 实验室用户、快速体验 | 预打包环境，离线可用，无需配置 | 5-10 分钟 (网络良好的情况下) |
+| **方式二：手动安装**   | 标准用户、生产环境   | 灵活配置，版本可控             | 10-20 分钟                   |
+| **方式三：开发者安装** | 开发者、需要修改源码 | 可编辑模式，支持自定义 msgs    | 20-30 分钟                   |

 ---

@@ -155,38 +144,17 @@ bash Miniforge3-$(uname)-$(uname -m).sh
 使用以下命令创建 Uni-Lab 专用环境：

 ```bash
-mamba create -n unilab python=3.11.14  # 目前ros2组件依赖版本大多为3.11.14
+mamba create -n unilab python=3.11.11  # 目前ros2组件依赖版本大多为3.11.11
 mamba activate unilab
-
-# 选择安装包（三选一）：
-
-# 方案 A：标准安装（推荐大多数用户）
-mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
-
-# 方案 B：开发者环境（可编辑模式开发）
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-# 然后安装 unilabos 和 pip 依赖：
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git && cd Uni-Lab-OS
-pip install -e .
-uv pip install -r unilabos/utils/requirements.txt
-
-# 方案 C：完整版（含仿真和可视化工具）
-mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```

 **参数说明**:

 - `-n unilab`: 创建名为 "unilab" 的环境
- `uni-lab::unilabos`: 安装 unilabos 完整包，开箱即用（推荐）
- `uni-lab::unilabos-env`: 仅安装环境依赖，适合开发者使用 `pip install -e .`
- `uni-lab::unilabos-full`: 安装完整包（含 ROS2 Desktop、Gazebo、MoveIt 等）
+- `uni-lab::unilabos`: 从 uni-lab channel 安装 unilabos 包
 - `-c robostack-staging -c conda-forge`: 添加额外的软件源

-**包选择建议**：
- **日常使用/生产部署**：安装 `unilabos`（推荐，完整功能，开箱即用）
- **开发者**：安装 `unilabos-env`，然后使用 `uv pip install -r unilabos/utils/requirements.txt` 安装依赖，再 `pip install -e .` 进行可编辑安装
- **仿真/可视化**：安装 `unilabos-full`（Gazebo、rviz2、MoveIt）
-
 **如果遇到网络问题**，可以使用清华镜像源加速下载：

 ```bash
@@ -195,14 +163,8 @@ mamba config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/m
 mamba config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
 mamba config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/

-# 然后重新执行安装命令（推荐标准安装）
+# 然后重新执行安装命令
 mamba create -n unilab uni-lab::unilabos -c robostack-staging
-
-# 或完整版（仿真/可视化）
-mamba create -n unilab uni-lab::unilabos-full -c robostack-staging
-
-# pip 安装时使用清华镜像（开发者安装时使用）
-uv pip install -r unilabos/utils/requirements.txt -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 ```

 ### 第三步：激活环境
@@ -241,87 +203,58 @@ cd Uni-Lab-OS
   cd Uni-Lab-OS
   ```

-### 第二步：安装开发环境（unilabos-env）
+### 第二步：安装基础环境

-**重要**：开发者请使用 `unilabos-env` 包，它专为开发者设计：
- 包含 ROS2 核心组件和消息包（ros-humble-ros-core、std-msgs、geometry-msgs 等）
- 包含 transforms3d、cv-bridge、tf2 等 conda 依赖
- 包含 `uv` 工具，用于快速安装 pip 依赖
- **不包含** pip 依赖和 unilabos 包（由 `pip install -e .` 和 `uv pip install` 安装）
+**推荐方式**：先通过**方式一（一键安装）**或**方式二（手动安装）**完成基础环境的安装，这将包含所有必需的依赖项（ROS2、msgs 等）。
+
+#### 选项 A：通过一键安装（推荐）
+
+参考上文"方式一：一键安装"，完成基础环境的安装后，激活环境：

 ```bash
-# 创建并激活环境
-mamba create -n unilab python=3.11.14
 conda activate unilab
-
-# 安装开发者环境包（ROS2 + conda 依赖 + uv）
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
 ```

-### 第三步：安装 pip 依赖和可编辑模式安装
+#### 选项 B：通过手动安装

-克隆代码并安装依赖：
+参考上文"方式二：手动安装"，创建并安装环境：
+
+```bash
+mamba create -n unilab python=3.11.11
+conda activate unilab
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
+```
+
+**说明**：这会安装包括 Python 3.11.11、ROS2 Humble、ros-humble-unilabos-msgs 和所有必需依赖
+
+### 第三步：切换到开发版本
+
+现在你已经有了一个完整可用的 Uni-Lab 环境，接下来将 unilabos 包切换为开发版本：

 ```bash
 # 确保环境已激活
 conda activate unilab

-# 克隆仓库（如果还未克隆）
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
-cd Uni-Lab-OS
+# 卸载 pip 安装的 unilabos（保留所有 conda 依赖）
+pip uninstall unilabos -y

-# 切换到 dev 分支（可选）
+# 克隆 dev 分支（如果还未克隆）
+cd /path/to/your/workspace
+git clone -b dev https://github.com/deepmodeling/Uni-Lab-OS.git
+# 或者如果已经克隆，切换到 dev 分支
+cd Uni-Lab-OS
 git checkout dev
 git pull
-```

-**推荐：使用安装脚本**（自动检测中文环境，使用 uv 加速）：
-
-```bash
-# 自动检测中文环境，如果是中文系统则使用清华镜像
-python scripts/dev_install.py
-
-# 或者手动指定：
-python scripts/dev_install.py --china     # 强制使用清华镜像
-python scripts/dev_install.py --no-mirror # 强制使用 PyPI
-python scripts/dev_install.py --skip-deps # 跳过 pip 依赖安装
-python scripts/dev_install.py --use-pip   # 使用 pip 而非 uv
-```
-
-**手动安装**（如果脚本安装失败或速度太慢）：
-
-```bash
-# 1. 安装 unilabos（可编辑模式）
-pip install -e .
-
-# 2. 使用 uv 安装 pip 依赖（推荐，速度更快）
-uv pip install -r unilabos/utils/requirements.txt
-
-# 国内用户使用清华镜像：
+# 以可编辑模式安装开发版 unilabos
 pip install -e . -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
-uv pip install -r unilabos/utils/requirements.txt -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 ```

-**注意**：
- `uv` 已包含在 `unilabos-env` 中，无需单独安装
- `unilabos/utils/requirements.txt` 包含运行 unilabos 所需的所有 pip 依赖
- 部分特殊包（如 pylabrobot）会在运行时由 unilabos 自动检测并安装
+**参数说明**：

-**为什么使用可编辑模式？**
-
- `-e` (editable mode)：代码修改**立即生效**，无需重新安装
- 适合开发调试：修改代码后直接运行测试
- 与 `unilabos-env` 配合：环境依赖由 conda 管理，unilabos 代码由 pip 管理
-
-**验证安装**：
-
-```bash
-# 检查 unilabos 版本
-python -c "import unilabos; print(unilabos.__version__)"
-
-# 检查安装位置（应该指向你的代码目录）
-pip show unilabos | grep Location
-```
+- `-e`: editable mode（可编辑模式），代码修改立即生效，无需重新安装
+- `-i`: 使用清华镜像源加速下载
+- `pip uninstall unilabos`: 只卸载 pip 安装的 unilabos 包，不影响 conda 安装的其他依赖（如 ROS2、msgs 等）

 ### 第四步：安装或自定义 ros-humble-unilabos-msgs（可选）

@@ -531,45 +464,7 @@ cd $CONDA_PREFIX/envs/unilab

 ### 问题 8: 环境很大，有办法减小吗？

-**解决方案**: 
-
-1. **使用 `unilabos` 标准版**（推荐大多数用户）：
-   ```bash
-   mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
-   ```
-   标准版包含完整功能，环境大小约 2-3GB（相比完整版的 8-10GB）。
-
-2. **使用 `unilabos-env` 开发者版**（最小化）：
-   ```bash
-   mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-   # 然后手动安装依赖
-   pip install -e .
-   uv pip install -r unilabos/utils/requirements.txt
-   ```
-   开发者版只包含环境依赖，体积最小约 2GB。
-
-3. **按需安装额外组件**：
-   如果后续需要特定功能，可以单独安装：
-   ```bash
-   # 需要 Jupyter
-   mamba install jupyter jupyros
-   
-   # 需要可视化
-   mamba install matplotlib opencv
-   
-   # 需要仿真（注意：这会安装大量依赖）
-   mamba install ros-humble-gazebo-ros
-   ```
-
-4. **预打包环境问题**：
-   预打包环境（方式一）包含所有依赖，通常较大（压缩后 2-5GB）。这是为了确保离线安装和完整功能。
-
-**包选择建议**：
-| 需求 | 推荐包 | 预估大小 |
-|------|--------|----------|
-| 日常使用/生产部署 | `unilabos` | ~2-3 GB |
-| 开发调试（可编辑模式） | `unilabos-env` | ~2 GB |
-| 仿真/可视化 | `unilabos-full` | ~8-10 GB |
+**解决方案**: 预打包的环境包含所有依赖，通常较大（压缩后 2-5GB）。这是为了确保离线安装和完整功能。如果空间有限，考虑使用方式二手动安装，只安装需要的组件。

 ### 问题 9: 如何更新到最新版本？

@@ -616,7 +511,6 @@ mamba update ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-f

 **提示**:

- **大多数用户**推荐使用方式二（手动安装）的 `unilabos` 标准版
- **开发者**推荐使用方式三（开发者安装），安装 `unilabos-env` 后使用 `uv pip install -r unilabos/utils/requirements.txt` 安装依赖
- **仿真/可视化**推荐安装 `unilabos-full` 完整版
- **快速体验和演示**推荐使用方式一（一键安装）
+- 生产环境推荐使用方式二（手动安装）的稳定版本
+- 开发和测试推荐使用方式三（开发者安装）
+- 快速体验和演示推荐使用方式一（一键安装）
--- a/recipes/msgs/recipe.yaml
+++ b/recipes/msgs/recipe.yaml
@@ -1,6 +1,6 @@
 package:
  name: ros-humble-unilabos-msgs
-  version: 0.10.18
+  version: 0.10.15
 source:
  path: ../../unilabos_msgs
  target_directory: src
@@ -25,7 +25,7 @@ requirements:
  build:
  - ${{ compiler('cxx') }}
  - ${{ compiler('c') }}
-  - python ==3.11.14
+  - python ==3.11.11
  - numpy
  - if: build_platform != target_platform
    then:
@@ -63,14 +63,14 @@ requirements:
  - robostack-staging::ros-humble-rosidl-default-generators
  - robostack-staging::ros-humble-std-msgs
  - robostack-staging::ros-humble-geometry-msgs
-  - robostack-staging::ros2-distro-mutex=0.7
+  - robostack-staging::ros2-distro-mutex=0.6
  run:
  - robostack-staging::ros-humble-action-msgs
  - robostack-staging::ros-humble-ros-workspace
  - robostack-staging::ros-humble-rosidl-default-runtime
  - robostack-staging::ros-humble-std-msgs
  - robostack-staging::ros-humble-geometry-msgs
-  - robostack-staging::ros2-distro-mutex=0.7
+  - robostack-staging::ros2-distro-mutex=0.6
  - if: osx and x86_64
    then:
    - __osx >=${{ MACOSX_DEPLOYMENT_TARGET|default('10.14') }}
--- a/recipes/unilabos/recipe.yaml
+++ b/recipes/unilabos/recipe.yaml
@@ -1,6 +1,6 @@
 package:
  name: unilabos
-  version: "0.10.18"
+  version: "0.10.15"

 source:
  path: ../..
--- a/scripts/create_readme.py
+++ b/scripts/create_readme.py
@@ -85,7 +85,7 @@ Verification:
 -------------

 The verify_installation.py script will check:
-  - Python version (3.11.14)
+  - Python version (3.11.11)
  - ROS2 rclpy installation
  - UniLabOS installation and dependencies

@@ -104,7 +104,7 @@ Build Information:

  Branch:   {branch}
  Platform: {platform}
-  Python:   3.11.14
+  Python:   3.11.11
  Date:     {build_date}

 Troubleshooting:
--- a/scripts/dev_install.py
+++ b/scripts/dev_install.py
@@ -1,214 +0,0 @@
-#!/usr/bin/env python3
-"""
-Development installation script for UniLabOS.
-Auto-detects Chinese locale and uses appropriate mirror.
-
-Usage:
-    python scripts/dev_install.py
-    python scripts/dev_install.py --no-mirror  # Force no mirror
-    python scripts/dev_install.py --china      # Force China mirror
-    python scripts/dev_install.py --skip-deps  # Skip pip dependencies installation
-
-Flow:
-    1. pip install -e . (install unilabos in editable mode)
-    2. Detect Chinese locale
-    3. Use uv to install pip dependencies from requirements.txt
-    4. Special packages (like pylabrobot) are handled by environment_check.py at runtime
-"""
-
-import locale
-import subprocess
-import sys
-import argparse
-from pathlib import Path
-
-# Tsinghua mirror URL
-TSINGHUA_MIRROR = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
-
-
-def is_chinese_locale() -> bool:
-    """
-    Detect if system is in Chinese locale.
-    Same logic as EnvironmentChecker._is_chinese_locale()
-    """
-    try:
-        lang = locale.getdefaultlocale()[0]
-        if lang and ("zh" in lang.lower() or "chinese" in lang.lower()):
-            return True
-    except Exception:
-        pass
-    return False
-
-
-def run_command(cmd: list, description: str, retry: int = 2) -> bool:
-    """Run command with retry support."""
-    print(f"[INFO] {description}")
-    print(f"[CMD] {' '.join(cmd)}")
-
-    for attempt in range(retry + 1):
-        try:
-            result = subprocess.run(cmd, check=True, timeout=600)
-            print(f"[OK] {description}")
-            return True
-        except subprocess.CalledProcessError as e:
-            if attempt < retry:
-                print(f"[WARN] Attempt {attempt + 1} failed, retrying...")
-            else:
-                print(f"[ERROR] {description} failed: {e}")
-                return False
-        except subprocess.TimeoutExpired:
-            print(f"[ERROR] {description} timed out")
-            return False
-    return False
-
-
-def install_editable(project_root: Path, use_mirror: bool) -> bool:
-    """Install unilabos in editable mode using pip."""
-    cmd = [sys.executable, "-m", "pip", "install", "-e", str(project_root)]
-    if use_mirror:
-        cmd.extend(["-i", TSINGHUA_MIRROR])
-
-    return run_command(cmd, "Installing unilabos in editable mode")
-
-
-def install_requirements_uv(requirements_file: Path, use_mirror: bool) -> bool:
-    """Install pip dependencies using uv (installed via conda-forge::uv)."""
-    cmd = ["uv", "pip", "install", "-r", str(requirements_file)]
-    if use_mirror:
-        cmd.extend(["-i", TSINGHUA_MIRROR])
-
-    return run_command(cmd, "Installing pip dependencies with uv", retry=2)
-
-
-def install_requirements_pip(requirements_file: Path, use_mirror: bool) -> bool:
-    """Fallback: Install pip dependencies using pip."""
-    cmd = [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)]
-    if use_mirror:
-        cmd.extend(["-i", TSINGHUA_MIRROR])
-
-    return run_command(cmd, "Installing pip dependencies with pip", retry=2)
-
-
-def check_uv_available() -> bool:
-    """Check if uv is available (installed via conda-forge::uv)."""
-    try:
-        subprocess.run(["uv", "--version"], capture_output=True, check=True)
-        return True
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return False
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Development installation script for UniLabOS")
-    parser.add_argument("--china", action="store_true", help="Force use China mirror (Tsinghua)")
-    parser.add_argument("--no-mirror", action="store_true", help="Force use default PyPI (no mirror)")
-    parser.add_argument(
-        "--skip-deps", action="store_true", help="Skip pip dependencies installation (only install unilabos)"
-    )
-    parser.add_argument("--use-pip", action="store_true", help="Use pip instead of uv for dependencies")
-    args = parser.parse_args()
-
-    # Determine project root
-    script_dir = Path(__file__).parent
-    project_root = script_dir.parent
-    requirements_file = project_root / "unilabos" / "utils" / "requirements.txt"
-
-    if not (project_root / "setup.py").exists():
-        print(f"[ERROR] setup.py not found in {project_root}")
-        sys.exit(1)
-
-    print("=" * 60)
-    print("UniLabOS Development Installation")
-    print("=" * 60)
-    print(f"Project root: {project_root}")
-    print()
-
-    # Determine mirror usage based on locale
-    if args.no_mirror:
-        use_mirror = False
-        print("[INFO] Mirror disabled by --no-mirror flag")
-    elif args.china:
-        use_mirror = True
-        print("[INFO] China mirror enabled by --china flag")
-    else:
-        use_mirror = is_chinese_locale()
-        if use_mirror:
-            print("[INFO] Chinese locale detected, using Tsinghua mirror")
-        else:
-            print("[INFO] Non-Chinese locale detected, using default PyPI")
-
-    print()
-
-    # Step 1: Install unilabos in editable mode
-    print("[STEP 1] Installing unilabos in editable mode...")
-    if not install_editable(project_root, use_mirror):
-        print("[ERROR] Failed to install unilabos")
-        print()
-        print("Manual fallback:")
-        if use_mirror:
-            print(f"  pip install -e {project_root} -i {TSINGHUA_MIRROR}")
-        else:
-            print(f"  pip install -e {project_root}")
-        sys.exit(1)
-
-    print()
-
-    # Step 2: Install pip dependencies
-    if args.skip_deps:
-        print("[INFO] Skipping pip dependencies installation (--skip-deps)")
-    else:
-        print("[STEP 2] Installing pip dependencies...")
-
-        if not requirements_file.exists():
-            print(f"[WARN] Requirements file not found: {requirements_file}")
-            print("[INFO] Skipping dependencies installation")
-        else:
-            # Try uv first (faster), fallback to pip
-            if args.use_pip:
-                print("[INFO] Using pip (--use-pip flag)")
-                success = install_requirements_pip(requirements_file, use_mirror)
-            elif check_uv_available():
-                print("[INFO] Using uv (installed via conda-forge::uv)")
-                success = install_requirements_uv(requirements_file, use_mirror)
-                if not success:
-                    print("[WARN] uv failed, falling back to pip...")
-                    success = install_requirements_pip(requirements_file, use_mirror)
-            else:
-                print("[WARN] uv not available (should be installed via: mamba install conda-forge::uv)")
-                print("[INFO] Falling back to pip...")
-                success = install_requirements_pip(requirements_file, use_mirror)
-
-            if not success:
-                print()
-                print("[WARN] Failed to install some dependencies automatically.")
-                print("You can manually install them:")
-                if use_mirror:
-                    print(f"  uv pip install -r {requirements_file} -i {TSINGHUA_MIRROR}")
-                    print("  or:")
-                    print(f"  pip install -r {requirements_file} -i {TSINGHUA_MIRROR}")
-                else:
-                    print(f"  uv pip install -r {requirements_file}")
-                    print("  or:")
-                    print(f"  pip install -r {requirements_file}")
-
-    print()
-    print("=" * 60)
-    print("Installation complete!")
-    print("=" * 60)
-    print()
-    print("Note: Some special packages (like pylabrobot) are installed")
-    print("automatically at runtime by unilabos if needed.")
-    print()
-    print("Verify installation:")
-    print('  python -c "import unilabos; print(unilabos.__version__)"')
-    print()
-    print("If you encounter issues, you can manually install dependencies:")
-    if use_mirror:
-        print(f"  uv pip install -r unilabos/utils/requirements.txt -i {TSINGHUA_MIRROR}")
-    else:
-        print("  uv pip install -r unilabos/utils/requirements.txt")
-    print()
-
-
-if __name__ == "__main__":
-    main()
--- a/setup.py
+++ b/setup.py
@@ -4,7 +4,7 @@ package_name = 'unilabos'

 setup(
    name=package_name,
-    version='0.10.18',
+    version='0.10.15',
    packages=find_packages(),
    include_package_data=True,
    install_requires=['setuptools'],
--- a/tests/workflow/test.json
+++ b/tests/workflow/test.json
@@ -1,213 +0,0 @@
-{
-  "workflow": [
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines",
-        "targets": "Liquid_1",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines",
-        "targets": "Liquid_2",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines",
-        "targets": "Liquid_3",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_2",
-        "targets": "Liquid_4",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_2",
-        "targets": "Liquid_5",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_2",
-        "targets": "Liquid_6",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_3",
-        "targets": "dest_set",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_3",
-        "targets": "dest_set_2",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_3",
-        "targets": "dest_set_3",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    }
-  ],
-  "reagent": {
-    "Liquid_1": {
-      "slot": 1,
-      "well": [
-        "A4",
-        "A7",
-        "A10"
-      ],
-      "labware": "rep 1"
-    },
-    "Liquid_4": {
-      "slot": 1,
-      "well": [
-        "A4",
-        "A7",
-        "A10"
-      ],
-      "labware": "rep 1"
-    },
-    "dest_set": {
-      "slot": 1,
-      "well": [
-        "A4",
-        "A7",
-        "A10"
-      ],
-      "labware": "rep 1"
-    },
-    "Liquid_2": {
-      "slot": 2,
-      "well": [
-        "A3",
-        "A5",
-        "A8"
-      ],
-      "labware": "rep 2"
-    },
-    "Liquid_5": {
-      "slot": 2,
-      "well": [
-        "A3",
-        "A5",
-        "A8"
-      ],
-      "labware": "rep 2"
-    },
-    "dest_set_2": {
-      "slot": 2,
-      "well": [
-        "A3",
-        "A5",
-        "A8"
-      ],
-      "labware": "rep 2"
-    },
-    "Liquid_3": {
-      "slot": 3,
-      "well": [
-        "A4",
-        "A6",
-        "A10"
-      ],
-      "labware": "rep 3"
-    },
-    "Liquid_6": {
-      "slot": 3,
-      "well": [
-        "A4",
-        "A6",
-        "A10"
-      ],
-      "labware": "rep 3"
-    },
-    "dest_set_3": {
-      "slot": 3,
-      "well": [
-        "A4",
-        "A6",
-        "A10"
-      ],
-      "labware": "rep 3"
-    },
-    "cell_lines": {
-      "slot": 4,
-      "well": [
-        "A1",
-        "A3",
-        "A5"
-      ],
-      "labware": "DRUG + YOYO-MEDIA"
-    },
-    "cell_lines_2": {
-      "slot": 4,
-      "well": [
-        "A1",
-        "A3",
-        "A5"
-      ],
-      "labware": "DRUG + YOYO-MEDIA"
-    },
-    "cell_lines_3": {
-      "slot": 4,
-      "well": [
-        "A1",
-        "A3",
-        "A5"
-      ],
-      "labware": "DRUG + YOYO-MEDIA"
-    }
-  }
-}
--- a/unilabos/init.py
+++ b/unilabos/init.py
@@ -1 +1 @@
-__version__ = "0.10.18"
+__version__ = "0.10.15"
--- a/unilabos/main.py
+++ b/unilabos/main.py
@@ -1,6 +0,0 @@
-"""Entry point for `python -m unilabos`."""
-
-from unilabos.app.main import main
-
-if __name__ == "__main__":
-    main()
--- a/unilabos/app/main.py
+++ b/unilabos/app/main.py
@@ -1,13 +1,13 @@
 import argparse
 import asyncio
 import os
-import platform
 import shutil
 import signal
 import sys
 import threading
 import time
 from typing import Dict, Any, List
+
 import networkx as nx
 import yaml

@@ -17,9 +17,9 @@ unilabos_dir = os.path.dirname(os.path.dirname(current_dir))
 if unilabos_dir not in sys.path:
    sys.path.append(unilabos_dir)

-from unilabos.app.utils import cleanup_for_restart
 from unilabos.utils.banner_print import print_status, print_unilab_banner
 from unilabos.config.config import load_config, BasicConfig, HTTPConfig
+from unilabos.app.utils import cleanup_for_restart

 # Global restart flags (used by ws_client and web/server)
 _restart_requested: bool = False
@@ -161,23 +161,11 @@ def parse_args():
        default=False,
        help="Complete registry information",
    )
-    parser.add_argument(
-        "--check_mode",
-        action="store_true",
-        default=False,
-        help="Run in check mode for CI: validates registry imports and ensures no file changes",
-    )
    parser.add_argument(
        "--no_update_feedback",
        action="store_true",
        help="Disable sending update feedback to server",
    )
-    parser.add_argument(
-        "--test_mode",
-        action="store_true",
-        default=False,
-        help="Test mode: all actions simulate execution and return mock results without running real hardware",
-    )
    # workflow upload subcommand
    workflow_parser = subparsers.add_parser(
        "workflow_upload",
@@ -211,12 +199,6 @@ def parse_args():
        default=False,
        help="Whether to publish the workflow (default: False)",
    )
-    workflow_parser.add_argument(
-        "--description",
-        type=str,
-        default="",
-        help="Workflow description, used when publishing the workflow",
-    )
    return parser


@@ -229,10 +211,7 @@ def main():
    args_dict = vars(args)

    # 环境检查 - 检查并自动安装必需的包 (可选)
-    skip_env_check = args_dict.get("skip_env_check", False)
-    check_mode = args_dict.get("check_mode", False)
-
-    if not skip_env_check:
+    if not args_dict.get("skip_env_check", False):
        from unilabos.utils.environment_check import check_environment

        if not check_environment(auto_install=True):
@@ -243,75 +222,49 @@ def main():

    # 加载配置文件，优先加载config，然后从env读取
    config_path = args_dict.get("config")
-
-    # === 解析 working_dir ===
-    # 规则1: working_dir 传入 → 检测 unilabos_data 子目录，已是则不修改
-    # 规则2: 仅 config_path 传入 → 用其父目录作为 working_dir
-    # 规则4: 两者都传入 → 各用各的，但 working_dir 仍做 unilabos_data 子目录检测
-    raw_working_dir = args_dict.get("working_dir")
-    if raw_working_dir:
-        working_dir = os.path.abspath(raw_working_dir)
-    elif config_path and os.path.exists(config_path):
-        working_dir = os.path.dirname(os.path.abspath(config_path))
-    else:
+    if os.getcwd().endswith("unilabos_data"):
        working_dir = os.path.abspath(os.getcwd())
+    else:
+        working_dir = os.path.abspath(os.path.join(os.getcwd(), "unilabos_data"))

-    # unilabos_data 子目录自动检测
-    if os.path.basename(working_dir) != "unilabos_data":
-        unilabos_data_sub = os.path.join(working_dir, "unilabos_data")
-        if os.path.isdir(unilabos_data_sub):
-            working_dir = unilabos_data_sub
-        elif not raw_working_dir and not (config_path and os.path.exists(config_path)):
-            # 未显式指定路径，默认使用 cwd/unilabos_data
-            working_dir = os.path.abspath(os.path.join(os.getcwd(), "unilabos_data"))
-
-    # === 解析 config_path ===
-    if config_path and not os.path.exists(config_path):
-        # config_path 传入但不存在，尝试在 working_dir 中查找
-        candidate = os.path.join(working_dir, "local_config.py")
-        if os.path.exists(candidate):
-            config_path = candidate
-            print_status(f"在工作目录中发现配置文件: {config_path}", "info")
-        else:
-            print_status(
-                f"配置文件 {config_path} 不存在，工作目录 {working_dir} 中也未找到 local_config.py，"
-                f"请通过 --config 传入 local_config.py 文件路径",
-                "error",
-            )
-            os._exit(1)
-    elif not config_path:
-        # 规则3: 未传入 config_path，尝试 working_dir/local_config.py
-        candidate = os.path.join(working_dir, "local_config.py")
-        if os.path.exists(candidate):
-            config_path = candidate
-            print_status(f"发现本地配置文件: {config_path}", "info")
-        else:
-            print_status(f"未指定config路径，可通过 --config 传入 local_config.py 文件路径", "info")
-            print_status(f"您是否为第一次使用？并将当前路径 {working_dir} 作为工作目录？ (Y/n)", "info")
-            if check_mode or input() != "n":
-                os.makedirs(working_dir, exist_ok=True)
-                config_path = os.path.join(working_dir, "local_config.py")
-                shutil.copy(
-                    os.path.join(os.path.dirname(os.path.dirname(__file__)), "config", "example_config.py"),
-                    config_path,
+    if args_dict.get("working_dir"):
+        working_dir = args_dict.get("working_dir", "")
+        if config_path and not os.path.exists(config_path):
+            config_path = os.path.join(working_dir, "local_config.py")
+            if not os.path.exists(config_path):
+                print_status(
+                    f"当前工作目录 {working_dir} 未找到local_config.py，请通过 --config 传入 local_config.py 文件路径",
+                    "error",
                )
-                print_status(f"已创建 local_config.py 路径： {config_path}", "info")
-            else:
                os._exit(1)
-
-    # 加载配置文件 (check_mode 跳过)
+    elif config_path and os.path.exists(config_path):
+        working_dir = os.path.dirname(config_path)
+    elif os.path.exists(working_dir) and os.path.exists(os.path.join(working_dir, "local_config.py")):
+        config_path = os.path.join(working_dir, "local_config.py")
+    elif not config_path and (
+        not os.path.exists(working_dir) or not os.path.exists(os.path.join(working_dir, "local_config.py"))
+    ):
+        print_status(f"未指定config路径，可通过 --config 传入 local_config.py 文件路径", "info")
+        print_status(f"您是否为第一次使用？并将当前路径 {working_dir} 作为工作目录？ (Y/n)", "info")
+        if input() != "n":
+            os.makedirs(working_dir, exist_ok=True)
+            config_path = os.path.join(working_dir, "local_config.py")
+            shutil.copy(
+                os.path.join(os.path.dirname(os.path.dirname(__file__)), "config", "example_config.py"), config_path
+            )
+            print_status(f"已创建 local_config.py 路径： {config_path}", "info")
+        else:
+            os._exit(1)
+    # 加载配置文件
    print_status(f"当前工作目录为 {working_dir}", "info")
-    if not check_mode:
-        load_config_from_file(config_path)
+    load_config_from_file(config_path)

    # 根据配置重新设置日志级别
    from unilabos.utils.log import configure_logger, logger

    if hasattr(BasicConfig, "log_level"):
        logger.info(f"Log level set to '{BasicConfig.log_level}' from config file.")
-    file_path = configure_logger(loglevel=BasicConfig.log_level, working_dir=working_dir)
-    if file_path is not None:
-        logger.info(f"[LOG_FILE] {file_path}")
+    configure_logger(loglevel=BasicConfig.log_level, working_dir=working_dir)

    if args.addr != parser.get_default("addr"):
        if args.addr == "test":
@@ -355,15 +308,11 @@ def main():
    BasicConfig.slave_no_host = args_dict.get("slave_no_host", False)
    BasicConfig.upload_registry = args_dict.get("upload_registry", False)
    BasicConfig.no_update_feedback = args_dict.get("no_update_feedback", False)
-    BasicConfig.test_mode = args_dict.get("test_mode", False)
-    if BasicConfig.test_mode:
-        print_status("启用测试模式：所有动作将模拟执行，不调用真实硬件", "warning")
    BasicConfig.communication_protocol = "websocket"
-    machine_name = platform.node()
+    machine_name = os.popen("hostname").read().strip()
    machine_name = "".join([c if c.isalnum() or c == "_" else "_" for c in machine_name])
    BasicConfig.machine_name = machine_name
    BasicConfig.vis_2d_enable = args_dict["2d_vis"]
-    BasicConfig.check_mode = check_mode

    from unilabos.resources.graphio import (
        read_node_link_json,
@@ -382,14 +331,10 @@ def main():
    # 显示启动横幅
    print_unilab_banner(args_dict)

-    # 注册表 - check_mode 时强制启用 complete_registry
-    complete_registry = args_dict.get("complete_registry", False) or check_mode
-    lab_registry = build_registry(args_dict["registry_path"], complete_registry, BasicConfig.upload_registry)
-
-    # Check mode: complete_registry 完成后直接退出，git diff 检测由 CI workflow 执行
-    if check_mode:
-        print_status("Check mode: complete_registry 完成，退出", "info")
-        os._exit(0)
+    # 注册表
+    lab_registry = build_registry(
+        args_dict["registry_path"], args_dict.get("complete_registry", False), BasicConfig.upload_registry
+    )

    if BasicConfig.upload_registry:
        # 设备注册到服务端 - 需要 ak 和 sk
--- a/unilabos/app/model.py
+++ b/unilabos/app/model.py
@@ -54,7 +54,6 @@ class JobAddReq(BaseModel):
    action_type: str = Field(
        examples=["unilabos_msgs.action._str_single_input.StrSingleInput"], description="action type", default=""
    )
-    sample_material: dict = Field(examples=[{"string": "string"}], description="sample uuid to material uuid")
    action_args: dict = Field(examples=[{"string": "string"}], description="action arguments", default_factory=dict)
    task_id: str = Field(examples=["task_id"], description="task uuid (auto-generated if empty)", default="")
    job_id: str = Field(examples=["job_id"], description="goal uuid (auto-generated if empty)", default="")
--- a/unilabos/app/register.py
+++ b/unilabos/app/register.py
@@ -38,9 +38,9 @@ def register_devices_and_resources(lab_registry, gather_only=False) -> Optional[
            response = http_client.resource_registry({"resources": list(devices_to_register.values())})
            cost_time = time.time() - start_time
            if response.status_code in [200, 201]:
-                logger.info(f"[UniLab Register] 成功注册 {len(devices_to_register)} 个设备 {cost_time}s")
+                logger.info(f"[UniLab Register] 成功注册 {len(devices_to_register)} 个设备 {cost_time}ms")
            else:
-                logger.error(f"[UniLab Register] 设备注册失败: {response.status_code}, {response.text} {cost_time}s")
+                logger.error(f"[UniLab Register] 设备注册失败: {response.status_code}, {response.text} {cost_time}ms")
        except Exception as e:
            logger.error(f"[UniLab Register] 设备注册异常: {e}")

@@ -51,9 +51,9 @@ def register_devices_and_resources(lab_registry, gather_only=False) -> Optional[
            response = http_client.resource_registry({"resources": list(resources_to_register.values())})
            cost_time = time.time() - start_time
            if response.status_code in [200, 201]:
-                logger.info(f"[UniLab Register] 成功注册 {len(resources_to_register)} 个资源 {cost_time}s")
+                logger.info(f"[UniLab Register] 成功注册 {len(resources_to_register)} 个资源 {cost_time}ms")
            else:
-                logger.error(f"[UniLab Register] 资源注册失败: {response.status_code}, {response.text} {cost_time}s")
+                logger.error(f"[UniLab Register] 资源注册失败: {response.status_code}, {response.text} {cost_time}ms")
        except Exception as e:
            logger.error(f"[UniLab Register] 资源注册异常: {e}")

--- a/unilabos/app/utils.py
+++ b/unilabos/app/utils.py
@@ -4,40 +4,8 @@ UniLabOS 应用工具函数
 提供清理、重启等工具函数
 """

-import glob
-import os
-import shutil
-import sys
-
-
-def patch_rclpy_dll_windows():
-    """在 Windows + conda 环境下为 rclpy 打 DLL 加载补丁"""
-    if sys.platform != "win32" or not os.environ.get("CONDA_PREFIX"):
-        return
-    try:
-        import rclpy
-
-        return
-    except ImportError as e:
-        if not str(e).startswith("DLL load failed"):
-            return
-    cp = os.environ["CONDA_PREFIX"]
-    impl = os.path.join(cp, "Lib", "site-packages", "rclpy", "impl", "implementation_singleton.py")
-    pyd = glob.glob(os.path.join(cp, "Lib", "site-packages", "rclpy", "_rclpy_pybind11*.pyd"))
-    if not os.path.exists(impl) or not pyd:
-        return
-    with open(impl, "r", encoding="utf-8") as f:
-        content = f.read()
-    lib_bin = os.path.join(cp, "Library", "bin").replace("\\", "/")
-    patch = f'# UniLabOS DLL Patch\nimport os,ctypes\nos.add_dll_directory("{lib_bin}") if hasattr(os,"add_dll_directory") else None\ntry: ctypes.CDLL("{pyd[0].replace(chr(92),"/")}")\nexcept: pass\n# End Patch\n'
-    shutil.copy2(impl, impl + ".bak")
-    with open(impl, "w", encoding="utf-8") as f:
-        f.write(patch + content)
-
-
-patch_rclpy_dll_windows()
-
 import gc
+import os
 import threading
 import time

--- a/unilabos/app/web/client.py
+++ b/unilabos/app/web/client.py
@@ -343,10 +343,9 @@ class HTTPClient:
        edges: List[Dict[str, Any]],
        tags: Optional[List[str]] = None,
        published: bool = False,
-        description: str = "",
    ) -> Dict[str, Any]:
        """
-        导入工作流到服务器，如果 published 为 True，则额外发起发布请求
+        导入工作流到服务器

        Args:
            name: 工作流名称（顶层）
@@ -356,12 +355,13 @@ class HTTPClient:
            edges: 工作流边列表
            tags: 工作流标签列表，默认为空列表
            published: 是否发布工作流，默认为False
-            description: 工作流描述，发布时使用

        Returns:
            Dict: API响应数据，包含 code 和 data (uuid, name)
        """
+        # target_lab_uuid 暂时使用默认值，后续由后端根据 ak/sk 获取
        payload = {
+            "target_lab_uuid": "28c38bb0-63f6-4352-b0d8-b5b8eb1766d5",
            "name": name,
            "data": {
                "workflow_uuid": workflow_uuid,
@@ -369,6 +369,7 @@ class HTTPClient:
                "nodes": nodes,
                "edges": edges,
                "tags": tags if tags is not None else [],
+                "published": published,
            },
        }
        # 保存请求到文件
@@ -389,51 +390,11 @@ class HTTPClient:
            res = response.json()
            if "code" in res and res["code"] != 0:
                logger.error(f"导入工作流失败: {response.text}")
-                return res
-            # 导入成功后，如果需要发布则额外发起发布请求
-            if published:
-                imported_uuid = res.get("data", {}).get("uuid", workflow_uuid)
-                publish_res = self.workflow_publish(imported_uuid, description)
-                res["publish_result"] = publish_res
            return res
        else:
            logger.error(f"导入工作流失败: {response.status_code}, {response.text}")
            return {"code": response.status_code, "message": response.text}

-    def workflow_publish(self, workflow_uuid: str, description: str = "") -> Dict[str, Any]:
-        """
-        发布工作流
-
-        Args:
-            workflow_uuid: 工作流UUID
-            description: 工作流描述
-
-        Returns:
-            Dict: API响应数据
-        """
-        payload = {
-            "uuid": workflow_uuid,
-            "description": description,
-            "published": True,
-        }
-        logger.info(f"正在发布工作流: {workflow_uuid}")
-        response = requests.patch(
-            f"{self.remote_addr}/lab/workflow/owner",
-            json=payload,
-            headers={"Authorization": f"Lab {self.auth}"},
-            timeout=60,
-        )
-        if response.status_code == 200:
-            res = response.json()
-            if "code" in res and res["code"] != 0:
-                logger.error(f"发布工作流失败: {response.text}")
-            else:
-                logger.info(f"工作流发布成功: {workflow_uuid}")
-            return res
-        else:
-            logger.error(f"发布工作流失败: {response.status_code}, {response.text}")
-            return {"code": response.status_code, "message": response.text}
-

 # 创建默认客户端实例
 http_client = HTTPClient()
--- a/unilabos/app/web/controller.py
+++ b/unilabos/app/web/controller.py
@@ -58,14 +58,14 @@ class JobResultStore:
                feedback=feedback or {},
                timestamp=time.time(),
            )
-            logger.trace(f"[JobResultStore] Stored result for job {job_id[:8]}, status={status}")
+            logger.debug(f"[JobResultStore] Stored result for job {job_id[:8]}, status={status}")

    def get_and_remove(self, job_id: str) -> Optional[JobResult]:
        """获取并删除任务结果"""
        with self._results_lock:
            result = self._results.pop(job_id, None)
            if result:
-                logger.trace(f"[JobResultStore] Retrieved and removed result for job {job_id[:8]}")
+                logger.debug(f"[JobResultStore] Retrieved and removed result for job {job_id[:8]}")
            return result

    def get_result(self, job_id: str) -> Optional[JobResult]:
@@ -327,7 +327,6 @@ def job_add(req: JobAddReq) -> JobData:
            queue_item,
            action_type=action_type,
            action_kwargs=action_args,
-            sample_material=req.sample_material,
            server_info=server_info,
        )

--- a/unilabos/app/ws_client.py
+++ b/unilabos/app/ws_client.py
@@ -23,7 +23,7 @@ from typing import Optional, Dict, Any, List
 from urllib.parse import urlparse
 from enum import Enum

-from typing_extensions import TypedDict
+from jedi.inference.gradual.typing import TypedDict

 from unilabos.app.model import JobAddReq
 from unilabos.ros.nodes.presets.host_node import HostNode
@@ -76,7 +76,6 @@ class JobInfo:
    start_time: float
    last_update_time: float = field(default_factory=time.time)
    ready_timeout: Optional[float] = None  # READY状态的超时时间
-    always_free: bool = False  # 是否为永久闲置动作(不受排队限制)

    def update_timestamp(self):
        """更新最后更新时间"""
@@ -128,15 +127,6 @@ class DeviceActionManager:
            # 总是将job添加到all_jobs中
            self.all_jobs[job_info.job_id] = job_info

-            # always_free的动作不受排队限制，直接设为READY
-            if job_info.always_free:
-                job_info.status = JobStatus.READY
-                job_info.update_timestamp()
-                job_info.set_ready_timeout(10)
-                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-                logger.trace(f"[DeviceActionManager] Job {job_log} always_free, start immediately")
-                return True
-
            # 检查是否有正在执行或准备执行的任务
            if device_key in self.active_jobs:
                # 有正在执行或准备执行的任务，加入队列
@@ -164,7 +154,7 @@ class DeviceActionManager:
            job_info.set_ready_timeout(10)  # 设置10秒超时
            self.active_jobs[device_key] = job_info
            job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-            logger.trace(f"[DeviceActionManager] Job {job_log} can start immediately for {device_key}")
+            logger.info(f"[DeviceActionManager] Job {job_log} can start immediately for {device_key}")
            return True

    def start_job(self, job_id: str) -> bool:
@@ -186,15 +176,11 @@ class DeviceActionManager:
                logger.error(f"[DeviceActionManager] Job {job_log} is not in READY status, current: {job_info.status}")
                return False

-            # always_free的job不需要检查active_jobs
-            if not job_info.always_free:
-                # 检查设备上是否是这个job
-                if device_key not in self.active_jobs or self.active_jobs[device_key].job_id != job_id:
-                    job_log = format_job_log(
-                        job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name
-                    )
-                    logger.error(f"[DeviceActionManager] Job {job_log} is not the active job for {device_key}")
-                    return False
+            # 检查设备上是否是这个job
+            if device_key not in self.active_jobs or self.active_jobs[device_key].job_id != job_id:
+                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
+                logger.error(f"[DeviceActionManager] Job {job_log} is not the active job for {device_key}")
+                return False

            # 开始执行任务，将状态从READY转换为STARTED
            job_info.status = JobStatus.STARTED
@@ -217,13 +203,6 @@ class DeviceActionManager:
            job_info = self.all_jobs[job_id]
            device_key = job_info.device_action_key

-            # always_free的job直接清理，不影响队列
-            if job_info.always_free:
-                job_info.status = JobStatus.ENDED
-                job_info.update_timestamp()
-                del self.all_jobs[job_id]
-                return None
-
            # 移除活跃任务
            if device_key in self.active_jobs and self.active_jobs[device_key].job_id == job_id:
                del self.active_jobs[device_key]
@@ -231,9 +210,8 @@ class DeviceActionManager:
                job_info.update_timestamp()
                # 从all_jobs中移除已结束的job
                del self.all_jobs[job_id]
-                # job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-                # logger.debug(f"[DeviceActionManager] Job {job_log} ended for {device_key}")
-                pass
+                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
+                logger.info(f"[DeviceActionManager] Job {job_log} ended for {device_key}")
            else:
                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
                logger.warning(f"[DeviceActionManager] Job {job_log} was not active for {device_key}")
@@ -249,20 +227,15 @@ class DeviceActionManager:
                next_job_log = format_job_log(
                    next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name
                )
-                logger.trace(f"[DeviceActionManager] Next job {next_job_log} can start for {device_key}")
+                logger.info(f"[DeviceActionManager] Next job {next_job_log} can start for {device_key}")
                return next_job

            return None

    def get_active_jobs(self) -> List[JobInfo]:
-        """获取所有正在执行的任务(含active_jobs和always_free的STARTED job)"""
+        """获取所有正在执行的任务"""
        with self.lock:
-            jobs = list(self.active_jobs.values())
-            # 补充 always_free 的 STARTED job(它们不在 active_jobs 中)
-            for job in self.all_jobs.values():
-                if job.always_free and job.status == JobStatus.STARTED and job not in jobs:
-                    jobs.append(job)
-            return jobs
+            return list(self.active_jobs.values())

    def get_queued_jobs(self) -> List[JobInfo]:
        """获取所有排队中的任务"""
@@ -287,14 +260,6 @@ class DeviceActionManager:
            job_info = self.all_jobs[job_id]
            device_key = job_info.device_action_key

-            # always_free的job直接清理
-            if job_info.always_free:
-                job_info.status = JobStatus.ENDED
-                del self.all_jobs[job_id]
-                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-                logger.trace(f"[DeviceActionManager] Always-free job {job_log} cancelled")
-                return True
-
            # 如果是正在执行的任务
            if device_key in self.active_jobs and self.active_jobs[device_key].job_id == job_id:
                # 清理active job状态
@@ -303,7 +268,7 @@ class DeviceActionManager:
                # 从all_jobs中移除
                del self.all_jobs[job_id]
                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-                logger.trace(f"[DeviceActionManager] Active job {job_log} cancelled for {device_key}")
+                logger.info(f"[DeviceActionManager] Active job {job_log} cancelled for {device_key}")

                # 启动下一个任务
                if device_key in self.device_queues and self.device_queues[device_key]:
@@ -316,7 +281,7 @@ class DeviceActionManager:
                    next_job_log = format_job_log(
                        next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name
                    )
-                    logger.trace(f"[DeviceActionManager] Next job {next_job_log} can start after cancel")
+                    logger.info(f"[DeviceActionManager] Next job {next_job_log} can start after cancel")
                return True

            # 如果是排队中的任务
@@ -330,7 +295,7 @@ class DeviceActionManager:
                    job_log = format_job_log(
                        job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name
                    )
-                    logger.trace(f"[DeviceActionManager] Queued job {job_log} cancelled for {device_key}")
+                    logger.info(f"[DeviceActionManager] Queued job {job_log} cancelled for {device_key}")
                    return True

            job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
@@ -368,18 +333,13 @@ class DeviceActionManager:
        timeout_jobs = []

        with self.lock:
-            # 收集所有需要检查的 READY 任务(active_jobs + always_free READY jobs)
-            ready_candidates = list(self.active_jobs.values())
-            for job in self.all_jobs.values():
-                if job.always_free and job.status == JobStatus.READY and job not in ready_candidates:
-                    ready_candidates.append(job)
-
-            ready_jobs_count = sum(1 for job in ready_candidates if job.status == JobStatus.READY)
+            # 统计READY状态的任务数量
+            ready_jobs_count = sum(1 for job in self.active_jobs.values() if job.status == JobStatus.READY)
            if ready_jobs_count > 0:
                logger.trace(f"[DeviceActionManager] Checking {ready_jobs_count} READY jobs for timeout")  # type: ignore  # noqa: E501

            # 找到所有超时的READY任务（只检测，不处理）
-            for job_info in ready_candidates:
+            for job_info in self.active_jobs.values():
                if job_info.is_ready_timeout():
                    timeout_jobs.append(job_info)
                    job_log = format_job_log(
@@ -534,12 +494,8 @@ class MessageProcessor:
                        await self._process_message(message_type, message_data)
                    else:
                        if message_type.endswith("_material"):
-                            logger.trace(
-                                f"[MessageProcessor] 收到一条归属 {data.get('edge_session')} 的旧消息：{data}"
-                            )
-                            logger.debug(
-                                f"[MessageProcessor] 跳过了一条归属 {data.get('edge_session')} 的旧消息: {data.get('action')}"
-                            )
+                            logger.trace(f"[MessageProcessor] 收到一条归属 {data.get('edge_session')} 的旧消息：{data}")
+                            logger.debug(f"[MessageProcessor] 跳过了一条归属 {data.get('edge_session')} 的旧消息: {data.get('action')}")
                        else:
                            await self._process_message(message_type, message_data)
                except json.JSONDecodeError:
@@ -584,7 +540,7 @@ class MessageProcessor:
                        try:
                            message_str = json.dumps(msg, ensure_ascii=False)
                            await self.websocket.send(message_str)
-                            # logger.trace(f"[MessageProcessor] Message sent: {msg.get('action', 'unknown')}")  # type: ignore  # noqa: E501
+                            logger.trace(f"[MessageProcessor] Message sent: {msg.get('action', 'unknown')}")  # type: ignore  # noqa: E501
                        except Exception as e:
                            logger.error(f"[MessageProcessor] Failed to send message: {str(e)}")
                            logger.error(traceback.format_exc())
@@ -609,7 +565,7 @@ class MessageProcessor:

    async def _process_message(self, message_type: str, message_data: Dict[str, Any]):
        """处理收到的消息"""
-        logger.trace(f"[MessageProcessor] Processing message: {message_type}")
+        logger.debug(f"[MessageProcessor] Processing message: {message_type}")

        try:
            if message_type == "pong":
@@ -647,24 +603,6 @@ class MessageProcessor:
        if host_node:
            host_node.handle_pong_response(pong_data)

-    def _check_action_always_free(self, device_id: str, action_name: str) -> bool:
-        """检查该action是否标记为always_free，通过HostNode统一的_action_value_mappings查找"""
-        try:
-            host_node = HostNode.get_instance(0)
-            if not host_node:
-                return False
-            # noinspection PyProtectedMember
-            action_mappings = host_node._action_value_mappings.get(device_id)
-            if not action_mappings:
-                return False
-            # 尝试直接匹配或 auto- 前缀匹配
-            for key in [action_name, f"auto-{action_name}"]:
-                if key in action_mappings:
-                    return action_mappings[key].get("always_free", False)
-            return False
-        except Exception:
-            return False
-
    async def _handle_query_action_state(self, data: Dict[str, Any]):
        """处理query_action_state消息"""
        device_id = data.get("device_id", "")
@@ -679,9 +617,6 @@ class MessageProcessor:

        device_action_key = f"/devices/{device_id}/{action_name}"

-        # 检查action是否为always_free
-        action_always_free = self._check_action_always_free(device_id, action_name)
-
        # 创建任务信息
        job_info = JobInfo(
            job_id=job_id,
@@ -691,7 +626,6 @@ class MessageProcessor:
            device_action_key=device_action_key,
            status=JobStatus.QUEUE,
            start_time=time.time(),
-            always_free=action_always_free,
        )

        # 添加到设备管理器
@@ -703,13 +637,13 @@ class MessageProcessor:
            await self._send_action_state_response(
                device_id, action_name, task_id, job_id, "query_action_status", True, 0
            )
-            logger.trace(f"[MessageProcessor] Job {job_log} can start immediately")
+            logger.info(f"[MessageProcessor] Job {job_log} can start immediately")
        else:
            # 需要排队
            await self._send_action_state_response(
                device_id, action_name, task_id, job_id, "query_action_status", False, 10
            )
-            logger.trace(f"[MessageProcessor] Job {job_log} queued")
+            logger.info(f"[MessageProcessor] Job {job_log} queued")

            # 通知QueueProcessor有新的队列更新
            if self.queue_processor:
@@ -718,8 +652,6 @@ class MessageProcessor:
    async def _handle_job_start(self, data: Dict[str, Any]):
        """处理job_start消息"""
        try:
-            if not data.get("sample_material"):
-                data["sample_material"] = {}
            req = JobAddReq(**data)

            job_log = format_job_log(req.job_id, req.task_id, req.device_id, req.action)
@@ -751,7 +683,6 @@ class MessageProcessor:
                queue_item,
                action_type=req.action_type,
                action_kwargs=req.action_args,
-                sample_material=req.sample_material,
                server_info=req.server_info,
            )

@@ -916,7 +847,9 @@ class MessageProcessor:
                        device_action_groups[key_add] = []
                    device_action_groups[key_add].append(item["uuid"])

-                    logger.info(f"[资源同步] 跨站Transfer: {item['uuid'][:8]} from {device_old_id} to {device_id}")
+                    logger.info(
+                        f"[MessageProcessor] Resource migrated: {item['uuid'][:8]} from {device_old_id} to {device_id}"
+                    )
                else:
                    # 正常update
                    key = (device_id, "update")
@@ -930,13 +863,11 @@ class MessageProcessor:
                    device_action_groups[key] = []
                device_action_groups[key].append(item["uuid"])

-        logger.trace(
-            f"[资源同步] 动作 {action} 分组数量: {len(device_action_groups)}, 总数量: {len(resource_uuid_list)}"
-        )
+        logger.info(f"触发物料更新 {action} 分组数量: {len(device_action_groups)}, 总数量: {len(resource_uuid_list)}")

        # 为每个(device_id, action)创建独立的更新线程
        for (device_id, actual_action), items in device_action_groups.items():
-            logger.trace(f"[资源同步] {device_id} 物料动作 {actual_action} 数量: {len(items)}")
+            logger.info(f"设备 {device_id} 物料更新 {actual_action} 数量: {len(items)}")

            def _notify_resource_tree(dev_id, act, item_list):
                try:
@@ -971,44 +902,42 @@ class MessageProcessor:
    async def _handle_request_restart(self, data: Dict[str, Any]):
        """
        处理重启请求
-
+        
        当LabGo发送request_restart时，执行清理并触发重启
        """
        reason = data.get("reason", "unknown")
        delay = data.get("delay", 2)  # 默认延迟2秒
        logger.info(f"[MessageProcessor] Received restart request, reason: {reason}, delay: {delay}s")
-
+        
        # 发送确认消息
        if self.websocket_client:
-            await self.websocket_client.send_message(
-                {"action": "restart_acknowledged", "data": {"reason": reason, "delay": delay}}
-            )
-
+            await self.websocket_client.send_message({
+                "action": "restart_acknowledged",
+                "data": {"reason": reason, "delay": delay}
+            })
+        
        # 设置全局重启标志
        import unilabos.app.main as main_module
-
        main_module._restart_requested = True
        main_module._restart_reason = reason
-
+        
        # 延迟后执行清理
        await asyncio.sleep(delay)
-
+        
        # 在新线程中执行清理，避免阻塞当前事件循环
        def do_cleanup():
            import time
-
            time.sleep(0.5)  # 给当前消息处理完成的时间
            logger.info(f"[MessageProcessor] Starting cleanup for restart, reason: {reason}")
            try:
                from unilabos.app.utils import cleanup_for_restart
-
                if cleanup_for_restart():
                    logger.info("[MessageProcessor] Cleanup successful, main() will restart")
                else:
                    logger.error("[MessageProcessor] Cleanup failed")
            except Exception as e:
                logger.error(f"[MessageProcessor] Error during cleanup: {e}")
-
+        
        cleanup_thread = threading.Thread(target=do_cleanup, name="RestartCleanupThread", daemon=True)
        cleanup_thread.start()
        logger.info(f"[MessageProcessor] Restart cleanup scheduled")
@@ -1184,11 +1113,6 @@ class QueueProcessor:
        logger.debug(f"[QueueProcessor] Sending busy status for {len(queued_jobs)} queued jobs")

        for job_info in queued_jobs:
-            # 快照可能已过期：在遍历过程中 end_job() 可能已将此 job 移至 READY，
-            # 此时不应再发送 busy/need_more，否则会覆盖已发出的 free=True 通知
-            if job_info.status != JobStatus.QUEUE:
-                continue
-
            message = {
                "action": "report_action_state",
                "data": {
@@ -1204,7 +1128,7 @@ class QueueProcessor:
            success = self.message_processor.send_message(message)
            job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
            if success:
-                logger.trace(f"[QueueProcessor] Sent busy/need_more for queued job {job_log}")
+                logger.debug(f"[QueueProcessor] Sent busy/need_more for queued job {job_log}")
            else:
                logger.warning(f"[QueueProcessor] Failed to send busy status for job {job_log}")

@@ -1227,7 +1151,7 @@ class QueueProcessor:
            job_info.action_name,
        )

-        logger.trace(f"[QueueProcessor] Job {job_log} completed with status: {status}")
+        logger.info(f"[QueueProcessor] Job {job_log} completed with status: {status}")

        # 结束任务，获取下一个可执行的任务
        next_job = self.device_manager.end_job(job_id)
@@ -1247,8 +1171,8 @@ class QueueProcessor:
                },
            }
            self.message_processor.send_message(message)
-            # next_job_log = format_job_log(next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name)
-            # logger.debug(f"[QueueProcessor] Notified next job {next_job_log} can start")
+            next_job_log = format_job_log(next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name)
+            logger.info(f"[QueueProcessor] Notified next job {next_job_log} can start")

            # 立即触发下一轮状态检查
            self.notify_queue_update()
@@ -1370,7 +1294,7 @@ class WebSocketClient(BaseCommunicationClient):
            },
        }
        self.message_processor.send_message(message)
-        # logger.trace(f"[WebSocketClient] Device status published: {device_id}.{property_name}")
+        logger.trace(f"[WebSocketClient] Device status published: {device_id}.{property_name}")

    def publish_job_status(
        self, feedback_data: dict, item: QueueItem, status: str, return_info: Optional[dict] = None
@@ -1390,7 +1314,7 @@ class WebSocketClient(BaseCommunicationClient):
                except (KeyError, AttributeError):
                    logger.warning(f"[WebSocketClient] Failed to remove job {item.job_id} from HostNode status")

-            # logger.debug(f"[WebSocketClient] Intercepting final status for job_id: {item.job_id} - {status}")
+            logger.info(f"[WebSocketClient] Intercepting final status for job_id: {item.job_id} - {status}")

            # 通知队列处理器job完成（包括timeout的job）
            self.queue_processor.handle_job_completed(item.job_id, status)
@@ -1451,17 +1375,15 @@ class WebSocketClient(BaseCommunicationClient):
        # 收集设备信息
        devices = []
        machine_name = BasicConfig.machine_name
-
+        
        try:
            host_node = HostNode.get_instance(0)
            if host_node:
                # 获取设备信息
                for device_id, namespace in host_node.devices_names.items():
-                    device_key = (
-                        f"{namespace}/{device_id}" if namespace.startswith("/") else f"/{namespace}/{device_id}"
-                    )
+                    device_key = f"{namespace}/{device_id}" if namespace.startswith("/") else f"/{namespace}/{device_id}"
                    is_online = device_key in host_node._online_devices
-
+                    
                    # 获取设备的动作信息
                    actions = {}
                    for action_id, client in host_node._action_clients.items():
@@ -1472,18 +1394,16 @@ class WebSocketClient(BaseCommunicationClient):
                                "action_path": action_id,
                                "action_type": str(type(client).__name__),
                            }
-
-                    devices.append(
-                        {
-                            "device_id": device_id,
-                            "namespace": namespace,
-                            "device_key": device_key,
-                            "is_online": is_online,
-                            "machine_name": host_node.device_machine_names.get(device_id, machine_name),
-                            "actions": actions,
-                        }
-                    )
-
+                    
+                    devices.append({
+                        "device_id": device_id,
+                        "namespace": namespace,
+                        "device_key": device_key,
+                        "is_online": is_online,
+                        "machine_name": host_node.device_machine_names.get(device_id, machine_name),
+                        "actions": actions,
+                    })
+                
                logger.info(f"[WebSocketClient] Collected {len(devices)} devices for host_ready")
        except Exception as e:
            logger.warning(f"[WebSocketClient] Error collecting device info: {e}")
--- a/unilabos/compile/pump_protocol.py
+++ b/unilabos/compile/pump_protocol.py
@@ -95,29 +95,8 @@ def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
    return total_volume


-def is_integrated_pump(node_class: str, node_name: str = "") -> bool:
-    """
-    判断是否为泵阀一体设备
-    """
-    class_lower = (node_class or "").lower()
-    name_lower = (node_name or "").lower()
-
-    if "pump" not in class_lower and "pump" not in name_lower:
-        return False
-
-    integrated_markers = [
-        "valve",
-        "pump_valve",
-        "pumpvalve",
-        "integrated",
-        "transfer_pump",
-    ]
-
-    for marker in integrated_markers:
-        if marker in class_lower or marker in name_lower:
-            return True
-
-    return False
+def is_integrated_pump(node_name):
+    return "pump" in node_name and "valve" in node_name


 def find_connected_pump(G, valve_node):
@@ -207,9 +186,7 @@ def build_pump_valve_maps(G, pump_backbone):
    debug_print(f"🔧 过滤后的骨架: {filtered_backbone}")

    for node in filtered_backbone:
-        node_data = G.nodes.get(node, {})
-        node_class = node_data.get("class", "") or ""
-        if is_integrated_pump(node_class, node):
+        if is_integrated_pump(G.nodes[node]["class"]):
            pumps_from_node[node] = node
            valve_from_node[node] = node
            debug_print(f"  - 集成泵-阀: {node}")
--- a/unilabos/config/config.py
+++ b/unilabos/config/config.py
@@ -22,8 +22,6 @@ class BasicConfig:
    startup_json_path = None  # 填写绝对路径
    disable_browser = False  # 禁止浏览器自动打开
    port = 8002  # 本地HTTP服务
-    check_mode = False  # CI 检查模式，用于验证 registry 导入和文件一致性
-    test_mode = False  # 测试模式，所有动作不实际执行，返回模拟结果
    # 'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
    log_level: Literal["TRACE", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "DEBUG"

@@ -146,5 +144,5 @@ def load_config(config_path=None):
            traceback.print_exc()
            exit(1)
    else:
-        config_path = os.path.join(os.path.dirname(__file__), "example_config.py")
+        config_path = os.path.join(os.path.dirname(__file__), "local_config.py")
        load_config(config_path)
--- a/unilabos/device_comms/opcua_client/client.py
+++ b/unilabos/device_comms/opcua_client/client.py
--- a/unilabos/device_comms/opcua_client/node/uniopcua.py
+++ b/unilabos/device_comms/opcua_client/node/uniopcua.py
@@ -43,7 +43,7 @@ class Base(ABC):
        self._type = typ
        self._data_type = data_type
        self._node: Optional[Node] = None
-
+        
    def _get_node(self) -> Node:
        if self._node is None:
            try:
@@ -66,7 +66,7 @@ class Base(ABC):
                # 直接以字符串形式处理
                if isinstance(nid, str):
                    nid = nid.strip()
-
+                    
                    # 处理包含类名的格式，如 'StringNodeId(ns=4;s=...)' 或 'NumericNodeId(ns=2;i=...)'
                    # 提取括号内的内容
                    match_wrapped = re.match(r'(String|Numeric|Byte|Guid|TwoByteNode|FourByteNode)NodeId\((.*)\)', nid)
@@ -116,16 +116,16 @@ class Base(ABC):
    def read(self) -> Tuple[Any, bool]:
        """读取节点值，返回(值, 是否出错)"""
        pass
-
+    
    @abstractmethod
    def write(self, value: Any) -> bool:
        """写入节点值，返回是否出错"""
        pass
-
+    
    @property
    def type(self) -> NodeType:
        return self._type
-
+    
    @property
    def node_id(self) -> str:
        return self._node_id
@@ -210,15 +210,15 @@ class Method(Base):
        super().__init__(client, name, node_id, NodeType.METHOD, data_type)
        self._parent_node_id = parent_node_id
        self._parent_node = None
-
+        
    def _get_parent_node(self) -> Node:
        if self._parent_node is None:
            try:
                # 处理父节点ID，使用与_get_node相同的解析逻辑
                import re
-
+                
                nid = self._parent_node_id
-
+                
                # 如果已经是 NodeId 对象，直接使用
                try:
                    from opcua.ua import NodeId as UaNodeId
@@ -227,16 +227,16 @@ class Method(Base):
                        return self._parent_node
                except Exception:
                    pass
-
+                
                # 字符串处理
                if isinstance(nid, str):
                    nid = nid.strip()
-
+                    
                    # 处理包含类名的格式
                    match_wrapped = re.match(r'(String|Numeric|Byte|Guid|TwoByteNode|FourByteNode)NodeId\((.*)\)', nid)
                    if match_wrapped:
                        nid = match_wrapped.group(2).strip()
-
+                    
                    # 常见短格式
                    if re.match(r'^ns=\d+;[is]=', nid):
                        self._parent_node = self._client.get_node(nid)
@@ -271,7 +271,7 @@ class Method(Base):
    def write(self, value: Any) -> bool:
        """方法节点不支持写入操作"""
        return True
-
+        
    def call(self, *args) -> Tuple[Any, bool]:
        """调用方法，返回(返回值, 是否出错)"""
        try:
@@ -285,7 +285,7 @@ class Method(Base):
 class Object(Base):
    def __init__(self, client: Client, name: str, node_id: str):
        super().__init__(client, name, node_id, NodeType.OBJECT, None)
-
+        
    def read(self) -> Tuple[Any, bool]:
        """对象节点不支持直接读取操作"""
        return None, True
@@ -293,7 +293,7 @@ class Object(Base):
    def write(self, value: Any) -> bool:
        """对象节点不支持直接写入操作"""
        return True
-
+    
    def get_children(self) -> Tuple[List[Node], bool]:
        """获取子节点列表，返回(子节点列表, 是否出错)"""
        try:
@@ -301,4 +301,4 @@ class Object(Base):
            return children, False
        except Exception as e:
            print(f"获取对象 {self._name} 的子节点失败: {e}")
-            return [], True
+            return [], True 
--- a/unilabos/device_mesh/resource_visalization.py
+++ b/unilabos/device_mesh/resource_visalization.py
@@ -201,42 +201,17 @@ class ResourceVisualization:
                self.moveit_controllers_yaml['moveit_simple_controller_manager'][f"{name}_{controller_name}"] = moveit_dict['moveit_simple_controller_manager'][controller_name]


-    @staticmethod
-    def _ensure_ros2_env() -> dict:
-        """确保 ROS2 环境变量正确设置，返回可用于子进程的 env dict"""
-        import sys
-        env = dict(os.environ)
-        conda_prefix = os.path.dirname(os.path.dirname(sys.executable))
-
-        if "AMENT_PREFIX_PATH" not in env or not env["AMENT_PREFIX_PATH"].strip():
-            candidate = os.pathsep.join([conda_prefix, os.path.join(conda_prefix, "Library")])
-            env["AMENT_PREFIX_PATH"] = candidate
-            os.environ["AMENT_PREFIX_PATH"] = candidate
-
-        extra_bin_dirs = [
-            os.path.join(conda_prefix, "Library", "bin"),
-            os.path.join(conda_prefix, "Library", "lib"),
-            os.path.join(conda_prefix, "Scripts"),
-            conda_prefix,
-        ]
-        current_path = env.get("PATH", "")
-        for d in extra_bin_dirs:
-            if d not in current_path:
-                current_path = d + os.pathsep + current_path
-        env["PATH"] = current_path
-        os.environ["PATH"] = current_path
-
-        return env
-
    def create_launch_description(self) -> LaunchDescription:
        """
        创建launch描述，包含robot_state_publisher和move_group节点

+        Args:
+            urdf_str: URDF文本
+
        Returns:
            LaunchDescription: launch描述对象
        """
-        launch_env = self._ensure_ros2_env()
-
+        # 检查ROS 2环境变量
        if "AMENT_PREFIX_PATH" not in os.environ:
            raise OSError(
                "ROS 2环境未正确设置。需要设置 AMENT_PREFIX_PATH 环境变量。\n"
@@ -315,7 +290,7 @@ class ResourceVisualization:
                        {"robot_description": robot_description},
                        ros2_controllers,
                    ],
-                    env=launch_env,
+                    env=dict(os.environ)
                )
            )
            for controller in self.moveit_controllers_yaml['moveit_simple_controller_manager']['controller_names']:
@@ -325,7 +300,7 @@ class ResourceVisualization:
                        executable="spawner",
                        arguments=[f"{controller}", "--controller-manager", f"controller_manager"],
                        output="screen",
-                        env=launch_env,
+                        env=dict(os.environ)
                    )
                )
            controllers.append(
@@ -334,7 +309,7 @@ class ResourceVisualization:
                        executable="spawner",
                        arguments=["joint_state_broadcaster", "--controller-manager", f"controller_manager"],
                        output="screen",
-                        env=launch_env,
+                        env=dict(os.environ)
                )
            )
            for i in controllers:
@@ -342,6 +317,7 @@ class ResourceVisualization:
        else:
            ros2_controllers = None

+        # 创建robot_state_publisher节点
        robot_state_publisher = nd(
            package='robot_state_publisher',
            executable='robot_state_publisher',
@@ -351,8 +327,9 @@ class ResourceVisualization:
                'robot_description': robot_description,
                'use_sim_time': False
            },
+            # kinematics_dict
            ],
-            env=launch_env,
+            env=dict(os.environ)
        )


@@ -384,7 +361,7 @@ class ResourceVisualization:
            executable='move_group',
            output='screen',
            parameters=moveit_params,
-            env=launch_env,
+            env=dict(os.environ)
        )


@@ -402,11 +379,13 @@ class ResourceVisualization:
                arguments=['-d', f"{str(self.mesh_path)}/view_robot.rviz"],
                output='screen',
                parameters=[
-                    {'robot_description_kinematics': kinematics_dict},
+                    {'robot_description_kinematics': kinematics_dict,
+                     },
                    robot_description_planning,
                    planning_pipelines,
+
                ],
-                env=launch_env,
+                env=dict(os.environ)
            )
            self.launch_description.add_action(rviz_node)

--- a/unilabos/devices/liquid_handling/liquid_handler_abstract.py
+++ b/unilabos/devices/liquid_handling/liquid_handler_abstract.py
--- a/unilabos/devices/liquid_handling/prcxi/prcxi.py
+++ b/unilabos/devices/liquid_handling/prcxi/prcxi.py
--- a/unilabos/devices/liquid_handling/rviz_backend.py
+++ b/unilabos/devices/liquid_handling/rviz_backend.py
@@ -59,7 +59,6 @@ class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
    self.total_height = total_height
    self.joint_config = kwargs.get("joint_config", None)
    self.lh_device_id = kwargs.get("lh_device_id", "lh_joint_publisher")
-    self.simulate_rviz = kwargs.get("simulate_rviz", False)
    if not rclpy.ok():
        rclpy.init()
    self.joint_state_publisher = None
@@ -70,7 +69,7 @@ class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
    self.joint_state_publisher = LiquidHandlerJointPublisher(
                                joint_config=self.joint_config,
                                lh_device_id=self.lh_device_id,
-                                simulate_rviz=self.simulate_rviz)
+                                simulate_rviz=True)

    # 启动ROS executor
    self.executor = rclpy.executors.MultiThreadedExecutor()
--- a/unilabos/devices/neware_battery_test_system/init.py
+++ b/unilabos/devices/neware_battery_test_system/init.py
--- a/unilabos/devices/ros_dev/liquid_handler_joint_publisher.py
+++ b/unilabos/devices/ros_dev/liquid_handler_joint_publisher.py
@@ -19,11 +19,10 @@ from rclpy.node import Node
 import re

 class LiquidHandlerJointPublisher(BaseROS2DeviceNode):
-    def __init__(self,resources_config:list, resource_tracker, rate=50, device_id:str = "lh_joint_publisher", registry_name: str = "lh_joint_publisher", **kwargs):
+    def __init__(self,resources_config:list, resource_tracker, rate=50, device_id:str = "lh_joint_publisher", **kwargs):
        super().__init__(
            driver_instance=self,
            device_id=device_id,
-            registry_name=registry_name,
            status_types={},
            action_value_mappings={},
            hardware_interface={},
--- a/unilabos/devices/ros_dev/liquid_handler_joint_publisher_node.py
+++ b/unilabos/devices/ros_dev/liquid_handler_joint_publisher_node.py
@@ -42,7 +42,6 @@ class LiquidHandlerJointPublisher(Node):
            while self.resource_action is None:
                self.resource_action = self.check_tf_update_actions()
                time.sleep(1)
-                self.get_logger().info(f'Waiting for TfUpdate server: {self.resource_action}')

            self.resource_action_client = ActionClient(self, SendCmd, self.resource_action)
            while not self.resource_action_client.wait_for_server(timeout_sec=1.0):
--- a/unilabos/devices/virtual/virtual_transferpump.py
+++ b/unilabos/devices/virtual/virtual_transferpump.py
@@ -15,35 +15,35 @@ class VirtualPumpMode(Enum):

 class VirtualTransferPump:
    """虚拟转移泵类 - 模拟泵的基本功能，无需实际硬件 🚰"""
-
+    
    _ros_node: BaseROS2DeviceNode
-
+    
    def __init__(self, device_id: str = None, config: dict = None, **kwargs):
        """
        初始化虚拟转移泵
-
+        
        Args:
            device_id: 设备ID
            config: 配置字典，包含max_volume, port等参数
            **kwargs: 其他参数，确保兼容性
        """
        self.device_id = device_id or "virtual_transfer_pump"
-
+        
        # 从config或kwargs中获取参数，确保类型正确
        if config:
-            self.max_volume = float(config.get("max_volume", 25.0))
-            self.port = config.get("port", "VIRTUAL")
+            self.max_volume = float(config.get('max_volume', 25.0))
+            self.port = config.get('port', 'VIRTUAL')
        else:
-            self.max_volume = float(kwargs.get("max_volume", 25.0))
-            self.port = kwargs.get("port", "VIRTUAL")
-
-        self._transfer_rate = float(kwargs.get("transfer_rate", 0))
-        self.mode = kwargs.get("mode", VirtualPumpMode.Normal)
-
+            self.max_volume = float(kwargs.get('max_volume', 25.0))
+            self.port = kwargs.get('port', 'VIRTUAL')
+        
+        self._transfer_rate = float(kwargs.get('transfer_rate', 0))
+        self.mode = kwargs.get('mode', VirtualPumpMode.Normal)
+        
        # 状态变量 - 确保都是正确类型
        self._status = "Idle"
        self._position = 0.0  # float
-        self._max_velocity = 5.0  # float
+        self._max_velocity = 5.0  # float 
        self._current_volume = 0.0  # float

        # 🚀 新增：快速模式设置 - 大幅缩短执行时间
@@ -52,16 +52,14 @@ class VirtualTransferPump:
        self._fast_dispense_time = 1.0  # 快速喷射时间（秒）

        self.logger = logging.getLogger(f"VirtualTransferPump.{self.device_id}")
-
+        
        print(f"🚰 === 虚拟转移泵 {self.device_id} 已创建 === ✨")
-        print(
-            f"💨 快速模式: {'启用' if self._fast_mode else '禁用'} | 移动时间: {self._fast_move_time}s | 喷射时间: {self._fast_dispense_time}s"
-        )
+        print(f"💨 快速模式: {'启用' if self._fast_mode else '禁用'} | 移动时间: {self._fast_move_time}s | 喷射时间: {self._fast_dispense_time}s")
        print(f"📊 最大容量: {self.max_volume}mL | 端口: {self.port}")
-
+    
    def post_init(self, ros_node: BaseROS2DeviceNode):
        self._ros_node = ros_node
-
+    
    async def initialize(self) -> bool:
        """初始化虚拟泵 🚀"""
        self.logger.info(f"🔧 初始化虚拟转移泵 {self.device_id} ✨")
@@ -70,33 +68,33 @@ class VirtualTransferPump:
        self._current_volume = 0.0
        self.logger.info(f"✅ 转移泵 {self.device_id} 初始化完成 🚰")
        return True
-
+    
    async def cleanup(self) -> bool:
        """清理虚拟泵 🧹"""
        self.logger.info(f"🧹 清理虚拟转移泵 {self.device_id} 🔚")
        self._status = "Idle"
        self.logger.info(f"✅ 转移泵 {self.device_id} 清理完成 💤")
        return True
-
+    
    # 基本属性
    @property
    def status(self) -> str:
        return self._status
-
+    
    @property
    def position(self) -> float:
        """当前柱塞位置 (ml) 📍"""
        return self._position
-
+    
    @property
    def current_volume(self) -> float:
        """当前注射器中的体积 (ml) 💧"""
        return self._current_volume
-
+    
    @property
    def max_velocity(self) -> float:
        return self._max_velocity
-
+    
    @property
    def transfer_rate(self) -> float:
        return self._transfer_rate
@@ -105,17 +103,17 @@ class VirtualTransferPump:
        """设置最大速度 (ml/s) 🌊"""
        self._max_velocity = max(0.1, min(50.0, velocity))  # 限制在合理范围内
        self.logger.info(f"🌊 设置最大速度为 {self._max_velocity} mL/s")
-
+    
    def get_status(self) -> str:
        """获取泵状态 📋"""
        return self._status
-
+    
    async def _simulate_operation(self, duration: float):
        """模拟操作延时 ⏱️"""
        self._status = "Busy"
        await self._ros_node.sleep(duration)
        self._status = "Idle"
-
+    
    def _calculate_duration(self, volume: float, velocity: float = None) -> float:
        """
        计算操作持续时间 ⏰
@@ -123,10 +121,10 @@ class VirtualTransferPump:
        """
        if velocity is None:
            velocity = self._max_velocity
-
+        
        # 📊 计算理论时间（用于日志显示）
        theoretical_duration = abs(volume) / velocity
-
+        
        # 🚀 如果启用快速模式，使用固定的快速时间
        if self._fast_mode:
            # 根据操作类型选择快速时间
@@ -134,13 +132,13 @@ class VirtualTransferPump:
                actual_duration = self._fast_move_time
            else:  # 很小的操作
                actual_duration = 0.5
-
+            
            self.logger.debug(f"⚡ 快速模式: 理论时间 {theoretical_duration:.2f}s → 实际时间 {actual_duration:.2f}s")
            return actual_duration
        else:
            # 正常模式使用理论时间
            return theoretical_duration
-
+    
    def _calculate_display_duration(self, volume: float, velocity: float = None) -> float:
        """
        计算显示用的持续时间（用于日志） 📊
@@ -149,16 +147,16 @@ class VirtualTransferPump:
        if velocity is None:
            velocity = self._max_velocity
        return abs(volume) / velocity
-
+    
    # 新的set_position方法 - 专门用于SetPumpPosition动作
    async def set_position(self, position: float, max_velocity: float = None):
        """
        移动到绝对位置 - 专门用于SetPumpPosition动作 🎯
-
+        
        Args:
            position (float): 目标位置 (ml)
            max_velocity (float): 移动速度 (ml/s)
-
+        
        Returns:
            dict: 符合SetPumpPosition.action定义的结果
        """
@@ -166,19 +164,19 @@ class VirtualTransferPump:
            # 验证并转换参数
            target_position = float(position)
            velocity = float(max_velocity) if max_velocity is not None else self._max_velocity
-
+            
            # 限制位置在有效范围内
            target_position = max(0.0, min(float(self.max_volume), target_position))
-
+            
            # 计算移动距离
            volume_to_move = abs(target_position - self._position)
-
+            
            # 📊 计算显示用的时间（用于日志）
            display_duration = self._calculate_display_duration(volume_to_move, velocity)
-
+            
            # ⚡ 计算实际执行时间（快速模式）
            actual_duration = self._calculate_duration(volume_to_move, velocity)
-
+            
            # 🎯 确定操作类型和emoji
            if target_position > self._position:
                operation_type = "吸液"
@@ -189,34 +187,28 @@ class VirtualTransferPump:
            else:
                operation_type = "保持"
                operation_emoji = "📍"
-
+            
            self.logger.info(f"🎯 SET_POSITION: {operation_type} {operation_emoji}")
-            self.logger.info(
-                f"  📍 位置: {self._position:.2f}mL → {target_position:.2f}mL (移动 {volume_to_move:.2f}mL)"
-            )
+            self.logger.info(f"  📍 位置: {self._position:.2f}mL → {target_position:.2f}mL (移动 {volume_to_move:.2f}mL)")
            self.logger.info(f"  🌊 速度: {velocity:.2f} mL/s")
            self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
-
+            
            if self._fast_mode:
                self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
-
+            
            # 🚀 模拟移动过程
            if volume_to_move > 0.01:  # 只有当移动距离足够大时才显示进度
                start_position = self._position
                steps = 5 if actual_duration > 0.5 else 2  # 根据实际时间调整步数
                step_duration = actual_duration / steps
-
+                
                self.logger.info(f"🚀 开始{operation_type}... {operation_emoji}")
-
+                
                for i in range(steps + 1):
                    # 计算当前位置和进度
                    progress = (i / steps) * 100 if steps > 0 else 100
-                    current_pos = (
-                        start_position + (target_position - start_position) * (i / steps)
-                        if steps > 0
-                        else target_position
-                    )
-
+                    current_pos = start_position + (target_position - start_position) * (i / steps) if steps > 0 else target_position
+                    
                    # 更新状态
                    if i < steps:
                        self._status = f"{operation_type}中"
@@ -224,10 +216,10 @@ class VirtualTransferPump:
                    else:
                        self._status = "Idle"
                        status_emoji = "✅"
-
+                    
                    self._position = current_pos
                    self._current_volume = current_pos
-
+                    
                    # 显示进度（每25%或最后一步）
                    if i == 0:
                        self.logger.debug(f"  🔄 {operation_type}开始: {progress:.0f}%")
@@ -235,7 +227,7 @@ class VirtualTransferPump:
                        self.logger.debug(f"  🔄 {operation_type}进度: {progress:.0f}%")
                    elif i == steps:
                        self.logger.info(f"  ✅ {operation_type}完成: {progress:.0f}% | 当前位置: {current_pos:.2f}mL")
-
+                    
                    # 等待一小步时间
                    if i < steps and step_duration > 0:
                        await self._ros_node.sleep(step_duration)
@@ -244,27 +236,25 @@ class VirtualTransferPump:
                self._position = target_position
                self._current_volume = target_position
                self.logger.info(f"  📍 微调完成: {target_position:.2f}mL")
-
+        
            # 确保最终位置准确
            self._position = target_position
            self._current_volume = target_position
            self._status = "Idle"
-
+            
            # 📊 最终状态日志
            if volume_to_move > 0.01:
-                self.logger.info(
-                    f"🎉 SET_POSITION 完成! 📍 最终位置: {self._position:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL"
-                )
-
+                self.logger.info(f"🎉 SET_POSITION 完成! 📍 最终位置: {self._position:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")
+            
            # 返回符合action定义的结果
            return {
                "success": True,
                "message": f"✅ 成功移动到位置 {self._position:.2f}mL ({operation_type})",
                "final_position": self._position,
                "final_volume": self._current_volume,
-                "operation_type": operation_type,
+                "operation_type": operation_type
            }
-
+            
        except Exception as e:
            error_msg = f"❌ 设置位置失败: {str(e)}"
            self.logger.error(error_msg)
@@ -272,136 +262,134 @@ class VirtualTransferPump:
                "success": False,
                "message": error_msg,
                "final_position": self._position,
-                "final_volume": self._current_volume,
+                "final_volume": self._current_volume
            }
-
+    
    # 其他泵操作方法
    async def pull_plunger(self, volume: float, velocity: float = None):
        """
        拉取柱塞（吸液） 📥
-
+        
        Args:
            volume (float): 要拉取的体积 (ml)
            velocity (float): 拉取速度 (ml/s)
        """
        new_position = min(self.max_volume, self._position + volume)
        actual_volume = new_position - self._position
-
+        
        if actual_volume <= 0:
            self.logger.warning("⚠️ 无法吸液 - 已达到最大容量")
            return
-
+        
        display_duration = self._calculate_display_duration(actual_volume, velocity)
        actual_duration = self._calculate_duration(actual_volume, velocity)
-
+        
        self.logger.info(f"📥 开始吸液: {actual_volume:.2f}mL")
        self.logger.info(f"  📍 位置: {self._position:.2f}mL → {new_position:.2f}mL")
        self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
-
+        
        if self._fast_mode:
            self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
-
+        
        await self._simulate_operation(actual_duration)
-
+        
        self._position = new_position
        self._current_volume = new_position
-
+        
        self.logger.info(f"✅ 吸液完成: {actual_volume:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")

    async def push_plunger(self, volume: float, velocity: float = None):
        """
        推出柱塞（排液） 📤
-
+        
        Args:
            volume (float): 要推出的体积 (ml)
            velocity (float): 推出速度 (ml/s)
        """
        new_position = max(0, self._position - volume)
        actual_volume = self._position - new_position
-
+        
        if actual_volume <= 0:
            self.logger.warning("⚠️ 无法排液 - 已达到最小容量")
            return
-
+        
        display_duration = self._calculate_display_duration(actual_volume, velocity)
        actual_duration = self._calculate_duration(actual_volume, velocity)
-
+        
        self.logger.info(f"📤 开始排液: {actual_volume:.2f}mL")
        self.logger.info(f"  📍 位置: {self._position:.2f}mL → {new_position:.2f}mL")
        self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
-
+        
        if self._fast_mode:
            self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
-
+        
        await self._simulate_operation(actual_duration)
-
+        
        self._position = new_position
        self._current_volume = new_position
-
+        
        self.logger.info(f"✅ 排液完成: {actual_volume:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")

    # 便捷操作方法
    async def aspirate(self, volume: float, velocity: float = None):
        """吸液操作 📥"""
        await self.pull_plunger(volume, velocity)
-
+    
    async def dispense(self, volume: float, velocity: float = None):
        """排液操作 📤"""
        await self.push_plunger(volume, velocity)
-
+    
    async def transfer(self, volume: float, aspirate_velocity: float = None, dispense_velocity: float = None):
        """转移操作（先吸后排） 🔄"""
        self.logger.info(f"🔄 开始转移操作: {volume:.2f}mL")
-
+        
        # 吸液
        await self.aspirate(volume, aspirate_velocity)
-
+        
        # 短暂停顿
        self.logger.debug("⏸️ 短暂停顿...")
        await self._ros_node.sleep(0.1)
-
+        
        # 排液
        await self.dispense(volume, dispense_velocity)
-
+    
    async def empty_syringe(self, velocity: float = None):
        """清空注射器"""
        await self.set_position(0, velocity)
-
+    
    async def fill_syringe(self, velocity: float = None):
        """充满注射器"""
        await self.set_position(self.max_volume, velocity)
-
+    
    async def stop_operation(self):
        """停止当前操作"""
        self._status = "Idle"
        self.logger.info("Operation stopped")
-
+    
    # 状态查询方法
    def get_position(self) -> float:
        """获取当前位置"""
        return self._position
-
+    
    def get_current_volume(self) -> float:
        """获取当前体积"""
        return self._current_volume
-
+    
    def get_remaining_capacity(self) -> float:
        """获取剩余容量"""
        return self.max_volume - self._current_volume
-
+    
    def is_empty(self) -> bool:
        """检查是否为空"""
        return self._current_volume <= 0.01  # 允许小量误差
-
+    
    def is_full(self) -> bool:
        """检查是否已满"""
        return self._current_volume >= (self.max_volume - 0.01)  # 允许小量误差
-
+    
    def __str__(self):
-        return (
-            f"VirtualTransferPump({self.device_id}: {self._current_volume:.2f}/{self.max_volume} ml, {self._status})"
-        )
-
+        return f"VirtualTransferPump({self.device_id}: {self._current_volume:.2f}/{self.max_volume} ml, {self._status})"
+    
    def __repr__(self):
        return self.__str__()

@@ -410,20 +398,20 @@ class VirtualTransferPump:
 async def demo():
    """虚拟泵使用示例"""
    pump = VirtualTransferPump("demo_pump", {"max_volume": 50.0})
-
+    
    await pump.initialize()
-
+    
    print(f"Initial state: {pump}")
-
+    
    # 测试set_position方法
    result = await pump.set_position(10.0, max_velocity=2.0)
    print(f"Set position result: {result}")
    print(f"After setting position to 10ml: {pump}")
-
+    
    # 吸液测试
    await pump.aspirate(5.0, velocity=2.0)
    print(f"After aspirating 5ml: {pump}")
-
+    
    # 清空测试
    result = await pump.set_position(0.0)
    print(f"Empty result: {result}")
--- a/unilabos/devices/virtual/workbench.py
+++ b/unilabos/devices/virtual/workbench.py
@@ -1,759 +0,0 @@
-"""
-Virtual Workbench Device - 模拟工作台设备
-包含：
- 1个机械臂 (每次操作3s, 独占锁)
- 3个加热台 (每次加热10s, 可并行)
-
-工作流程：
-1. A1-A5 物料同时启动，竞争机械臂
-2. 机械臂将物料移动到空闲加热台
-3. 加热完成后，机械臂将物料移动到C1-C5
-
-注意：调用来自线程池，使用 threading.Lock 进行同步
-"""
-
-import logging
-import time
-from typing import Dict, Any, Optional, List
-from dataclasses import dataclass
-from enum import Enum
-from threading import Lock, RLock
-
-from typing_extensions import TypedDict
-
-from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-from unilabos.utils.decorator import not_action, always_free
-from unilabos.resources.resource_tracker import SampleUUIDsType, LabSample, RETURN_UNILABOS_SAMPLES
-
-
-# ============ TypedDict 返回类型定义 ============
-
-
-class MoveToHeatingStationResult(TypedDict):
-    """move_to_heating_station 返回类型"""
-
-    success: bool
-    station_id: int
-    material_id: str
-    material_number: int
-    message: str
-    unilabos_samples: List[LabSample]
-
-
-class StartHeatingResult(TypedDict):
-    """start_heating 返回类型"""
-
-    success: bool
-    station_id: int
-    material_id: str
-    material_number: int
-    message: str
-    unilabos_samples: List[LabSample]
-
-
-class MoveToOutputResult(TypedDict):
-    """move_to_output 返回类型"""
-
-    success: bool
-    station_id: int
-    material_id: str
-    unilabos_samples: List[LabSample]
-
-
-class PrepareMaterialsResult(TypedDict):
-    """prepare_materials 返回类型 - 批量准备物料"""
-
-    success: bool
-    count: int
-    material_1: int  # 物料编号1
-    material_2: int  # 物料编号2
-    material_3: int  # 物料编号3
-    material_4: int  # 物料编号4
-    material_5: int  # 物料编号5
-    message: str
-    unilabos_samples: List[LabSample]
-
-
-# ============ 状态枚举 ============
-
-
-class HeatingStationState(Enum):
-    """加热台状态枚举"""
-
-    IDLE = "idle"  # 空闲
-    OCCUPIED = "occupied"  # 已放置物料，等待加热
-    HEATING = "heating"  # 加热中
-    COMPLETED = "completed"  # 加热完成，等待取走
-
-
-class ArmState(Enum):
-    """机械臂状态枚举"""
-
-    IDLE = "idle"  # 空闲
-    BUSY = "busy"  # 工作中
-
-
-@dataclass
-class HeatingStation:
-    """加热台数据结构"""
-
-    station_id: int
-    state: HeatingStationState = HeatingStationState.IDLE
-    current_material: Optional[str] = None  # 当前物料 (如 "A1", "A2")
-    material_number: Optional[int] = None  # 物料编号 (1-5)
-    heating_start_time: Optional[float] = None
-    heating_progress: float = 0.0
-
-
-class VirtualWorkbench:
-    """
-    Virtual Workbench Device - 虚拟工作台设备
-
-    模拟一个包含1个机械臂和3个加热台的工作站
-    - 机械臂操作耗时3秒，同一时间只能执行一个操作
-    - 加热台加热耗时10秒，3个加热台可并行工作
-
-    工作流:
-    1. 物料A1-A5并发启动（线程池），竞争机械臂使用权
-    2. 获取机械臂后，查找空闲加热台
-    3. 机械臂将物料放入加热台，开始加热
-    4. 加热完成后，机械臂将物料移动到目标位置Cn
-    """
-
-    _ros_node: BaseROS2DeviceNode
-
-    # 配置常量
-    ARM_OPERATION_TIME: float = 2  # 机械臂操作时间(秒)
-    HEATING_TIME: float = 60.0  # 加热时间(秒)
-    NUM_HEATING_STATIONS: int = 3  # 加热台数量
-
-    def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
-        # 处理可能的不同调用方式
-        if device_id is None and "id" in kwargs:
-            device_id = kwargs.pop("id")
-        if config is None and "config" in kwargs:
-            config = kwargs.pop("config")
-
-        self.device_id = device_id or "virtual_workbench"
-        self.config = config or {}
-
-        self.logger = logging.getLogger(f"VirtualWorkbench.{self.device_id}")
-        self.data: Dict[str, Any] = {}
-
-        # 从config中获取可配置参数
-        self.ARM_OPERATION_TIME = float(self.config.get("arm_operation_time", self.ARM_OPERATION_TIME))
-        self.HEATING_TIME = float(self.config.get("heating_time", self.HEATING_TIME))
-        self.NUM_HEATING_STATIONS = int(self.config.get("num_heating_stations", self.NUM_HEATING_STATIONS))
-
-        # 机械臂状态和锁 (使用threading.Lock)
-        self._arm_lock = Lock()
-        self._arm_state = ArmState.IDLE
-        self._arm_current_task: Optional[str] = None
-
-        # 加热台状态 (station_id -> HeatingStation) - 立即初始化，不依赖initialize()
-        self._heating_stations: Dict[int, HeatingStation] = {
-            i: HeatingStation(station_id=i) for i in range(1, self.NUM_HEATING_STATIONS + 1)
-        }
-        self._stations_lock = RLock()  # 可重入锁，保护加热台状态
-
-        # 任务追踪
-        self._active_tasks: Dict[str, Dict[str, Any]] = {}  # material_id -> task_info
-        self._tasks_lock = Lock()
-
-        # 处理其他kwargs参数
-        skip_keys = {"arm_operation_time", "heating_time", "num_heating_stations"}
-        for key, value in kwargs.items():
-            if key not in skip_keys and not hasattr(self, key):
-                setattr(self, key, value)
-
-        self.logger.info(f"=== 虚拟工作台 {self.device_id} 已创建 ===")
-        self.logger.info(
-            f"机械臂操作时间: {self.ARM_OPERATION_TIME}s | "
-            f"加热时间: {self.HEATING_TIME}s | "
-            f"加热台数量: {self.NUM_HEATING_STATIONS}"
-        )
-
-    @not_action
-    def post_init(self, ros_node: BaseROS2DeviceNode):
-        """ROS节点初始化后回调"""
-        self._ros_node = ros_node
-
-    @not_action
-    def initialize(self) -> bool:
-        """初始化虚拟工作台"""
-        self.logger.info(f"初始化虚拟工作台 {self.device_id}")
-
-        # 重置加热台状态 (已在__init__中创建，这里重置为初始状态)
-        with self._stations_lock:
-            for station in self._heating_stations.values():
-                station.state = HeatingStationState.IDLE
-                station.current_material = None
-                station.material_number = None
-                station.heating_progress = 0.0
-
-        # 初始化状态
-        self.data.update(
-            {
-                "status": "Ready",
-                "arm_state": ArmState.IDLE.value,
-                "arm_current_task": None,
-                "heating_stations": self._get_stations_status(),
-                "active_tasks_count": 0,
-                "message": "工作台就绪",
-            }
-        )
-
-        self.logger.info(f"工作台初始化完成: {self.NUM_HEATING_STATIONS}个加热台就绪")
-        return True
-
-    @not_action
-    def cleanup(self) -> bool:
-        """清理虚拟工作台"""
-        self.logger.info(f"清理虚拟工作台 {self.device_id}")
-
-        self._arm_state = ArmState.IDLE
-        self._arm_current_task = None
-
-        with self._stations_lock:
-            self._heating_stations.clear()
-
-        with self._tasks_lock:
-            self._active_tasks.clear()
-
-        self.data.update(
-            {
-                "status": "Offline",
-                "arm_state": ArmState.IDLE.value,
-                "heating_stations": {},
-                "message": "工作台已关闭",
-            }
-        )
-        return True
-
-    def _get_stations_status(self) -> Dict[int, Dict[str, Any]]:
-        """获取所有加热台状态"""
-        with self._stations_lock:
-            return {
-                station_id: {
-                    "state": station.state.value,
-                    "current_material": station.current_material,
-                    "material_number": station.material_number,
-                    "heating_progress": station.heating_progress,
-                }
-                for station_id, station in self._heating_stations.items()
-            }
-
-    def _update_data_status(self, message: Optional[str] = None):
-        """更新状态数据"""
-        self.data.update(
-            {
-                "arm_state": self._arm_state.value,
-                "arm_current_task": self._arm_current_task,
-                "heating_stations": self._get_stations_status(),
-                "active_tasks_count": len(self._active_tasks),
-            }
-        )
-        if message:
-            self.data["message"] = message
-
-    def _find_available_heating_station(self) -> Optional[int]:
-        """查找空闲的加热台
-
-        Returns:
-            空闲加热台ID，如果没有则返回None
-        """
-        with self._stations_lock:
-            for station_id, station in self._heating_stations.items():
-                if station.state == HeatingStationState.IDLE:
-                    return station_id
-        return None
-
-    def _acquire_arm(self, task_description: str) -> bool:
-        """获取机械臂使用权（阻塞直到获取）
-
-        Args:
-            task_description: 任务描述，用于日志
-
-        Returns:
-            是否成功获取
-        """
-        self.logger.info(f"[{task_description}] 等待获取机械臂...")
-
-        # 阻塞等待获取锁
-        self._arm_lock.acquire()
-
-        self._arm_state = ArmState.BUSY
-        self._arm_current_task = task_description
-        self._update_data_status(f"机械臂执行: {task_description}")
-
-        self.logger.info(f"[{task_description}] 成功获取机械臂使用权")
-        return True
-
-    def _release_arm(self):
-        """释放机械臂"""
-        task = self._arm_current_task
-        self._arm_state = ArmState.IDLE
-        self._arm_current_task = None
-        self._arm_lock.release()
-        self._update_data_status(f"机械臂已释放 (完成: {task})")
-        self.logger.info(f"机械臂已释放 (完成: {task})")
-
-    def prepare_materials(
-        self,
-        sample_uuids: SampleUUIDsType,
-        count: int = 5,
-    ) -> PrepareMaterialsResult:
-        """
-        批量准备物料 - 虚拟起始节点
-
-        作为工作流的起始节点，生成指定数量的物料编号供后续节点使用。
-        输出5个handle (material_1 ~ material_5)，分别对应实验1~5。
-
-        Args:
-            count: 待生成的物料数量，默认5 (生成 A1-A5)
-
-        Returns:
-            PrepareMaterialsResult: 包含 material_1 ~ material_5 用于传递给 move_to_heating_station
-        """
-        # 生成物料列表 A1 - A{count}
-        materials = [i for i in range(1, count + 1)]
-
-        self.logger.info(f"[准备物料] 生成 {count} 个物料: " f"A1-A{count} -> material_1~material_{count}")
-
-        return {
-            "success": True,
-            "count": count,
-            "material_1": materials[0] if len(materials) > 0 else 0,
-            "material_2": materials[1] if len(materials) > 1 else 0,
-            "material_3": materials[2] if len(materials) > 2 else 0,
-            "material_4": materials[3] if len(materials) > 3 else 0,
-            "material_5": materials[4] if len(materials) > 4 else 0,
-            "message": f"已准备 {count} 个物料: A1-A{count}",
-            "unilabos_samples": [LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for sample_uuid, content in sample_uuids.items()]
-        }
-
-    def move_to_heating_station(
-        self,
-        sample_uuids: SampleUUIDsType,
-        material_number: int,
-    ) -> MoveToHeatingStationResult:
-        """
-        将物料从An位置移动到加热台
-
-        多线程并发调用时，会竞争机械臂使用权，并自动查找空闲加热台
-
-        Args:
-            material_number: 物料编号 (1-5)
-
-        Returns:
-            MoveToHeatingStationResult: 包含 station_id, material_number 等用于传递给下一个节点
-        """
-        # 根据物料编号生成物料ID
-        material_id = f"A{material_number}"
-        task_desc = f"移动{material_id}到加热台"
-        self.logger.info(f"[任务] {task_desc} - 开始执行")
-
-        # 记录任务
-        with self._tasks_lock:
-            self._active_tasks[material_id] = {
-                "status": "waiting_for_arm",
-                "start_time": time.time(),
-            }
-
-        try:
-            # 步骤1: 等待获取机械臂使用权(竞争)
-            with self._tasks_lock:
-                self._active_tasks[material_id]["status"] = "waiting_for_arm"
-            self._acquire_arm(task_desc)
-
-            # 步骤2: 查找空闲加热台
-            with self._tasks_lock:
-                self._active_tasks[material_id]["status"] = "finding_station"
-            station_id = None
-
-            # 循环等待直到找到空闲加热台
-            while station_id is None:
-                station_id = self._find_available_heating_station()
-                if station_id is None:
-                    self.logger.info(f"[{material_id}] 没有空闲加热台，等待中...")
-                    # 释放机械臂，等待后重试
-                    self._release_arm()
-                    time.sleep(0.5)
-                    self._acquire_arm(task_desc)
-
-            # 步骤3: 占用加热台 - 立即标记为OCCUPIED，防止其他任务选择同一加热台
-            with self._stations_lock:
-                self._heating_stations[station_id].state = HeatingStationState.OCCUPIED
-                self._heating_stations[station_id].current_material = material_id
-                self._heating_stations[station_id].material_number = material_number
-
-            # 步骤4: 模拟机械臂移动操作 (3秒)
-            with self._tasks_lock:
-                self._active_tasks[material_id]["status"] = "arm_moving"
-                self._active_tasks[material_id]["assigned_station"] = station_id
-            self.logger.info(f"[{material_id}] 机械臂正在移动到加热台{station_id}...")
-
-            time.sleep(self.ARM_OPERATION_TIME)
-
-            # 步骤5: 放入加热台完成
-            self._update_data_status(f"{material_id}已放入加热台{station_id}")
-            self.logger.info(f"[{material_id}] 已放入加热台{station_id} (用时{self.ARM_OPERATION_TIME}s)")
-
-            # 释放机械臂
-            self._release_arm()
-
-            with self._tasks_lock:
-                self._active_tasks[material_id]["status"] = "placed_on_station"
-
-            return {
-                "success": True,
-                "station_id": station_id,
-                "material_id": material_id,
-                "material_number": material_number,
-                "message": f"{material_id}已成功移动到加热台{station_id}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-        except Exception as e:
-            self.logger.error(f"[{material_id}] 移动失败: {str(e)}")
-            if self._arm_lock.locked():
-                self._release_arm()
-            return {
-                "success": False,
-                "station_id": -1,
-                "material_id": material_id,
-                "material_number": material_number,
-                "message": f"移动失败: {str(e)}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-    @always_free
-    def start_heating(
-        self,
-        sample_uuids: SampleUUIDsType,
-        station_id: int,
-        material_number: int,
-    ) -> StartHeatingResult:
-        """
-        启动指定加热台的加热程序
-
-        Args:
-            station_id: 加热台ID (1-3)，从 move_to_heating_station 的 handle 传入
-            material_number: 物料编号，从 move_to_heating_station 的 handle 传入
-
-        Returns:
-            StartHeatingResult: 包含 station_id, material_number 等用于传递给下一个节点
-        """
-        self.logger.info(f"[加热台{station_id}] 开始加热")
-
-        if station_id not in self._heating_stations:
-            return {
-                "success": False,
-                "station_id": station_id,
-                "material_id": "",
-                "material_number": material_number,
-                "message": f"无效的加热台ID: {station_id}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-        with self._stations_lock:
-            station = self._heating_stations[station_id]
-
-            if station.current_material is None:
-                return {
-                    "success": False,
-                    "station_id": station_id,
-                    "material_id": "",
-                    "material_number": material_number,
-                    "message": f"加热台{station_id}上没有物料",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
-                }
-
-            if station.state == HeatingStationState.HEATING:
-                return {
-                    "success": False,
-                    "station_id": station_id,
-                    "material_id": station.current_material,
-                    "material_number": material_number,
-                    "message": f"加热台{station_id}已经在加热中",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
-                }
-
-            material_id = station.current_material
-
-            # 开始加热
-            station.state = HeatingStationState.HEATING
-            station.heating_start_time = time.time()
-            station.heating_progress = 0.0
-
-        with self._tasks_lock:
-            if material_id in self._active_tasks:
-                self._active_tasks[material_id]["status"] = "heating"
-
-        self._update_data_status(f"加热台{station_id}开始加热{material_id}")
-
-        # 打印当前所有正在加热的台位
-        with self._stations_lock:
-            heating_list = [
-                f"加热台{sid}:{s.current_material}"
-                for sid, s in self._heating_stations.items()
-                if s.state == HeatingStationState.HEATING and s.current_material
-            ]
-        self.logger.info(f"[并行加热] 当前同时加热中: {', '.join(heating_list)}")
-
-        # 模拟加热过程
-        start_time = time.time()
-        last_countdown_log = start_time
-        while True:
-            elapsed = time.time() - start_time
-            remaining = max(0.0, self.HEATING_TIME - elapsed)
-            progress = min(100.0, (elapsed / self.HEATING_TIME) * 100)
-
-            with self._stations_lock:
-                self._heating_stations[station_id].heating_progress = progress
-
-            self._update_data_status(f"加热台{station_id}加热中: {progress:.1f}%")
-
-            # 每5秒打印一次倒计时
-            if time.time() - last_countdown_log >= 5.0:
-                self.logger.info(f"[加热台{station_id}] {material_id} 剩余 {remaining:.1f}s")
-                last_countdown_log = time.time()
-
-            if elapsed >= self.HEATING_TIME:
-                break
-
-            time.sleep(1.0)
-
-        # 加热完成
-        with self._stations_lock:
-            self._heating_stations[station_id].state = HeatingStationState.COMPLETED
-            self._heating_stations[station_id].heating_progress = 100.0
-
-        with self._tasks_lock:
-            if material_id in self._active_tasks:
-                self._active_tasks[material_id]["status"] = "heating_completed"
-
-        self._update_data_status(f"加热台{station_id}加热完成")
-        self.logger.info(f"[加热台{station_id}] {material_id}加热完成 (用时{self.HEATING_TIME}s)")
-
-        return {
-            "success": True,
-            "station_id": station_id,
-            "material_id": material_id,
-            "material_number": material_number,
-            "message": f"加热台{station_id}加热完成",
-            "unilabos_samples": [
-                LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                sample_uuid, content in sample_uuids.items()]
-        }
-
-    def move_to_output(
-        self,
-        sample_uuids: SampleUUIDsType,
-        station_id: int,
-        material_number: int,
-    ) -> MoveToOutputResult:
-        """
-        将物料从加热台移动到输出位置Cn
-
-        Args:
-            station_id: 加热台ID (1-3)，从 start_heating 的 handle 传入
-            material_number: 物料编号，从 start_heating 的 handle 传入，用于确定输出位置 Cn
-
-        Returns:
-            MoveToOutputResult: 包含执行结果
-        """
-        output_number = material_number  # 物料编号决定输出位置
-
-        if station_id not in self._heating_stations:
-            return {
-                "success": False,
-                "station_id": station_id,
-                "material_id": "",
-                "output_position": f"C{output_number}",
-                "message": f"无效的加热台ID: {station_id}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-        with self._stations_lock:
-            station = self._heating_stations[station_id]
-            material_id = station.current_material
-
-            if material_id is None:
-                return {
-                    "success": False,
-                    "station_id": station_id,
-                    "material_id": "",
-                    "output_position": f"C{output_number}",
-                    "message": f"加热台{station_id}上没有物料",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
-                }
-
-            if station.state != HeatingStationState.COMPLETED:
-                return {
-                    "success": False,
-                    "station_id": station_id,
-                    "material_id": material_id,
-                    "output_position": f"C{output_number}",
-                    "message": f"加热台{station_id}尚未完成加热 (当前状态: {station.state.value})",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
-                }
-
-        output_position = f"C{output_number}"
-        task_desc = f"从加热台{station_id}移动{material_id}到{output_position}"
-        self.logger.info(f"[任务] {task_desc}")
-
-        try:
-            with self._tasks_lock:
-                if material_id in self._active_tasks:
-                    self._active_tasks[material_id]["status"] = "waiting_for_arm_output"
-
-            # 获取机械臂
-            self._acquire_arm(task_desc)
-
-            with self._tasks_lock:
-                if material_id in self._active_tasks:
-                    self._active_tasks[material_id]["status"] = "arm_moving_to_output"
-
-            # 模拟机械臂操作 (3秒)
-            self.logger.info(f"[{material_id}] 机械臂正在从加热台{station_id}取出并移动到{output_position}...")
-            time.sleep(self.ARM_OPERATION_TIME)
-
-            # 清空加热台
-            with self._stations_lock:
-                self._heating_stations[station_id].state = HeatingStationState.IDLE
-                self._heating_stations[station_id].current_material = None
-                self._heating_stations[station_id].material_number = None
-                self._heating_stations[station_id].heating_progress = 0.0
-                self._heating_stations[station_id].heating_start_time = None
-
-            # 释放机械臂
-            self._release_arm()
-
-            # 任务完成
-            with self._tasks_lock:
-                if material_id in self._active_tasks:
-                    self._active_tasks[material_id]["status"] = "completed"
-                    self._active_tasks[material_id]["end_time"] = time.time()
-
-            self._update_data_status(f"{material_id}已移动到{output_position}")
-            self.logger.info(f"[{material_id}] 已成功移动到{output_position} (用时{self.ARM_OPERATION_TIME}s)")
-
-            return {
-                "success": True,
-                "station_id": station_id,
-                "material_id": material_id,
-                "output_position": output_position,
-                "message": f"{material_id}已成功移动到{output_position}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-        except Exception as e:
-            self.logger.error(f"移动到输出位置失败: {str(e)}")
-            if self._arm_lock.locked():
-                self._release_arm()
-            return {
-                "success": False,
-                "station_id": station_id,
-                "material_id": "",
-                "output_position": output_position,
-                "message": f"移动失败: {str(e)}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-    # ============ 状态属性 ============
-
-    @property
-    def status(self) -> str:
-        return self.data.get("status", "Unknown")
-
-    @property
-    def arm_state(self) -> str:
-        return self._arm_state.value
-
-    @property
-    def arm_current_task(self) -> str:
-        return self._arm_current_task or ""
-
-    @property
-    def heating_station_1_state(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(1)
-            return station.state.value if station else "unknown"
-
-    @property
-    def heating_station_1_material(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(1)
-            return station.current_material or "" if station else ""
-
-    @property
-    def heating_station_1_progress(self) -> float:
-        with self._stations_lock:
-            station = self._heating_stations.get(1)
-            return station.heating_progress if station else 0.0
-
-    @property
-    def heating_station_2_state(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(2)
-            return station.state.value if station else "unknown"
-
-    @property
-    def heating_station_2_material(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(2)
-            return station.current_material or "" if station else ""
-
-    @property
-    def heating_station_2_progress(self) -> float:
-        with self._stations_lock:
-            station = self._heating_stations.get(2)
-            return station.heating_progress if station else 0.0
-
-    @property
-    def heating_station_3_state(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(3)
-            return station.state.value if station else "unknown"
-
-    @property
-    def heating_station_3_material(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(3)
-            return station.current_material or "" if station else ""
-
-    @property
-    def heating_station_3_progress(self) -> float:
-        with self._stations_lock:
-            station = self._heating_stations.get(3)
-            return station.heating_progress if station else 0.0
-
-    @property
-    def active_tasks_count(self) -> int:
-        with self._tasks_lock:
-            return len(self._active_tasks)
-
-    @property
-    def message(self) -> str:
-        return self.data.get("message", "")
--- a/unilabos/devices/workstation/README.md
+++ b/unilabos/devices/workstation/README.md
@@ -1,5 +1,9 @@
 # 工作站抽象基类物料系统架构说明

+## 设计理念
+
+基于用户需求"请你帮我系统思考一下，工作站抽象基类的物料系统基类该如何构建"，我们最终确定了一个**PyLabRobot Deck为中心**的简化架构。
+
 ### 核心原则

 1. **PyLabRobot为物料管理核心**：使用PyLabRobot的Deck系统作为物料管理的基础，利用其成熟的Resource体系
--- a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260108_multi_batch1.xlsx
+++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260108_multi_batch1.xlsx
--- a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260108_multi_batch2.xlsx
+++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260108_multi_batch2.xlsx
--- a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/init.py
+++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/init.py
--- a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/outbound_template.xlsx
+++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/outbound_template.xlsx
--- a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/smiles&molweight.py
+++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/smiles&molweight.py
@@ -0,0 +1,12 @@
+import pubchempy as pcp
+
+cas = "21324-40-3"  # 示例
+comps = pcp.get_compounds(cas, namespace="name")
+if not comps:
+    raise ValueError("No hit")
+
+c = comps[0]
+
+print("Canonical SMILES:", c.canonical_smiles)
+print("Isomeric  SMILES:", c.isomeric_smiles)
+print("MW:", c.molecular_weight)
--- a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/solid_materials.csv
+++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/solid_materials.csv
@@ -0,0 +1,7 @@
+material_name
+LiPF6
+LiDFOB
+DTD
+LiFSI
+LiPO2F2
+
--- a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/批量出库模板使用说明.md
+++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/批量出库模板使用说明.md
@@ -1,157 +0,0 @@
-# 批量出库 Excel 模板使用说明
-
-**文件**: `outbound_template.xlsx`  
-**用途**: 配合 `auto_batch_outbound_from_xlsx()` 方法进行批量出库操作  
-**API 端点**: `/api/lims/storage/auto-batch-out-bound`
-
---
-
-## 📋 Excel 列说明
-
-| 列名 | 说明 | 示例 | 必填 |
-|------|------|------|------|
-| `locationId` | **库位 ID（UUID）** | `3a19da43-57b5-294f-d663-154a1cc32270` | ✅ 是 |
-| `warehouseId` | **仓库 ID 或名称** | `配液站内试剂仓库` | ✅ 是 |
-| `quantity` | **出库数量** | `1.0`, `2.0` | ✅ 是 |
-| `x` | **X 坐标（库位横向位置）** | `1`, `2`, `3` | ✅ 是 |
-| `y` | **Y 坐标（库位纵向位置）** | `1`, `2`, `3` | ✅ 是 |
-| `z` | **Z 坐标（库位层数/高度）** | `1`, `2`, `3` | ✅ 是 |
-| `备注说明` | 可选备注信息 | `配液站内试剂仓库-A01` | ❌ 否 |
-
-### 📐 坐标说明
-
-**x, y, z** 是库位在仓库内的**三维坐标**：
-
-```
-仓库（例如 WH4）
-├── Z=1（第1层/加样头面）
-│   ├── X=1, Y=1（位置 A）
-│   ├── X=2, Y=1（位置 B）
-│   ├── X=3, Y=1（位置 C）
-│   └── ...
-│
-└── Z=2（第2层/原液瓶面）
-    ├── X=1, Y=1（位置 A）
-    ├── X=2, Y=1（位置 B）
-    └── ...
-```
-
- **warehouseId**: 指定哪个仓库（WH3, WH4, 配液站等）
- **x, y, z**: 在该仓库内的三维坐标
- **locationId**: 该坐标位置的唯一 UUID
-
-### 🎯 起点与终点
-
-**重要说明**：批量出库模板**只规定了出库的"起点"**（从哪里取物料），**没有指定"终点"**（放到哪里）。
-
-```
-出库流程：
-起点（Excel 指定） → ？终点（LIMS/工作流决定）
-    ↓
-locationId, x, y, z    → 由 LIMS 系统或当前工作流自动分配
-```
-
-**终点由以下方式确定：**
- **LIMS 系统自动分配**：根据当前任务自动规划目标位置
- **工作流预定义**：在创建出库任务时已绑定目标位置
- **暂存区**：默认放到出库暂存区，等待下一步操作
-
-💡 **对比**：上料操作（`auto_feeding4to3`）则有 `targetWH` 参数可以指定目标仓库
-
---
-
-## 🔍 如何获取 UUID？
-
-### 方法 1：从配置文件获取
-
-参考 `yibin_electrolyte_config.json` 中的 `warehouse_mapping`：
-
-```json
-{
-  "warehouse_mapping": {
-    "配液站内试剂仓库": {
-      "site_uuids": {
-        "A01": "3a19da43-57b5-294f-d663-154a1cc32270",
-        "B01": "3a19da43-57b5-7394-5f49-54efe2c9bef2",
-        "C01": "3a19da43-57b5-5e75-552f-8dbd0ad1075f"
-      }
-    },
-    "手动堆栈": {
-      "site_uuids": {
-        "A01": "3a19deae-2c7a-36f5-5e41-02c5b66feaea",
-        "A02": "3a19deae-2c7a-dc6d-c41e-ef285d946cfe"
-      }
-    }
-  }
-}
-```
-
-### 方法 2：通过 API 查询
-
-```python
-material_info = hardware_interface.material_id_query(workflow_id)
-locations = material_info.get("locations", [])
-```
-
---
-
-## 📝 填写示例
-
-### 示例 1：从配液站内试剂仓库出库
-
-| locationId | warehouseId | quantity | x | y | z | 备注说明 |
-|------------|-------------|----------|---|---|---|----------|
-| `3a19da43-57b5-294f-d663-154a1cc32270` | 配液站内试剂仓库 | 1 | 1 | 1 | 1 | A01 位置 |
-| `3a19da43-57b5-7394-5f49-54efe2c9bef2` | 配液站内试剂仓库 | 2 | 2 | 1 | 1 | B01 位置 |
-
-### 示例 2：从手动堆栈出库
-
-| locationId | warehouseId | quantity | x | y | z | 备注说明 |
-|------------|-------------|----------|---|---|---|----------|
-| `3a19deae-2c7a-36f5-5e41-02c5b66feaea` | 手动堆栈 | 1 | 1 | 1 | 1 | A01 |
-| `3a19deae-2c7a-dc6d-c41e-ef285d946cfe` | 手动堆栈 | 1 | 1 | 2 | 1 | A02 |
-
---
-
-## 💻 使用方法
-
-```python
-from bioyond_cell_workstation import BioyondCellWorkstation
-
-# 初始化工作站
-workstation = BioyondCellWorkstation(config=config, deck=deck)
-
-# 调用批量出库方法
-result = workstation.auto_batch_outbound_from_xlsx(
-    xlsx_path="outbound_template.xlsx"
-)
-```
-
---
-
-## ⚠️ 注意事项
-
-1. **locationId 必须是有效的 UUID**，不能使用库位名称
-2. **x, y, z 坐标必须与 locationId 对应**，表示该库位在仓库内的位置
-3. **quantity 必须是数字**，可以是整数或浮点数
-4. Excel 文件必须包含表头行
-5. 空行会被自动跳过
-6. 确保 UUID 与实际库位对应，否则 API 会报错
-
---
-
-## 📚 相关文件
-
- **配置文件**: `yibin_electrolyte_config.json`
- **Python 代码**: `bioyond_cell_workstation.py` (L630-695)
- **生成脚本**: `create_outbound_template.py`
- **上料模板**: `material_template.xlsx`
-
---
-
-## 🔄 重新生成模板
-
-```bash
-conda activate newunilab
-python create_outbound_template.py
-```
--- a/unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py
+++ b/unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py
@@ -49,14 +49,6 @@ class BioyondV1RPC(BaseRequest):
        self.config = config
        self.api_key = config["api_key"]
        self.host = config["api_host"]
-
-        # 初始化 location_mapping
-        # 直接从 warehouse_mapping 构建，确保数据源所谓的单一和结构化
-        self.location_mapping = {}
-        warehouse_mapping = self.config.get("warehouse_mapping", {})
-        for warehouse_name, warehouse_config in warehouse_mapping.items():
-            if "site_uuids" in warehouse_config:
-                self.location_mapping.update(warehouse_config["site_uuids"])
        self._logger = SimpleLogger()
        self.material_cache = {}
        self._load_material_cache()
@@ -184,40 +176,7 @@ class BioyondV1RPC(BaseRequest):
            return {}

        print(f"add material data: {response['data']}")
-
-        # 自动更新缓存
-        data = response.get("data", {})
-        if data:
-            if isinstance(data, str):
-                # 如果返回的是字符串，通常是ID
-                mat_id = data
-                name = params.get("name")
-            else:
-                # 如果返回的是字典，尝试获取name和id
-                name = data.get("name") or params.get("name")
-                mat_id = data.get("id")
-
-            if name and mat_id:
-                self.material_cache[name] = mat_id
-                print(f"已自动更新缓存: {name} -> {mat_id}")
-
-            # 处理返回数据中的 details (如果有)
-            # 有些 API 返回结构可能直接包含 details，或者在 data 字段中
-            details = data.get("details", []) if isinstance(data, dict) else []
-            if not details and isinstance(data, dict):
-                 details = data.get("detail", [])
-
-            if details:
-                for detail in details:
-                    d_name = detail.get("name")
-                    # 尝试从不同字段获取 ID
-                    d_id = detail.get("id") or detail.get("detailMaterialId")
-
-                    if d_name and d_id:
-                        self.material_cache[d_name] = d_id
-                        print(f"已自动更新 detail 缓存: {d_name} -> {d_id}")
-
-        return data
+        return response.get("data", {})

    def query_matial_type_id(self, data) -> list:
        """查找物料typeid"""
@@ -244,7 +203,7 @@ class BioyondV1RPC(BaseRequest):
            params={
                "apiKey": self.api_key,
                "requestTime": self.get_current_time_iso8601(),
-                "data": 0,
+                "data": {},
            })
        if not response or response['code'] != 1:
            return []
@@ -314,19 +273,12 @@ class BioyondV1RPC(BaseRequest):

        if not response or response['code'] != 1:
            return {}
-
-        # 自动更新缓存 - 移除被删除的物料
-        for name, mid in list(self.material_cache.items()):
-            if mid == material_id:
-                del self.material_cache[name]
-                print(f"已从缓存移除物料: {name}")
-                break
-
        return response.get("data", {})

    def material_outbound(self, material_id: str, location_name: str, quantity: int) -> dict:
        """指定库位出库物料（通过库位名称）"""
-        location_id = self.location_mapping.get(location_name, location_name)
+        # location_name 参数实际上应该直接是 location_id (UUID)
+        location_id = location_name

        params = {
            "materialId": material_id,
@@ -1152,10 +1104,6 @@ class BioyondV1RPC(BaseRequest):
                    for detail_material in detail_materials:
                        detail_name = detail_material.get("name")
                        detail_id = detail_material.get("detailMaterialId")
-                        if not detail_id:
-                            # 尝试其他可能的字段
-                            detail_id = detail_material.get("id")
-
                        if detail_name and detail_id:
                            self.material_cache[detail_name] = detail_id
                            print(f"加载detail材料: {detail_name} -> ID: {detail_id}")
@@ -1176,14 +1124,6 @@ class BioyondV1RPC(BaseRequest):
            print(f"从缓存找到材料: {material_name_or_id} -> ID: {material_id}")
            return material_id

-        # 如果缓存中没有，尝试刷新缓存
-        print(f"缓存中未找到材料 '{material_name_or_id}'，尝试刷新缓存...")
-        self.refresh_material_cache()
-        if material_name_or_id in self.material_cache:
-            material_id = self.material_cache[material_name_or_id]
-            print(f"刷新缓存后找到材料: {material_name_or_id} -> ID: {material_id}")
-            return material_id
-
        print(f"警告: 未在缓存中找到材料名称 '{material_name_or_id}'，将使用原值")
        return material_name_or_id

--- a/unilabos/devices/workstation/bioyond_studio/config.py.deprecated
+++ b/unilabos/devices/workstation/bioyond_studio/config.py.deprecated
@@ -1,329 +0,0 @@
-# config.py
-"""
-Bioyond工作站配置文件
-包含API配置、工作流映射、物料类型映射、仓库库位映射等所有配置信息
-"""
-
-from unilabos.resources.bioyond.decks import BIOYOND_PolymerReactionStation_Deck
-
-# ============================================================================
-# 基础配置
-# ============================================================================
-
-# API配置
-API_CONFIG = {
-    "api_key": "DE9BDDA0",
-    "api_host": "http://192.168.1.200:44402"
-}
-
-# HTTP 报送服务配置
-HTTP_SERVICE_CONFIG = {
-    "http_service_host": "127.0.0.1",  # 监听地址
-    "http_service_port": 8080,        # 监听端口
-}
-
-# Deck配置 - 反应站工作台配置
-DECK_CONFIG = BIOYOND_PolymerReactionStation_Deck(setup=True)
-
-# ============================================================================
-# 工作流配置
-# ============================================================================
-
-# 工作流ID映射
-WORKFLOW_MAPPINGS = {
-    "reactor_taken_out": "3a16081e-4788-ca37-eff4-ceed8d7019d1",
-    "reactor_taken_in": "3a160df6-76b3-0957-9eb0-cb496d5721c6",
-    "Solid_feeding_vials": "3a160877-87e7-7699-7bc6-ec72b05eb5e6",
-    "Liquid_feeding_vials(non-titration)": "3a167d99-6158-c6f0-15b5-eb030f7d8e47",
-    "Liquid_feeding_solvents": "3a160824-0665-01ed-285a-51ef817a9046",
-    "Liquid_feeding(titration)": "3a16082a-96ac-0449-446a-4ed39f3365b6",
-    "liquid_feeding_beaker": "3a16087e-124f-8ddb-8ec1-c2dff09ca784",
-    "Drip_back": "3a162cf9-6aac-565a-ddd7-682ba1796a4a",
-}
-
-# 工作流名称到显示名称的映射
-WORKFLOW_TO_SECTION_MAP = {
-    'reactor_taken_in': '反应器放入',
-    'reactor_taken_out': '反应器取出',
-    'Solid_feeding_vials': '固体投料-小瓶',
-    'Liquid_feeding_vials(non-titration)': '液体投料-小瓶（非滴定）',
-    'Liquid_feeding_solvents': '液体投料-溶剂',
-    'Liquid_feeding(titration)': '液体投料-滴定',
-    'liquid_feeding_beaker': '液体投料-烧杯',
-    'Drip_back': '液体回滴'
-}
-
-# 工作流步骤ID配置
-WORKFLOW_STEP_IDS = {
-    "reactor_taken_in": {
-        "config": "60a06f85-c5b3-29eb-180f-4f62dd7e2154"
-    },
-    "liquid_feeding_beaker": {
-        "liquid": "6808cda7-fee7-4092-97f0-5f9c2ffa60e3",
-        "observe": "1753c0de-dffc-4ee6-8458-805a2e227362"
-    },
-    "liquid_feeding_vials_non_titration": {
-        "liquid": "62ea6e95-3d5d-43db-bc1e-9a1802673861",
-        "observe": "3a167d99-6172-b67b-5f22-a7892197142e"
-    },
-    "liquid_feeding_solvents": {
-        "liquid": "1fcea355-2545-462b-b727-350b69a313bf",
-        "observe": "0553dfb3-9ac5-4ace-8e00-2f11029919a8"
-    },
-    "solid_feeding_vials": {
-        "feeding": "f7ae7448-4f20-4c1d-8096-df6fbadd787a",
-        "observe": "263c7ed5-7277-426b-bdff-d6fbf77bcc05"
-    },
-    "liquid_feeding_titration": {
-        "liquid": "a00ec41b-e666-4422-9c20-bfcd3cd15c54",
-        "observe": "ac738ff6-4c58-4155-87b1-d6f65a2c9ab5"
-    },
-    "drip_back": {
-        "liquid": "371be86a-ab77-4769-83e5-54580547c48a",
-        "observe": "ce024b9d-bd20-47b8-9f78-ca5ce7f44cf1"
-    }
-}
-
-# 工作流动作名称配置
-ACTION_NAMES = {
-    "reactor_taken_in": {
-        "config": "通量-配置",
-        "stirring": "反应模块-开始搅拌"
-    },
-    "solid_feeding_vials": {
-        "feeding": "粉末加样模块-投料",
-        "observe": "反应模块-观察搅拌结果"
-    },
-    "liquid_feeding_vials_non_titration": {
-        "liquid": "稀释液瓶加液位-液体投料",
-        "observe": "反应模块-滴定结果观察"
-    },
-    "liquid_feeding_solvents": {
-        "liquid": "试剂AB放置位-试剂吸液分液",
-        "observe": "反应模块-观察搅拌结果"
-    },
-    "liquid_feeding_titration": {
-        "liquid": "稀释液瓶加液位-稀释液吸液分液",
-        "observe": "反应模块-滴定结果观察"
-    },
-    "liquid_feeding_beaker": {
-        "liquid": "烧杯溶液放置位-烧杯吸液分液",
-        "observe": "反应模块-观察搅拌结果"
-    },
-    "drip_back": {
-        "liquid": "试剂AB放置位-试剂吸液分液",
-        "observe": "反应模块-向下滴定结果观察"
-    }
-}
-
-# ============================================================================
-# 仓库配置
-# ============================================================================
-# 说明:
-# - 出库和入库操作都需要UUID
-WAREHOUSE_MAPPING = {
-    # ========== 反应站仓库 ==========
-
-    # 堆栈1左 - 反应站左侧堆栈 (4行×4列=16个库位, A01～D04)
-    "堆栈1左": {
-        "uuid": "3a14aa17-0d49-dce4-486e-4b5c85c8b366",
-        "site_uuids": {
-            "A01": "3a14aa17-0d49-11d7-a6e1-f236b3e5e5a3",
-            "A02": "3a14aa17-0d49-4bc5-8836-517b75473f5f",
-            "A03": "3a14aa17-0d49-c2bc-6222-5cee8d2d94f8",
-            "A04": "3a14aa17-0d49-3ce2-8e9a-008c38d116fb",
-            "B01": "3a14aa17-0d49-f49c-6b66-b27f185a3b32",
-            "B02": "3a14aa17-0d49-cf46-df85-a979c9c9920c",
-            "B03": "3a14aa17-0d49-7698-4a23-f7ffb7d48ba3",
-            "B04": "3a14aa17-0d49-1231-99be-d5870e6478e9",
-            "C01": "3a14aa17-0d49-be34-6fae-4aed9d48b70b",
-            "C02": "3a14aa17-0d49-11d7-0897-34921dcf6b7c",
-            "C03": "3a14aa17-0d49-9840-0bd5-9c63c1bb2c29",
-            "C04": "3a14aa17-0d49-8335-3bff-01da69ea4911",
-            "D01": "3a14aa17-0d49-2bea-c8e5-2b32094935d5",
-            "D02": "3a14aa17-0d49-cff4-e9e8-5f5f0bc1ef32",
-            "D03": "3a14aa17-0d49-4948-cb0a-78f30d1ca9b8",
-            "D04": "3a14aa17-0d49-fd2f-9dfb-a29b11e84099",
-        },
-    },
-
-    # 堆栈1右 - 反应站右侧堆栈 (4行×4列=16个库位, A05～D08)
-    "堆栈1右": {
-        "uuid": "3a14aa17-0d49-dce4-486e-4b5c85c8b366",
-        "site_uuids": {
-            "A05": "3a14aa17-0d49-2c61-edc8-72a8ca7192dd",
-            "A06": "3a14aa17-0d49-60c8-2b00-40b17198f397",
-            "A07": "3a14aa17-0d49-ec5b-0b75-634dce8eed25",
-            "A08": "3a14aa17-0d49-3ec9-55b3-f3189c4ec53d",
-            "B05": "3a14aa17-0d49-6a4e-abcf-4c113eaaeaad",
-            "B06": "3a14aa17-0d49-e3f6-2dd6-28c2e8194fbe",
-            "B07": "3a14aa17-0d49-11a6-b861-ee895121bf52",
-            "B08": "3a14aa17-0d49-9c7d-1145-d554a6e482f0",
-            "C05": "3a14aa17-0d49-45c4-7a34-5105bc3e2368",
-            "C06": "3a14aa17-0d49-867e-39ab-31b3fe9014be",
-            "C07": "3a14aa17-0d49-ec56-c4b4-39fd9b2131e7",
-            "C08": "3a14aa17-0d49-1128-d7d9-ffb1231c98c0",
-            "D05": "3a14aa17-0d49-e843-f961-ea173326a14b",
-            "D06": "3a14aa17-0d49-4d26-a985-f188359c4f8b",
-            "D07": "3a14aa17-0d49-223a-b520-bc092bb42fe0",
-            "D08": "3a14aa17-0d49-4fa3-401a-6a444e1cca22",
-        },
-    },
-
-    # 站内试剂存放堆栈
-    "站内试剂存放堆栈": {
-        "uuid": "3a14aa3b-9fab-9d8e-d1a7-828f01f51f0c",
-        "site_uuids": {
-            "A01": "3a14aa3b-9fab-adac-7b9c-e1ee446b51d5",
-            "A02": "3a14aa3b-9fab-ca72-febc-b7c304476c78"
-        }
-    },
-
-
-    # 测量小瓶仓库（测密度）
-    "测量小瓶仓库": {
-        "uuid": "3a15012f-705b-c0de-3f9e-950c205f9921",
-        "site_uuids": {
-            "A01": "3a15012f-705e-0524-3161-c523b5aebc97",
-            "A02": "3a15012f-705e-7cd1-32ab-ad4fd1ab75c8",
-            "A03": "3a15012f-705e-a5d6-edac-bdbfec236260",
-            "B01": "3a15012f-705e-e0ee-80e0-10a6b3fc500d",
-            "B02": "3a15012f-705e-e499-180d-de06d60d0b21",
-            "B03": "3a15012f-705e-eff6-63f1-09f742096b26"
-        }
-    },
-
-    # 站内Tip盒堆栈 - 用于存放枪头盒 (耗材)
-    "站内Tip盒堆栈": {
-        "uuid": "3a14aa3a-2d3c-b5c1-9ddf-7c4a957d459a",
-        "site_uuids": {
-            "A01": "3a14aa3a-2d3d-e700-411a-0ddf85e1f18a",
-            "A02": "3a14aa3a-2d3d-a7ce-099a-d5632fdafa24",
-            "A03": "3a14aa3a-2d3d-bdf6-a702-c60b38b08501",
-            "B01": "3a14aa3a-2d3d-d704-f076-2a8d5bc72cb8",
-            "B02": "3a14aa3a-2d3d-c350-2526-0778d173a5ac",
-            "B03": "3a14aa3a-2d3d-bc38-b356-f0de2e44e0c7"
-        }
-    },
-    # ========== 配液站仓库 ==========
-    "粉末堆栈": {
-        "uuid": "3a14198e-6928-121f-7ca6-88ad3ae7e6a0",
-        "site_uuids": {
-            "A01": "3a14198e-6929-31f0-8a22-0f98f72260df",
-            "A02": "3a14198e-6929-4379-affa-9a2935c17f99",
-            "A03": "3a14198e-6929-56da-9a1c-7f5fbd4ae8af",
-            "A04": "3a14198e-6929-5e99-2b79-80720f7cfb54",
-            "B01": "3a14198e-6929-f525-9a1b-1857552b28ee",
-            "B02": "3a14198e-6929-bf98-0fd5-26e1d68bf62d",
-            "B03": "3a14198e-6929-2d86-a468-602175a2b5aa",
-            "B04": "3a14198e-6929-1a98-ae57-e97660c489ad",
-            "C01": "3a14198e-6929-46fe-841e-03dd753f1e4a",
-            "C02": "3a14198e-6929-72ac-32ce-9b50245682b8",
-            "C03": "3a14198e-6929-8a0b-b686-6f4a2955c4e2",
-            "C04": "3a14198e-6929-a0ec-5f15-c0f9f339f963",
-            "D01": "3a14198e-6929-1bc9-a9bd-3b7ca66e7f95",
-            "D02": "3a14198e-6929-3bd8-e6c7-4a9fd93be118",
-            "D03": "3a14198e-6929-dde1-fc78-34a84b71afdf",
-            "D04": "3a14198e-6929-7ac8-915a-fea51cb2e884"
-        }
-    },
-    "溶液堆栈": {
-        "uuid": "3a14198e-d723-2c13-7d12-50143e190a23",
-        "site_uuids": {
-            "A01": "3a14198e-d724-e036-afdc-2ae39a7f3383",
-            "A02": "3a14198e-d724-d818-6d4f-5725191a24b5",
-            "A03": "3a14198e-d724-b5bb-adf3-4c5a0da6fb31",
-            "A04": "3a14198e-d724-d378-d266-2508a224a19f",
-            "B01": "3a14198e-d724-afa4-fc82-0ac8a9016791",
-            "B02": "3a14198e-d724-be8a-5e0b-012675e195c6",
-            "B03": "3a14198e-d724-ab4e-48cb-817c3c146707",
-            "B04": "3a14198e-d724-f56e-468b-0110a8feb36a",
-            "C01": "3a14198e-d724-ca48-bb9e-7e85751e55b6",
-            "C02": "3a14198e-d724-cc1e-5c2c-228a130f40a8",
-            "C03": "3a14198e-d724-7f18-1853-39d0c62e1d33",
-            "C04": "3a14198e-d724-0cf1-dea9-a1f40fe7e13c",
-            "D01": "3a14198e-d724-df6d-5e32-5483b3cab583",
-            "D02": "3a14198e-d724-1e28-c885-574c3df468d0",
-            "D03": "3a14198e-d724-28a2-a760-baa896f46b66",
-            "D04": "3a14198e-d724-0ddd-9654-f9352a421de9"
-        }
-    },
-    "试剂堆栈": {
-        "uuid": "3a14198c-c2cc-0290-e086-44a428fba248",
-        "site_uuids": {
-            "A01": "3a14198c-c2cf-8b40-af28-b467808f1c36",  # x=1, y=1, code=0001-0001
-            "A02": "3a14198c-c2d0-dc7d-b8d0-e1d88cee3094",  # x=1, y=2, code=0001-0002
-            "A03": "3a14198c-c2d0-354f-39ad-642e1a72fcb8",  # x=1, y=3, code=0001-0003
-            "A04": "3a14198c-c2d0-725e-523d-34c037ac2440",  # x=1, y=4, code=0001-0004
-            "B01": "3a14198c-c2d0-f3e7-871a-e470d144296f",  # x=2, y=1, code=0001-0005
-            "B02": "3a14198c-c2d0-2070-efc8-44e245f10c6f",  # x=2, y=2, code=0001-0006
-            "B03": "3a14198c-c2d0-1559-105d-0ea30682cab4",  # x=2, y=3, code=0001-0007
-            "B04": "3a14198c-c2d0-efce-0939-69ca5a7dfd39"   # x=2, y=4, code=0001-0008
-        }
-    }
-}
-
-# ============================================================================
-# 物料类型配置
-# ============================================================================
-# 说明:
-# - 格式: PyLabRobot资源类型名称 → Bioyond系统typeId的UUID
-# - 这个映射基于 resource.model 属性 (不是显示名称!)
-# - UUID为空表示该类型暂未在Bioyond系统中定义
-MATERIAL_TYPE_MAPPINGS = {
-    # ================================================配液站资源============================================================
-    # ==================================================样品===============================================================
-    "BIOYOND_PolymerStation_1FlaskCarrier": ("烧杯", "3a14196b-24f2-ca49-9081-0cab8021bf1a"),  # 配液站-样品-烧杯
-    "BIOYOND_PolymerStation_1BottleCarrier": ("试剂瓶", "3a14196b-8bcf-a460-4f74-23f21ca79e72"),  # 配液站-样品-试剂瓶
-    "BIOYOND_PolymerStation_6StockCarrier": ("分装板", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"),  # 配液站-样品-分装板
-    "BIOYOND_PolymerStation_Liquid_Vial": ("10%分装小瓶", "3a14196c-76be-2279-4e22-7310d69aed68"),  # 配液站-样品-分装板-第一排小瓶
-    "BIOYOND_PolymerStation_Solid_Vial": ("90%分装小瓶", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"),  # 配液站-样品-分装板-第二排小瓶
-    # ==================================================试剂===============================================================
-    "BIOYOND_PolymerStation_8StockCarrier": ("样品板", "3a14196e-b7a0-a5da-1931-35f3000281e9"),  # 配液站-试剂-样品板（8孔）
-    "BIOYOND_PolymerStation_Solid_Stock": ("样品瓶", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"),  # 配液站-试剂-样品板-样品瓶
-
-}
-
-# ============================================================================
-# 动态生成的库位UUID映射（从WAREHOUSE_MAPPING中提取）
-# ============================================================================
-
-LOCATION_MAPPING = {}
-for warehouse_name, warehouse_config in WAREHOUSE_MAPPING.items():
-    if "site_uuids" in warehouse_config:
-        LOCATION_MAPPING.update(warehouse_config["site_uuids"])
-
-# ============================================================================
-# 物料默认参数配置
-# ============================================================================
-# 说明:
-# - 为特定物料名称自动添加默认参数（如密度、分子量、单位等）
-# - 格式: 物料名称 → {参数字典}
-# - 在创建或更新物料时，会自动合并这些参数到 Parameters 字段
-# - unit: 物料的计量单位（会用于 unit 字段）
-# - density/densityUnit: 密度信息（会添加到 Parameters 中）
-
-MATERIAL_DEFAULT_PARAMETERS = {
-    # 溶剂类
-    "NMP": {
-        "unit": "毫升",
-        "density": "1.03",
-        "densityUnit": "g/mL",
-        "description": "N-甲基吡咯烷酮 (N-Methyl-2-pyrrolidone)"
-    },
-    # 可以继续添加其他物料...
-}
-
-# ============================================================================
-# 物料类型默认参数配置
-# ============================================================================
-# 说明:
-# - 为特定物料类型（UUID）自动添加默认参数
-# - 格式: Bioyond类型UUID → {参数字典}
-# - 优先级低于按名称匹配的配置
-MATERIAL_TYPE_PARAMETERS = {
-    # 示例:
-    # "3a14196b-24f2-ca49-9081-0cab8021bf1a": {  # 烧杯
-    #     "unit": "个"
-    # }
-}
--- a/unilabos/devices/workstation/bioyond_studio/dispensing_station/dispensing_station.py
+++ b/unilabos/devices/workstation/bioyond_studio/dispensing_station/dispensing_station.py
@@ -4,8 +4,7 @@ import time
 from typing import Optional, Dict, Any, List
 from typing_extensions import TypedDict
 import requests
-import pint
-
+from unilabos.devices.workstation.bioyond_studio.config import API_CONFIG

 from unilabos.devices.workstation.bioyond_studio.bioyond_rpc import BioyondException
 from unilabos.devices.workstation.bioyond_studio.station import BioyondWorkstation
@@ -26,89 +25,13 @@ class ComputeExperimentDesignReturn(TypedDict):
 class BioyondDispensingStation(BioyondWorkstation):
    def __init__(
        self,
-        config: dict = None,
-        deck=None,
-        protocol_type=None,
+        config,
+            # 桌子
+        deck,
+        *args,
        **kwargs,
-    ):
-        """初始化配液站
-
-        Args:
-            config: 配置字典,应包含material_type_mappings等配置
-            deck: Deck对象
-            protocol_type: 协议类型(由ROS系统传递,此处忽略)
-            **kwargs: 其他可能的参数
-        """
-        if config is None:
-            config = {}
-
-        # 将 kwargs 合并到 config 中 (处理扁平化配置如 api_key)
-        config.update(kwargs)
-
-        if deck is None and config:
-            deck = config.get('deck')
-
-        # 🔧 修复: 确保 Deck 上的 warehouses 具有正确的 UUID (必须在 super().__init__ 之前执行，因为父类会触发同步)
-        # 从配置中读取 warehouse_mapping，并应用到实际的 deck 资源上
-        if config and "warehouse_mapping" in config and deck:
-            warehouse_mapping = config["warehouse_mapping"]
-            print(f"正在根据配置更新 Deck warehouse UUIDs... (共有 {len(warehouse_mapping)} 个配置)")
-
-            user_deck = deck
-            # 初始化 warehouses 字典
-            if not hasattr(user_deck, "warehouses") or user_deck.warehouses is None:
-                user_deck.warehouses = {}
-
-            # 1. 尝试从 children 中查找匹配的资源
-            for child in user_deck.children:
-                # 简单判断: 如果名字在 mapping 中，就认为是 warehouse
-                if child.name in warehouse_mapping:
-                    user_deck.warehouses[child.name] = child
-                    print(f"  - 从子资源中找到 warehouse: {child.name}")
-
-            # 2. 如果还是没找到，且 Deck 类有 setup 方法，尝试调用 setup (针对 Deck 对象正确但未初始化的情况)
-            if not user_deck.warehouses and hasattr(user_deck, "setup"):
-                print("  - 尝试调用 deck.setup() 初始化仓库...")
-                try:
-                    user_deck.setup()
-                    # setup 后重新检查
-                    if hasattr(user_deck, "warehouses") and user_deck.warehouses:
-                            print(f"  - setup() 成功，找到 {len(user_deck.warehouses)} 个仓库")
-                except Exception as e:
-                    print(f"  - 调用 setup() 失败: {e}")
-
-            # 3. 如果仍然为空，可能需要手动创建 (仅针对特定已知的 Deck 类型进行补救，这里暂时只打印警告)
-            if not user_deck.warehouses:
-                    print("  - ⚠️ 仍然无法找到任何 warehouse 资源！")
-
-            for wh_name, wh_config in warehouse_mapping.items():
-                target_uuid = wh_config.get("uuid")
-
-                # 尝试在 deck.warehouses 中查找
-                wh_resource = None
-                if hasattr(user_deck, "warehouses") and wh_name in user_deck.warehouses:
-                    wh_resource = user_deck.warehouses[wh_name]
-
-                # 如果没找到，尝试在所有子资源中查找
-                if not wh_resource:
-                    wh_resource = user_deck.get_resource(wh_name)
-
-                if wh_resource:
-                    if target_uuid:
-                        current_uuid = getattr(wh_resource, "uuid", None)
-                        print(f"✅ 更新仓库 '{wh_name}' UUID: {current_uuid} -> {target_uuid}")
-
-                        # 动态添加 uuid 属性
-                        wh_resource.uuid = target_uuid
-                        # 同时也确保 category 正确，避免 graphio 识别错误
-                        # wh_resource.category = "warehouse"
-                    else:
-                            print(f"⚠️ 仓库 '{wh_name}' 在配置中没有 UUID")
-                else:
-                    print(f"❌ 在 Deck 中未找到配置的仓库: '{wh_name}'")
-
-        super().__init__(bioyond_config=config, deck=deck)
-
+        ):
+        super().__init__(config, deck, *args, **kwargs)
        # self.config = config
        # self.api_key = config["api_key"]
        # self.host = config["api_host"]
@@ -120,41 +43,6 @@ class BioyondDispensingStation(BioyondWorkstation):
        # 用于跟踪任务完成状态的字典: {orderCode: {status, order_id, timestamp}}
        self.order_completion_status = {}

-        # 初始化 pint 单位注册表
-        self.ureg = pint.UnitRegistry()
-
-        # 化合物信息
-        self.compound_info = {
-            "MolWt": {
-                "MDA": 108.14 * self.ureg.g / self.ureg.mol,
-                "TDA": 122.16 * self.ureg.g / self.ureg.mol,
-                "PAPP": 521.62 * self.ureg.g / self.ureg.mol,
-                "BTDA": 322.23 * self.ureg.g / self.ureg.mol,
-                "BPDA": 294.22 * self.ureg.g / self.ureg.mol,
-                "6FAP": 366.26 * self.ureg.g / self.ureg.mol,
-                "PMDA": 218.12 * self.ureg.g / self.ureg.mol,
-                "MPDA": 108.14 * self.ureg.g / self.ureg.mol,
-                "SIDA": 248.51 * self.ureg.g / self.ureg.mol,
-                "ODA": 200.236 * self.ureg.g / self.ureg.mol,
-                "4,4'-ODA": 200.236 * self.ureg.g / self.ureg.mol,
-                "134": 292.34 * self.ureg.g / self.ureg.mol,
-            },
-            "FuncGroup": {
-                "MDA": "Amine",
-                "TDA": "Amine",
-                "PAPP": "Amine",
-                "BTDA": "Anhydride",
-                "BPDA": "Anhydride",
-                "6FAP": "Amine",
-                "MPDA": "Amine",
-                "SIDA": "Amine",
-                "PMDA": "Anhydride",
-                "ODA": "Amine",
-                "4,4'-ODA": "Amine",
-                "134": "Amine",
-            }
-        }
-
    def _post_project_api(self, endpoint: str, data: Any) -> Dict[str, Any]:
        """项目接口通用POST调用

@@ -166,7 +54,7 @@ class BioyondDispensingStation(BioyondWorkstation):
            dict: 服务端响应，失败时返回 {code:0,message,...}
        """
        request_data = {
-            "apiKey": self.bioyond_config["api_key"],
+            "apiKey": API_CONFIG["api_key"],
            "requestTime": self.hardware_interface.get_current_time_iso8601(),
            "data": data
        }
@@ -197,7 +85,7 @@ class BioyondDispensingStation(BioyondWorkstation):
            dict: 服务端响应，失败时返回 {code:0,message,...}
        """
        request_data = {
-            "apiKey": self.bioyond_config["api_key"],
+            "apiKey": API_CONFIG["api_key"],
            "requestTime": self.hardware_interface.get_current_time_iso8601(),
            "data": data
        }
@@ -230,22 +118,20 @@ class BioyondDispensingStation(BioyondWorkstation):
                    ratio = json.loads(ratio)
                except Exception:
                    ratio = {}
+            root = str(Path(__file__).resolve().parents[3])
+            if root not in sys.path:
+                sys.path.append(root)
+            try:
+                mod = importlib.import_module("tem.compute")
+            except Exception as e:
+                raise BioyondException(f"无法导入计算模块: {e}")
            try:
                wp = float(wt_percent) if isinstance(wt_percent, str) else wt_percent
                mt = float(m_tot) if isinstance(m_tot, str) else m_tot
                tp = float(titration_percent) if isinstance(titration_percent, str) else titration_percent
            except Exception as e:
                raise BioyondException(f"参数解析失败: {e}")
-
-            # 2. 调用内部计算方法
-            res = self._generate_experiment_design(
-                ratio=ratio,
-                wt_percent=wp,
-                m_tot=mt,
-                titration_percent=tp
-            )
-
-            # 3. 构造返回结果
+            res = mod.generate_experiment_design(ratio=ratio, wt_percent=wp, m_tot=mt, titration_percent=tp)
            out = {
                "solutions": res.get("solutions", []),
                "titration": res.get("titration", {}),
@@ -254,248 +140,11 @@ class BioyondDispensingStation(BioyondWorkstation):
                "return_info": json.dumps(res, ensure_ascii=False)
            }
            return out
-
        except BioyondException:
            raise
        except Exception as e:
            raise BioyondException(str(e))

-    def _generate_experiment_design(
-        self,
-        ratio: dict,
-        wt_percent: float = 0.25,
-        m_tot: float = 70,
-        titration_percent: float = 0.03,
-    ) -> dict:
-        """内部方法：生成实验设计
-
-        根据FuncGroup自动区分二胺和二酐，每种二胺单独配溶液，严格按照ratio顺序投料。
-
-        参数:
-            ratio: 化合物配比字典，格式: {"compound_name": ratio_value}
-            wt_percent: 固体重量百分比
-            m_tot: 反应混合物总质量(g)
-            titration_percent: 滴定溶液百分比
-
-        返回:
-            包含实验设计详细参数的字典
-        """
-        # 溶剂密度
-        ρ_solvent = 1.03 * self.ureg.g / self.ureg.ml
-        # 二酐溶解度
-        solubility = 0.02 * self.ureg.g / self.ureg.ml
-        # 投入固体时最小溶剂体积
-        V_min = 30 * self.ureg.ml
-        m_tot = m_tot * self.ureg.g
-
-        # 保持ratio中的顺序
-        compound_names = list(ratio.keys())
-        compound_ratios = list(ratio.values())
-
-        # 验证所有化合物是否在 compound_info 中定义
-        undefined_compounds = [name for name in compound_names if name not in self.compound_info["MolWt"]]
-        if undefined_compounds:
-            available = list(self.compound_info["MolWt"].keys())
-            raise ValueError(
-                f"以下化合物未在 compound_info 中定义: {undefined_compounds}。"
-                f"可用的化合物: {available}"
-            )
-
-        # 获取各化合物的分子量和官能团类型
-        molecular_weights = [self.compound_info["MolWt"][name] for name in compound_names]
-        func_groups = [self.compound_info["FuncGroup"][name] for name in compound_names]
-
-        # 记录化合物信息用于调试
-        self.hardware_interface._logger.info(f"化合物名称: {compound_names}")
-        self.hardware_interface._logger.info(f"官能团类型: {func_groups}")
-
-        # 按原始顺序分离二胺和二酐
-        ordered_compounds = list(zip(compound_names, compound_ratios, molecular_weights, func_groups))
-        diamine_compounds = [(name, ratio_val, mw, i) for i, (name, ratio_val, mw, fg) in enumerate(ordered_compounds) if fg == "Amine"]
-        anhydride_compounds = [(name, ratio_val, mw, i) for i, (name, ratio_val, mw, fg) in enumerate(ordered_compounds) if fg == "Anhydride"]
-
-        if not diamine_compounds or not anhydride_compounds:
-            raise ValueError(
-                f"需要同时包含二胺(Amine)和二酐(Anhydride)化合物。"
-                f"当前二胺: {[c[0] for c in diamine_compounds]}, "
-                f"当前二酐: {[c[0] for c in anhydride_compounds]}"
-            )
-
-        # 计算加权平均分子量 (基于摩尔比)
-        total_molar_ratio = sum(compound_ratios)
-        weighted_molecular_weight = sum(ratio_val * mw for ratio_val, mw in zip(compound_ratios, molecular_weights))
-
-        # 取最后一个二酐用于滴定
-        titration_anhydride = anhydride_compounds[-1]
-        solid_anhydrides = anhydride_compounds[:-1] if len(anhydride_compounds) > 1 else []
-
-        # 二胺溶液配制参数 - 每种二胺单独配制
-        diamine_solutions = []
-        total_diamine_volume = 0 * self.ureg.ml
-
-        # 计算反应物的总摩尔量
-        n_reactant = m_tot * wt_percent / weighted_molecular_weight
-
-        for name, ratio_val, mw, order_index in diamine_compounds:
-            # 跳过 SIDA
-            if name == "SIDA":
-                continue
-
-            # 计算该二胺需要的摩尔数
-            n_diamine_needed = n_reactant * ratio_val
-
-            # 二胺溶液配制参数 (每种二胺固定配制参数)
-            m_diamine_solid = 5.0 * self.ureg.g  # 每种二胺固体质量
-            V_solvent_for_this = 20 * self.ureg.ml  # 每种二胺溶剂体积
-            m_solvent_for_this = ρ_solvent * V_solvent_for_this
-
-            # 计算该二胺溶液的浓度
-            c_diamine = (m_diamine_solid / mw) / V_solvent_for_this
-
-            # 计算需要移取的溶液体积
-            V_diamine_needed = n_diamine_needed / c_diamine
-
-            diamine_solutions.append({
-                "name": name,
-                "order": order_index,
-                "solid_mass": m_diamine_solid.magnitude,
-                "solvent_volume": V_solvent_for_this.magnitude,
-                "concentration": c_diamine.magnitude,
-                "volume_needed": V_diamine_needed.magnitude,
-                "molar_ratio": ratio_val
-            })
-
-            total_diamine_volume += V_diamine_needed
-
-        # 按原始顺序排序
-        diamine_solutions.sort(key=lambda x: x["order"])
-
-        # 计算滴定二酐的质量
-        titration_name, titration_ratio, titration_mw, _ = titration_anhydride
-        m_titration_anhydride = n_reactant * titration_ratio * titration_mw
-        m_titration_90 = m_titration_anhydride * (1 - titration_percent)
-        m_titration_10 = m_titration_anhydride * titration_percent
-
-        # 计算其他固体二酐的质量 (按顺序)
-        solid_anhydride_masses = []
-        for name, ratio_val, mw, order_index in solid_anhydrides:
-            mass = n_reactant * ratio_val * mw
-            solid_anhydride_masses.append({
-                "name": name,
-                "order": order_index,
-                "mass": mass.magnitude,
-                "molar_ratio": ratio_val
-            })
-
-        # 按原始顺序排序
-        solid_anhydride_masses.sort(key=lambda x: x["order"])
-
-        # 计算溶剂用量
-        total_diamine_solution_mass = sum(
-            sol["volume_needed"] * ρ_solvent for sol in diamine_solutions
-        ) * self.ureg.ml
-
-        # 预估滴定溶剂量、计算补加溶剂量
-        m_solvent_titration = m_titration_10 / solubility * ρ_solvent
-        m_solvent_add = m_tot * (1 - wt_percent) - total_diamine_solution_mass - m_solvent_titration
-
-        # 检查最小溶剂体积要求
-        total_liquid_volume = (total_diamine_solution_mass + m_solvent_add) / ρ_solvent
-        m_tot_min = V_min / total_liquid_volume * m_tot
-
-        # 如果需要，按比例放大
-        scale_factor = 1.0
-        if m_tot_min > m_tot:
-            scale_factor = (m_tot_min / m_tot).magnitude
-            m_titration_90 *= scale_factor
-            m_titration_10 *= scale_factor
-            m_solvent_add *= scale_factor
-            m_solvent_titration *= scale_factor
-
-            # 更新二胺溶液用量
-            for sol in diamine_solutions:
-                sol["volume_needed"] *= scale_factor
-
-            # 更新固体二酐用量
-            for anhydride in solid_anhydride_masses:
-                anhydride["mass"] *= scale_factor
-
-            m_tot = m_tot_min
-
-        # 生成投料顺序
-        feeding_order = []
-
-        # 1. 固体二酐 (按顺序)
-        for anhydride in solid_anhydride_masses:
-            feeding_order.append({
-                "step": len(feeding_order) + 1,
-                "type": "solid_anhydride",
-                "name": anhydride["name"],
-                "amount": anhydride["mass"],
-                "order": anhydride["order"]
-            })
-
-        # 2. 二胺溶液 (按顺序)
-        for sol in diamine_solutions:
-            feeding_order.append({
-                "step": len(feeding_order) + 1,
-                "type": "diamine_solution",
-                "name": sol["name"],
-                "amount": sol["volume_needed"],
-                "order": sol["order"]
-            })
-
-        # 3. 主要二酐粉末
-        feeding_order.append({
-            "step": len(feeding_order) + 1,
-            "type": "main_anhydride",
-            "name": titration_name,
-            "amount": m_titration_90.magnitude,
-            "order": titration_anhydride[3]
-        })
-
-        # 4. 补加溶剂
-        if m_solvent_add > 0:
-            feeding_order.append({
-                "step": len(feeding_order) + 1,
-                "type": "additional_solvent",
-                "name": "溶剂",
-                "amount": m_solvent_add.magnitude,
-                "order": 999
-            })
-
-        # 5. 滴定二酐溶液
-        feeding_order.append({
-            "step": len(feeding_order) + 1,
-            "type": "titration_anhydride",
-            "name": f"{titration_name} 滴定液",
-            "amount": m_titration_10.magnitude,
-            "titration_solvent": m_solvent_titration.magnitude,
-            "order": titration_anhydride[3]
-        })
-
-        # 返回实验设计结果
-        results = {
-            "total_mass": m_tot.magnitude,
-            "scale_factor": scale_factor,
-            "solutions": diamine_solutions,
-            "solids": solid_anhydride_masses,
-            "titration": {
-                "name": titration_name,
-                "main_portion": m_titration_90.magnitude,
-                "titration_portion": m_titration_10.magnitude,
-                "titration_solvent": m_solvent_titration.magnitude,
-            },
-            "solvents": {
-                "additional_solvent": m_solvent_add.magnitude,
-                "total_liquid_volume": total_liquid_volume.magnitude
-            },
-            "feeding_order": feeding_order,
-            "minimum_required_mass": m_tot_min.magnitude
-        }
-
-        return results
-
    # 90%10%小瓶投料任务创建方法
    def create_90_10_vial_feeding_task(self,
                                       order_name: str = None,
@@ -1312,108 +961,6 @@ class BioyondDispensingStation(BioyondWorkstation):
            'actualVolume': actual_volume
        }

-    def _simplify_report(self, report) -> Dict[str, Any]:
-        """简化实验报告，只保留关键信息，去除冗余的工作流参数"""
-        if not isinstance(report, dict):
-            return report
-
-        data = report.get('data', {})
-        if not isinstance(data, dict):
-            return report
-
-        # 提取关键信息
-        simplified = {
-            'name': data.get('name'),
-            'code': data.get('code'),
-            'requester': data.get('requester'),
-            'workflowName': data.get('workflowName'),
-            'workflowStep': data.get('workflowStep'),
-            'requestTime': data.get('requestTime'),
-            'startPreparationTime': data.get('startPreparationTime'),
-            'completeTime': data.get('completeTime'),
-            'useTime': data.get('useTime'),
-            'status': data.get('status'),
-            'statusName': data.get('statusName'),
-        }
-
-        # 提取物料信息（简化版）
-        pre_intakes = data.get('preIntakes', [])
-        if pre_intakes and isinstance(pre_intakes, list):
-            first_intake = pre_intakes[0]
-            sample_materials = first_intake.get('sampleMaterials', [])
-
-            # 简化物料信息
-            simplified_materials = []
-            for material in sample_materials:
-                if isinstance(material, dict):
-                    mat_info = {
-                        'materialName': material.get('materialName'),
-                        'materialTypeName': material.get('materialTypeName'),
-                        'materialCode': material.get('materialCode'),
-                        'materialLocation': material.get('materialLocation'),
-                    }
-
-                    # 解析parameters中的关键信息（如密度、加料历史等）
-                    params_str = material.get('parameters', '{}')
-                    try:
-                        params = json.loads(params_str) if isinstance(params_str, str) else params_str
-                        if isinstance(params, dict):
-                            # 只保留关键参数
-                            if 'density' in params:
-                                mat_info['density'] = params['density']
-                            if 'feedingHistory' in params:
-                                mat_info['feedingHistory'] = params['feedingHistory']
-                            if 'liquidVolume' in params:
-                                mat_info['liquidVolume'] = params['liquidVolume']
-                            if 'm_diamine_tot' in params:
-                                mat_info['m_diamine_tot'] = params['m_diamine_tot']
-                            if 'wt_diamine' in params:
-                                mat_info['wt_diamine'] = params['wt_diamine']
-                    except:
-                        pass
-
-                    simplified_materials.append(mat_info)
-
-            simplified['sampleMaterials'] = simplified_materials
-
-            # 提取extraProperties中的实际值
-            extra_props = first_intake.get('extraProperties', {})
-            if isinstance(extra_props, dict):
-                simplified_extra = {}
-                for key, value in extra_props.items():
-                    try:
-                        parsed_value = json.loads(value) if isinstance(value, str) else value
-                        simplified_extra[key] = parsed_value
-                    except:
-                        simplified_extra[key] = value
-                simplified['extraProperties'] = simplified_extra
-
-        return {
-            'data': simplified,
-            'code': report.get('code'),
-            'message': report.get('message'),
-            'timestamp': report.get('timestamp')
-        }
-
-    def scheduler_start(self) -> dict:
-        """启动调度器 - 启动Bioyond工作站的任务调度器，开始执行队列中的任务
-
-        Returns:
-            dict: 包含return_info的字典，return_info为整型(1=成功)
-
-        Raises:
-            BioyondException: 调度器启动失败时抛出异常
-        """
-        result = self.hardware_interface.scheduler_start()
-        self.hardware_interface._logger.info(f"调度器启动结果: {result}")
-
-        if result != 1:
-            error_msg = "启动调度器失败: 有未处理错误，调度无法启动。请检查Bioyond系统状态。"
-            self.hardware_interface._logger.error(error_msg)
-            raise BioyondException(error_msg)
-
-        return {"return_info": result}
-
    # 等待多个任务完成并获取实验报告
    def wait_for_multiple_orders_and_get_reports(self,
                                                  batch_create_result: str = None,
@@ -1455,12 +1002,7 @@ class BioyondDispensingStation(BioyondWorkstation):

            # 验证batch_create_result参数
            if not batch_create_result or batch_create_result == "":
-                raise BioyondException(
-                    "batch_create_result参数为空，请确保:\n"
-                    "1. batch_create节点与wait节点之间正确连接了handle\n"
-                    "2. batch_create节点成功执行并返回了结果\n"
-                    "3. 检查上游batch_create任务是否成功创建了订单"
-                )
+                raise BioyondException("batch_create_result参数为空，请确保从batch_create节点正确连接handle")

            # 解析batch_create_result JSON对象
            try:
@@ -1489,17 +1031,7 @@ class BioyondDispensingStation(BioyondWorkstation):

            # 验证提取的数据
            if not order_codes:
-                self.hardware_interface._logger.error(
-                    f"batch_create任务未生成任何订单。batch_create_result内容: {batch_create_result}"
-                )
-                raise BioyondException(
-                    "batch_create_result中未找到order_codes或为空。\n"
-                    "可能的原因:\n"
-                    "1. batch_create任务执行失败（检查任务是否报错）\n"
-                    "2. 物料配置问题（如'物料样品板分配失败'）\n"
-                    "3. Bioyond系统状态异常\n"
-                    f"请检查batch_create任务的执行结果"
-                )
+                raise BioyondException("batch_create_result中未找到order_codes字段或为空")
            if not order_ids:
                raise BioyondException("batch_create_result中未找到order_ids字段或为空")

@@ -1582,8 +1114,6 @@ class BioyondDispensingStation(BioyondWorkstation):
                                self.hardware_interface._logger.info(
                                    f"成功获取任务 {order_code} 的实验报告"
                                )
-                                # 简化报告，去除冗余信息
-                                report = self._simplify_report(report)

                            reports.append({
                                "order_code": order_code,
@@ -1758,7 +1288,7 @@ class BioyondDispensingStation(BioyondWorkstation):
                f"开始执行批量物料转移: {len(transfer_groups)}组任务 -> {target_device_id}"
            )

-            warehouse_mapping = self.bioyond_config.get("warehouse_mapping", {})
+            from .config import WAREHOUSE_MAPPING
            results = []
            successful_count = 0
            failed_count = 0
--- a/unilabos/devices/workstation/bioyond_studio/dispensing_station/init.py
+++ b/unilabos/devices/workstation/bioyond_studio/dispensing_station/init.py
--- a/unilabos/devices/workstation/bioyond_studio/reaction_station/reaction_station.py
+++ b/unilabos/devices/workstation/bioyond_studio/reaction_station/reaction_station.py
--- a/unilabos/devices/workstation/bioyond_studio/reaction_station/init.py
+++ b/unilabos/devices/workstation/bioyond_studio/reaction_station/init.py
--- a/unilabos/devices/workstation/bioyond_studio/station.py
+++ b/unilabos/devices/workstation/bioyond_studio/station.py
@@ -6,7 +6,6 @@ Bioyond Workstation Implementation
 """
 import time
 import traceback
-import threading
 from datetime import datetime
 from typing import Dict, Any, List, Optional, Union
 import json
@@ -28,90 +27,6 @@ from pylabrobot.resources.resource import Resource as ResourcePLR
 from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService


-class ConnectionMonitor:
-    """Bioyond连接监控器"""
-    def __init__(self, workstation, check_interval=30):
-        self.workstation = workstation
-        self.check_interval = check_interval
-        self._running = False
-        self._thread = None
-        self._last_status = "unknown"
-
-    def start(self):
-        if self._running:
-            return
-        self._running = True
-        self._thread = threading.Thread(target=self._monitor_loop, daemon=True, name="BioyondConnectionMonitor")
-        self._thread.start()
-        logger.info("Bioyond连接监控器已启动")
-
-    def stop(self):
-        self._running = False
-        if self._thread:
-            self._thread.join(timeout=2)
-            logger.info("Bioyond连接监控器已停止")
-
-    def _monitor_loop(self):
-        while self._running:
-            try:
-                # 使用 lightweight API 检查连接
-                # query_matial_type_list 是比较快的查询
-                start_time = time.time()
-                result = self.workstation.hardware_interface.material_type_list()
-
-                status = "online" if result else "offline"
-                msg = "Connection established" if status == "online" else "Failed to get material type list"
-
-                if status != self._last_status:
-                    logger.info(f"Bioyond连接状态变更: {self._last_status} -> {status}")
-                    self._publish_event(status, msg)
-                    self._last_status = status
-
-                # 发布心跳 (可选，或者只在状态变更时发布)
-                # self._publish_event(status, msg)
-
-            except Exception as e:
-                logger.error(f"Bioyond连接检查异常: {e}")
-                if self._last_status != "error":
-                    self._publish_event("error", str(e))
-                    self._last_status = "error"
-
-            time.sleep(self.check_interval)
-
-    def _publish_event(self, status, message):
-        try:
-            if hasattr(self.workstation, "_ros_node") and self.workstation._ros_node:
-                event_data = {
-                    "status": status,
-                    "message": message,
-                    "timestamp": datetime.now().isoformat()
-                }
-
-                # 动态发布消息，需要在 ROS2DeviceNode 中有对应支持
-                # 这里假设通用事件发布机制，使用 String 类型的 topic
-                # 话题: /<namespace>/events/device_status
-                ns = self.workstation._ros_node.namespace
-                topic = f"{ns}/events/device_status"
-
-                # 使用 ROS2DeviceNode 的发布功能
-                # 如果没有预定义的 publisher，需要动态创建
-                # 注意：workstation base node 可能没有自动创建 arbitrary publishers 的机制
-                # 这里我们先尝试用 String json 发布
-
-                # 在 ROS2DeviceNode 中通常需要先 create_publisher
-                # 为了简单起见，我们检查是否已有 publisher，没有则创建
-                if not hasattr(self.workstation, "_device_status_pub"):
-                    self.workstation._device_status_pub = self.workstation._ros_node.create_publisher(
-                        String, topic, 10
-                    )
-
-                self.workstation._device_status_pub.publish(
-                    convert_to_ros_msg(String, json.dumps(event_data, ensure_ascii=False))
-                )
-        except Exception as e:
-            logger.error(f"发布设备状态事件失败: {e}")
-
-
 class BioyondResourceSynchronizer(ResourceSynchronizer):
    """Bioyond资源同步器

@@ -257,8 +172,9 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
            else:
                logger.info(f"[同步→Bioyond] ➕ 物料不存在于 Bioyond，将创建新物料并入库")

-            # 第1步：从配置中获取仓库配置
-            warehouse_mapping = self.bioyond_config.get("warehouse_mapping", {})
+            # 第1步：获取仓库配置
+            from .config import WAREHOUSE_MAPPING
+            warehouse_mapping = WAREHOUSE_MAPPING

            # 确定目标仓库名称
            parent_name = None
@@ -320,20 +236,14 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
            # 第2步：转换为 Bioyond 格式
            logger.info(f"[同步→Bioyond] 🔄 转换物料为 Bioyond 格式...")

-            # 从配置中获取物料默认参数
-            material_default_params = self.workstation.bioyond_config.get("material_default_parameters", {})
-            material_type_params = self.workstation.bioyond_config.get("material_type_parameters", {})
-
-            # 合并参数配置：物料名称参数 + typeId参数（转换为 type:<uuid> 格式）
-            merged_params = material_default_params.copy()
-            for type_id, params in material_type_params.items():
-                merged_params[f"type:{type_id}"] = params
+            # 导入物料默认参数配置
+            from .config import MATERIAL_DEFAULT_PARAMETERS

            bioyond_material = resource_plr_to_bioyond(
                [resource],
                type_mapping=self.workstation.bioyond_config["material_type_mappings"],
                warehouse_mapping=self.workstation.bioyond_config["warehouse_mapping"],
-                material_params=merged_params
+                material_params=MATERIAL_DEFAULT_PARAMETERS
            )[0]

            logger.info(f"[同步→Bioyond] 🔧 准备覆盖locations字段，目标仓库: {parent_name}, 库位: {update_site}, UUID: {target_location_uuid[:8]}...")
@@ -556,20 +466,13 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
                return material_bioyond_id

            # 转换为 Bioyond 格式
-            # 从配置中获取物料默认参数
-            material_default_params = self.workstation.bioyond_config.get("material_default_parameters", {})
-            material_type_params = self.workstation.bioyond_config.get("material_type_parameters", {})
-
-            # 合并参数配置：物料名称参数 + typeId参数（转换为 type:<uuid> 格式）
-            merged_params = material_default_params.copy()
-            for type_id, params in material_type_params.items():
-                merged_params[f"type:{type_id}"] = params
+            from .config import MATERIAL_DEFAULT_PARAMETERS

            bioyond_material = resource_plr_to_bioyond(
                [resource],
                type_mapping=self.workstation.bioyond_config["material_type_mappings"],
                warehouse_mapping=self.workstation.bioyond_config["warehouse_mapping"],
-                material_params=merged_params
+                material_params=MATERIAL_DEFAULT_PARAMETERS
            )[0]

            # ⚠️ 关键：创建物料时不设置 locations，让 Bioyond 系统暂不分配库位
@@ -623,7 +526,8 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
            logger.info(f"[物料入库] 目标库位: {update_site}")

            # 获取仓库配置和目标库位 UUID
-            warehouse_mapping = self.workstation.bioyond_config.get("warehouse_mapping", {})
+            from .config import WAREHOUSE_MAPPING
+            warehouse_mapping = WAREHOUSE_MAPPING

            parent_name = None
            target_location_uuid = None
@@ -678,44 +582,6 @@ class BioyondWorkstation(WorkstationBase):
    集成Bioyond物料管理的工作站实现
    """

-    def _publish_task_status(
-        self,
-        task_id: str,
-        task_type: str,
-        status: str,
-        result: dict = None,
-        progress: float = 0.0,
-        task_code: str = None
-    ):
-        """发布任务状态事件"""
-        try:
-            if not getattr(self, "_ros_node", None):
-                return
-
-            event_data = {
-                "task_id": task_id,
-                "task_code": task_code,
-                "task_type": task_type,
-                "status": status,
-                "progress": progress,
-                "timestamp": datetime.now().isoformat()
-            }
-            if result:
-                event_data["result"] = result
-
-            topic = f"{self._ros_node.namespace}/events/task_status"
-
-            if not hasattr(self, "_task_status_pub"):
-                self._task_status_pub = self._ros_node.create_publisher(
-                    String, topic, 10
-                )
-
-            self._task_status_pub.publish(
-                convert_to_ros_msg(String, json.dumps(event_data, ensure_ascii=False))
-            )
-        except Exception as e:
-            logger.error(f"发布任务状态事件失败: {e}")
-
    def __init__(
        self,
        bioyond_config: Optional[Dict[str, Any]] = None,
@@ -737,28 +603,10 @@ class BioyondWorkstation(WorkstationBase):
            raise ValueError("Deck 配置不能为空，请在配置文件中添加正确的 deck 配置")

        # 初始化 warehouses 属性
-        if not hasattr(self.deck, "warehouses") or self.deck.warehouses is None:
-            self.deck.warehouses = {}
-
-        # 仅当 warehouses 为空时尝试重新扫描（避免覆盖子类的修复）
-        if not self.deck.warehouses:
-            for resource in self.deck.children:
-                # 兼容性增强: 只要是仓库类别或者是 WareHouse 实例均可
-                is_warehouse = isinstance(resource, WareHouse) or getattr(resource, "category", "") == "warehouse"
-
-                # 如果配置中有定义，也可以认定为 warehouse
-                if not is_warehouse and "warehouse_mapping" in bioyond_config:
-                    if resource.name in bioyond_config["warehouse_mapping"]:
-                        is_warehouse = True
-
-                if is_warehouse:
-                    self.deck.warehouses[resource.name] = resource
-                    # 确保 category 被正确设置，方便后续使用
-                    if getattr(resource, "category", "") != "warehouse":
-                        try:
-                            resource.category = "warehouse"
-                        except:
-                            pass
+        self.deck.warehouses = {}
+        for resource in self.deck.children:
+            if isinstance(resource, WareHouse):
+                self.deck.warehouses[resource.name] = resource

        # 创建通信模块
        self._create_communication_module(bioyond_config)
@@ -777,22 +625,18 @@ class BioyondWorkstation(WorkstationBase):
            self._set_workflow_mappings(bioyond_config["workflow_mappings"])

        # 准备 HTTP 报送接收服务配置（延迟到 post_init 启动）
-        # 从 bioyond_config 中的 http_service_config 获取
-        http_service_cfg = bioyond_config.get("http_service_config", {})
+        # 从 bioyond_config 中获取，如果没有则使用默认值
        self._http_service_config = {
-            "host": http_service_cfg.get("http_service_host", "127.0.0.1"),
-            "port": http_service_cfg.get("http_service_port", 8080)
+            "host": bioyond_config.get("http_service_host", bioyond_config.get("HTTP_host", "")),
+            "port": bioyond_config.get("http_service_port", bioyond_config.get("HTTP_port", 0))
        }
-        self.http_service = None  # 将在 post_init 启动
-        self.connection_monitor = None # 将在 post_init 启动
+        self.http_service = None  # 将在 post_init 中启动

        logger.info(f"Bioyond工作站初始化完成")

    def __del__(self):
        """析构函数：清理资源，停止 HTTP 服务"""
        try:
-            if hasattr(self, 'connection_monitor') and self.connection_monitor:
-                self.connection_monitor.stop()
            if hasattr(self, 'http_service') and self.http_service is not None:
                logger.info("正在停止 HTTP 报送服务...")
                self.http_service.stop()
@@ -802,13 +646,6 @@ class BioyondWorkstation(WorkstationBase):
    def post_init(self, ros_node: ROS2WorkstationNode):
        self._ros_node = ros_node

-        # 启动连接监控
-        try:
-            self.connection_monitor = ConnectionMonitor(self)
-            self.connection_monitor.start()
-        except Exception as e:
-            logger.error(f"启动连接监控失败: {e}")
-
        # 启动 HTTP 报送接收服务（现在 device_id 已可用）
        # ⚠️ 检查子类是否已经自己管理 HTTP 服务
        if self.bioyond_config.get("_disable_auto_http_service"):
@@ -853,14 +690,14 @@ class BioyondWorkstation(WorkstationBase):

    def _create_communication_module(self, config: Optional[Dict[str, Any]] = None) -> None:
        """创建Bioyond通信模块"""
-        # 直接使用传入的配置，不再使用默认值
-        # 所有配置必须从 JSON 文件中提供
+        # 使用传入的 config 参数（来自 bioyond_config）
+        # 不再依赖全局变量 API_CONFIG 等
        if config:
            self.bioyond_config = config
        else:
-            # 如果没有配置，使用空字典（会导致后续错误，但这是预期的）
+            # 如果没有传入配置，创建空配置（用于测试或兼容性）
            self.bioyond_config = {}
-            print("警告: 未提供 bioyond_config，请确保在 JSON 配置文件中提供完整配置")
+

        self.hardware_interface = BioyondV1RPC(self.bioyond_config)

@@ -1174,15 +1011,7 @@ class BioyondWorkstation(WorkstationBase):

        workflow_id = self._get_workflow(actual_workflow_name)
        if workflow_id:
-            # 兼容 BioyondReactionStation 中 workflow_sequence 被重写为 property 的情况
-            if isinstance(self.workflow_sequence, list):
-                self.workflow_sequence.append(workflow_id)
-            elif hasattr(self, "_cached_workflow_sequence") and isinstance(self._cached_workflow_sequence, list):
-                self._cached_workflow_sequence.append(workflow_id)
-            else:
-                print(f"❌ 无法添加工作流: workflow_sequence 类型错误 {type(self.workflow_sequence)}")
-                return False
-
+            self.workflow_sequence.append(workflow_id)
            print(f"添加工作流到执行顺序: {actual_workflow_name} -> {workflow_id}")
            return True
        return False
@@ -1383,22 +1212,6 @@ class BioyondWorkstation(WorkstationBase):
            # TODO: 根据实际业务需求处理步骤完成逻辑
            # 例如：更新数据库、触发后续流程等

-            # 发布任务状态事件 (running/progress update)
-            self._publish_task_status(
-                task_id=data.get('orderCode'), # 使用 OrderCode 作为关联 ID
-                task_code=data.get('orderCode'),
-                task_type="bioyond_step",
-                status="running",
-                progress=0.5, # 步骤完成视为任务进行中
-                result={"step_name": data.get('stepName'), "step_id": data.get('stepId')}
-            )
-
-            # 更新物料信息
-            # 步骤完成后，物料状态可能发生变化（如位置、用量等），触发同步
-            logger.info(f"[步骤完成报送] 触发物料同步...")
-            self.resource_synchronizer.sync_from_external()
-
-
            return {
                "processed": True,
                "step_id": data.get('stepId'),
@@ -1433,17 +1246,6 @@ class BioyondWorkstation(WorkstationBase):

            # TODO: 根据实际业务需求处理通量完成逻辑

-            # 发布任务状态事件
-            self._publish_task_status(
-                task_id=data.get('orderCode'),
-                task_code=data.get('orderCode'),
-                task_type="bioyond_sample",
-                status="running",
-                progress=0.7,
-                result={"sample_id": data.get('sampleId'), "status": status_desc}
-            )
-
-
            return {
                "processed": True,
                "sample_id": data.get('sampleId'),
@@ -1483,32 +1285,6 @@ class BioyondWorkstation(WorkstationBase):
            # TODO: 根据实际业务需求处理任务完成逻辑
            # 例如：更新物料库存、生成报表等

-            # 映射状态到事件状态
-            event_status = "completed"
-            if str(data.get('status')) in ["-11", "-12"]:
-                event_status = "error"
-            elif str(data.get('status')) == "30":
-                event_status = "completed"
-            else:
-                event_status = "running" # 其他状态视为运行中（或根据实际定义）
-
-            # 发布任务状态事件
-            self._publish_task_status(
-                task_id=data.get('orderCode'),
-                task_code=data.get('orderCode'),
-                task_type="bioyond_order",
-                status=event_status,
-                progress=1.0 if event_status in ["completed", "error"] else 0.9,
-                result={"order_name": data.get('orderName'), "status": status_desc, "materials_count": len(used_materials)}
-            )
-
-            # 更新物料信息
-            # 任务完成后，且状态为完成时，触发同步以更新最终物料状态
-            if event_status == "completed":
-                logger.info(f"[任务完成报送] 触发物料同步...")
-                self.resource_synchronizer.sync_from_external()
-
-
            return {
                "processed": True,
                "order_code": data.get('orderCode'),
--- a/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_20260112.xlsx
+++ b/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_20260112.xlsx
--- a/unilabos/devices/workstation/workstation_http_service.py
+++ b/unilabos/devices/workstation/workstation_http_service.py
@@ -459,12 +459,12 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
            # 验证必需字段
            if 'brand' in request_data:
                if request_data['brand'] == "bioyond":  # 奔曜
-                    material_data = request_data["text"]
-                    logger.info(f"收到奔曜物料变更报送: {material_data}")
+                    error_msg = request_data["text"]
+                    logger.info(f"收到奔曜错误处理报送: {error_msg}")
                    return HttpResponse(
                        success=True,
-                        message=f"物料变更报送已收到: {material_data}",
-                        acknowledgment_id=f"MATERIAL_{int(time.time() * 1000)}_{material_data.get('id', 'unknown')}",
+                        message=f"错误处理报送已收到: {error_msg}",
+                        acknowledgment_id=f"ERROR_{int(time.time() * 1000)}_{error_msg.get('action_id', 'unknown')}",
                        data=None
                    )
            else:
--- a/unilabos/devices/xrd_d7mate/init.py
+++ b/unilabos/devices/xrd_d7mate/init.py
--- a/unilabos/devices/zhida_hplc/init.py
+++ b/unilabos/devices/zhida_hplc/init.py
--- a/unilabos/registry/device_comms/communication_devices.yaml
+++ b/unilabos/registry/device_comms/communication_devices.yaml
@@ -96,13 +96,10 @@ serial:
          type: string
        port:
          type: string
-        registry_name:
-          type: string
        resource_tracker:
          type: object
      required:
      - device_id
-      - registry_name
      - port
      type: object
    data:
--- a/unilabos/registry/devices/bioyond.yaml
+++ b/unilabos/registry/devices/bioyond.yaml
@@ -0,0 +1,589 @@
+workstation.bioyond_dispensing_station:
+  category:
+  - workstation
+  - bioyond
+  class:
+    action_value_mappings:
+      auto-batch_create_90_10_vial_feeding_tasks:
+        feedback: {}
+        goal: {}
+        goal_default:
+          delay_time: null
+          hold_m_name: null
+          liquid_material_name: NMP
+          speed: null
+          temperature: null
+          titration: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                delay_time:
+                  type: string
+                hold_m_name:
+                  type: string
+                liquid_material_name:
+                  default: NMP
+                  type: string
+                speed:
+                  type: string
+                temperature:
+                  type: string
+                titration:
+                  type: string
+              required:
+              - titration
+              type: object
+            result: {}
+          required:
+          - goal
+          title: batch_create_90_10_vial_feeding_tasks参数
+          type: object
+        type: UniLabJsonCommand
+      auto-batch_create_diamine_solution_tasks:
+        feedback: {}
+        goal: {}
+        goal_default:
+          delay_time: null
+          liquid_material_name: NMP
+          solutions: null
+          speed: null
+          temperature: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                delay_time:
+                  type: string
+                liquid_material_name:
+                  default: NMP
+                  type: string
+                solutions:
+                  type: string
+                speed:
+                  type: string
+                temperature:
+                  type: string
+              required:
+              - solutions
+              type: object
+            result: {}
+          required:
+          - goal
+          title: batch_create_diamine_solution_tasks参数
+          type: object
+        type: UniLabJsonCommand
+      auto-brief_step_parameters:
+        feedback: {}
+        goal: {}
+        goal_default:
+          data: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                data:
+                  type: object
+              required:
+              - data
+              type: object
+            result: {}
+          required:
+          - goal
+          title: brief_step_parameters参数
+          type: object
+        type: UniLabJsonCommand
+      auto-compute_experiment_design:
+        feedback: {}
+        goal: {}
+        goal_default:
+          m_tot: '70'
+          ratio: null
+          titration_percent: '0.03'
+          wt_percent: '0.25'
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                m_tot:
+                  default: '70'
+                  type: string
+                ratio:
+                  type: object
+                titration_percent:
+                  default: '0.03'
+                  type: string
+                wt_percent:
+                  default: '0.25'
+                  type: string
+              required:
+              - ratio
+              type: object
+            result:
+              properties:
+                feeding_order:
+                  items: {}
+                  title: Feeding Order
+                  type: array
+                return_info:
+                  title: Return Info
+                  type: string
+                solutions:
+                  items: {}
+                  title: Solutions
+                  type: array
+                solvents:
+                  additionalProperties: true
+                  title: Solvents
+                  type: object
+                titration:
+                  additionalProperties: true
+                  title: Titration
+                  type: object
+              required:
+              - solutions
+              - titration
+              - solvents
+              - feeding_order
+              - return_info
+              title: ComputeExperimentDesignReturn
+              type: object
+          required:
+          - goal
+          title: compute_experiment_design参数
+          type: object
+        type: UniLabJsonCommand
+      auto-process_order_finish_report:
+        feedback: {}
+        goal: {}
+        goal_default:
+          report_request: null
+          used_materials: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                report_request:
+                  type: string
+                used_materials:
+                  type: string
+              required:
+              - report_request
+              - used_materials
+              type: object
+            result: {}
+          required:
+          - goal
+          title: process_order_finish_report参数
+          type: object
+        type: UniLabJsonCommand
+      auto-project_order_report:
+        feedback: {}
+        goal: {}
+        goal_default:
+          order_id: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                order_id:
+                  type: string
+              required:
+              - order_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: project_order_report参数
+          type: object
+        type: UniLabJsonCommand
+      auto-query_resource_by_name:
+        feedback: {}
+        goal: {}
+        goal_default:
+          material_name: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                material_name:
+                  type: string
+              required:
+              - material_name
+              type: object
+            result: {}
+          required:
+          - goal
+          title: query_resource_by_name参数
+          type: object
+        type: UniLabJsonCommand
+      auto-transfer_materials_to_reaction_station:
+        feedback: {}
+        goal: {}
+        goal_default:
+          target_device_id: null
+          transfer_groups: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                target_device_id:
+                  type: string
+                transfer_groups:
+                  type: array
+              required:
+              - target_device_id
+              - transfer_groups
+              type: object
+            result: {}
+          required:
+          - goal
+          title: transfer_materials_to_reaction_station参数
+          type: object
+        type: UniLabJsonCommand
+      auto-wait_for_multiple_orders_and_get_reports:
+        feedback: {}
+        goal: {}
+        goal_default:
+          batch_create_result: null
+          check_interval: 10
+          timeout: 7200
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                batch_create_result:
+                  type: string
+                check_interval:
+                  default: 10
+                  type: integer
+                timeout:
+                  default: 7200
+                  type: integer
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: wait_for_multiple_orders_and_get_reports参数
+          type: object
+        type: UniLabJsonCommand
+      auto-workflow_sample_locations:
+        feedback: {}
+        goal: {}
+        goal_default:
+          workflow_id: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                workflow_id:
+                  type: string
+              required:
+              - workflow_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: workflow_sample_locations参数
+          type: object
+        type: UniLabJsonCommand
+      create_90_10_vial_feeding_task:
+        feedback: {}
+        goal:
+          delay_time: delay_time
+          hold_m_name: hold_m_name
+          order_name: order_name
+          percent_10_1_assign_material_name: percent_10_1_assign_material_name
+          percent_10_1_liquid_material_name: percent_10_1_liquid_material_name
+          percent_10_1_target_weigh: percent_10_1_target_weigh
+          percent_10_1_volume: percent_10_1_volume
+          percent_10_2_assign_material_name: percent_10_2_assign_material_name
+          percent_10_2_liquid_material_name: percent_10_2_liquid_material_name
+          percent_10_2_target_weigh: percent_10_2_target_weigh
+          percent_10_2_volume: percent_10_2_volume
+          percent_10_3_assign_material_name: percent_10_3_assign_material_name
+          percent_10_3_liquid_material_name: percent_10_3_liquid_material_name
+          percent_10_3_target_weigh: percent_10_3_target_weigh
+          percent_10_3_volume: percent_10_3_volume
+          percent_90_1_assign_material_name: percent_90_1_assign_material_name
+          percent_90_1_target_weigh: percent_90_1_target_weigh
+          percent_90_2_assign_material_name: percent_90_2_assign_material_name
+          percent_90_2_target_weigh: percent_90_2_target_weigh
+          percent_90_3_assign_material_name: percent_90_3_assign_material_name
+          percent_90_3_target_weigh: percent_90_3_target_weigh
+          speed: speed
+          temperature: temperature
+        goal_default:
+          delay_time: ''
+          hold_m_name: ''
+          order_name: ''
+          percent_10_1_assign_material_name: ''
+          percent_10_1_liquid_material_name: ''
+          percent_10_1_target_weigh: ''
+          percent_10_1_volume: ''
+          percent_10_2_assign_material_name: ''
+          percent_10_2_liquid_material_name: ''
+          percent_10_2_target_weigh: ''
+          percent_10_2_volume: ''
+          percent_10_3_assign_material_name: ''
+          percent_10_3_liquid_material_name: ''
+          percent_10_3_target_weigh: ''
+          percent_10_3_volume: ''
+          percent_90_1_assign_material_name: ''
+          percent_90_1_target_weigh: ''
+          percent_90_2_assign_material_name: ''
+          percent_90_2_target_weigh: ''
+          percent_90_3_assign_material_name: ''
+          percent_90_3_target_weigh: ''
+          speed: ''
+          temperature: ''
+        handles: {}
+        result:
+          return_info: return_info
+        schema:
+          description: ''
+          properties:
+            feedback:
+              properties: {}
+              required: []
+              title: DispenStationVialFeed_Feedback
+              type: object
+            goal:
+              properties:
+                delay_time:
+                  type: string
+                hold_m_name:
+                  type: string
+                order_name:
+                  type: string
+                percent_10_1_assign_material_name:
+                  type: string
+                percent_10_1_liquid_material_name:
+                  type: string
+                percent_10_1_target_weigh:
+                  type: string
+                percent_10_1_volume:
+                  type: string
+                percent_10_2_assign_material_name:
+                  type: string
+                percent_10_2_liquid_material_name:
+                  type: string
+                percent_10_2_target_weigh:
+                  type: string
+                percent_10_2_volume:
+                  type: string
+                percent_10_3_assign_material_name:
+                  type: string
+                percent_10_3_liquid_material_name:
+                  type: string
+                percent_10_3_target_weigh:
+                  type: string
+                percent_10_3_volume:
+                  type: string
+                percent_90_1_assign_material_name:
+                  type: string
+                percent_90_1_target_weigh:
+                  type: string
+                percent_90_2_assign_material_name:
+                  type: string
+                percent_90_2_target_weigh:
+                  type: string
+                percent_90_3_assign_material_name:
+                  type: string
+                percent_90_3_target_weigh:
+                  type: string
+                speed:
+                  type: string
+                temperature:
+                  type: string
+              required:
+              - order_name
+              - percent_90_1_assign_material_name
+              - percent_90_1_target_weigh
+              - percent_90_2_assign_material_name
+              - percent_90_2_target_weigh
+              - percent_90_3_assign_material_name
+              - percent_90_3_target_weigh
+              - percent_10_1_assign_material_name
+              - percent_10_1_target_weigh
+              - percent_10_1_volume
+              - percent_10_1_liquid_material_name
+              - percent_10_2_assign_material_name
+              - percent_10_2_target_weigh
+              - percent_10_2_volume
+              - percent_10_2_liquid_material_name
+              - percent_10_3_assign_material_name
+              - percent_10_3_target_weigh
+              - percent_10_3_volume
+              - percent_10_3_liquid_material_name
+              - speed
+              - temperature
+              - delay_time
+              - hold_m_name
+              title: DispenStationVialFeed_Goal
+              type: object
+            result:
+              properties:
+                return_info:
+                  type: string
+              required:
+              - return_info
+              title: DispenStationVialFeed_Result
+              type: object
+          required:
+          - goal
+          title: DispenStationVialFeed
+          type: object
+        type: DispenStationVialFeed
+      create_diamine_solution_task:
+        feedback: {}
+        goal:
+          delay_time: delay_time
+          hold_m_name: hold_m_name
+          liquid_material_name: liquid_material_name
+          material_name: material_name
+          order_name: order_name
+          speed: speed
+          target_weigh: target_weigh
+          temperature: temperature
+          volume: volume
+        goal_default:
+          delay_time: ''
+          hold_m_name: ''
+          liquid_material_name: ''
+          material_name: ''
+          order_name: ''
+          speed: ''
+          target_weigh: ''
+          temperature: ''
+          volume: ''
+        handles: {}
+        result:
+          return_info: return_info
+        schema:
+          description: ''
+          properties:
+            feedback:
+              properties: {}
+              required: []
+              title: DispenStationSolnPrep_Feedback
+              type: object
+            goal:
+              properties:
+                delay_time:
+                  type: string
+                hold_m_name:
+                  type: string
+                liquid_material_name:
+                  type: string
+                material_name:
+                  type: string
+                order_name:
+                  type: string
+                speed:
+                  type: string
+                target_weigh:
+                  type: string
+                temperature:
+                  type: string
+                volume:
+                  type: string
+              required:
+              - order_name
+              - material_name
+              - target_weigh
+              - volume
+              - liquid_material_name
+              - speed
+              - temperature
+              - delay_time
+              - hold_m_name
+              title: DispenStationSolnPrep_Goal
+              type: object
+            result:
+              properties:
+                return_info:
+                  type: string
+              required:
+              - return_info
+              title: DispenStationSolnPrep_Result
+              type: object
+          required:
+          - goal
+          title: DispenStationSolnPrep
+          type: object
+        type: DispenStationSolnPrep
+    module: unilabos.devices.workstation.bioyond_studio.dispensing_station:BioyondDispensingStation
+    status_types: {}
+    type: python
+  config_info: []
+  description: ''
+  handles: []
+  icon: ''
+  init_param_schema:
+    config:
+      properties:
+        config:
+          type: string
+        deck:
+          type: string
+      required:
+      - config
+      - deck
+      type: object
+    data:
+      properties: {}
+      required: []
+      type: object
+  version: 1.0.0
--- a/unilabos/registry/devices/bioyond_cell.yaml
+++ b/unilabos/registry/devices/bioyond_cell.yaml
--- a/unilabos/registry/devices/bioyond_dispensing_station.yaml
+++ b/unilabos/registry/devices/bioyond_dispensing_station.yaml
@@ -30,6 +30,71 @@ bioyond_dispensing_station:
          title: brief_step_parameters参数
          type: object
        type: UniLabJsonCommand
+      auto-compute_experiment_design:
+        feedback: {}
+        goal: {}
+        goal_default:
+          m_tot: '70'
+          ratio: null
+          titration_percent: '0.03'
+          wt_percent: '0.25'
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                m_tot:
+                  default: '70'
+                  type: string
+                ratio:
+                  type: object
+                titration_percent:
+                  default: '0.03'
+                  type: string
+                wt_percent:
+                  default: '0.25'
+                  type: string
+              required:
+              - ratio
+              type: object
+            result:
+              properties:
+                feeding_order:
+                  items: {}
+                  title: Feeding Order
+                  type: array
+                return_info:
+                  title: Return Info
+                  type: string
+                solutions:
+                  items: {}
+                  title: Solutions
+                  type: array
+                solvents:
+                  additionalProperties: true
+                  title: Solvents
+                  type: object
+                titration:
+                  additionalProperties: true
+                  title: Titration
+                  type: object
+              required:
+              - solutions
+              - titration
+              - solvents
+              - feeding_order
+              - return_info
+              title: ComputeExperimentDesignReturn
+              type: object
+          required:
+          - goal
+          title: compute_experiment_design参数
+          type: object
+        type: UniLabJsonCommand
      auto-process_order_finish_report:
        feedback: {}
        goal: {}
@@ -109,6 +174,35 @@ bioyond_dispensing_station:
          title: query_resource_by_name参数
          type: object
        type: UniLabJsonCommand
+      auto-transfer_materials_to_reaction_station:
+        feedback: {}
+        goal: {}
+        goal_default:
+          target_device_id: null
+          transfer_groups: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                target_device_id:
+                  type: string
+                transfer_groups:
+                  type: array
+              required:
+              - target_device_id
+              - transfer_groups
+              type: object
+            result: {}
+          required:
+          - goal
+          title: transfer_materials_to_reaction_station参数
+          type: object
+        type: UniLabJsonCommand
      auto-workflow_sample_locations:
        feedback: {}
        goal: {}
@@ -300,99 +394,6 @@ bioyond_dispensing_station:
          title: BatchCreateDiamineSolutionTasks
          type: object
        type: UniLabJsonCommand
-      compute_experiment_design:
-        feedback: {}
-        goal:
-          m_tot: m_tot
-          ratio: ratio
-          titration_percent: titration_percent
-          wt_percent: wt_percent
-        goal_default:
-          m_tot: '70'
-          ratio: ''
-          titration_percent: '0.03'
-          wt_percent: '0.25'
-        handles:
-          output:
-          - data_key: solutions
-            data_source: executor
-            data_type: array
-            handler_key: solutions
-            io_type: sink
-            label: Solution Data From Python
-          - data_key: titration
-            data_source: executor
-            data_type: object
-            handler_key: titration
-            io_type: sink
-            label: Titration Data From Calculation Node
-          - data_key: solvents
-            data_source: executor
-            data_type: object
-            handler_key: solvents
-            io_type: sink
-            label: Solvents Data From Calculation Node
-          - data_key: feeding_order
-            data_source: executor
-            data_type: array
-            handler_key: feeding_order
-            io_type: sink
-            label: Feeding Order Data From Calculation Node
-        result:
-          feeding_order: feeding_order
-          return_info: return_info
-          solutions: solutions
-          solvents: solvents
-          titration: titration
-        schema:
-          description: 计算实验设计，输出solutions/titration/solvents/feeding_order用于后续节点。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                m_tot:
-                  default: '70'
-                  description: 总质量(g)
-                  type: string
-                ratio:
-                  description: 组分摩尔比的对象，保持输入顺序，如{"MDA":1,"BTDA":1}
-                  type: string
-                titration_percent:
-                  default: '0.03'
-                  description: 滴定比例(10%部分)
-                  type: string
-                wt_percent:
-                  default: '0.25'
-                  description: 目标固含质量分数
-                  type: string
-              required:
-              - ratio
-              type: object
-            result:
-              properties:
-                feeding_order:
-                  type: array
-                return_info:
-                  type: string
-                solutions:
-                  type: array
-                solvents:
-                  type: object
-                titration:
-                  type: object
-              required:
-              - solutions
-              - titration
-              - solvents
-              - feeding_order
-              - return_info
-              title: ComputeExperimentDesign_Result
-              type: object
-          required:
-          - goal
-          title: ComputeExperimentDesign
-          type: object
-        type: UniLabJsonCommand
      create_90_10_vial_feeding_task:
        feedback: {}
        goal:
@@ -619,89 +620,6 @@ bioyond_dispensing_station:
          title: DispenStationSolnPrep
          type: object
        type: DispenStationSolnPrep
-      scheduler_start:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        result:
-          return_info: return_info
-        schema:
-          description: 启动调度器 - 启动Bioyond配液站的任务调度器，开始执行队列中的任务
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result:
-              properties:
-                return_info:
-                  description: 调度器启动结果，成功返回1，失败返回0
-                  type: integer
-              required:
-              - return_info
-              title: scheduler_start结果
-              type: object
-          required:
-          - goal
-          title: scheduler_start参数
-          type: object
-        type: UniLabJsonCommand
-      transfer_materials_to_reaction_station:
-        feedback: {}
-        goal:
-          target_device_id: target_device_id
-          transfer_groups: transfer_groups
-        goal_default:
-          target_device_id: ''
-          transfer_groups: ''
-        handles: {}
-        placeholder_keys:
-          target_device_id: unilabos_devices
-        result: {}
-        schema:
-          description: 将配液站完成的物料（溶液、样品等）转移到指定反应站的堆栈库位。支持配置多组转移任务，每组包含物料名称、目标堆栈和目标库位。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                target_device_id:
-                  description: 目标反应站设备ID（从设备列表中选择，所有转移组都使用同一个目标设备）
-                  type: string
-                transfer_groups:
-                  description: 转移任务组列表，每组包含物料名称、目标堆栈和目标库位，可以添加多组
-                  items:
-                    properties:
-                      materials:
-                        description: 物料名称（手动输入，系统将通过RPC查询验证）
-                        type: string
-                      target_sites:
-                        description: 目标库位（手动输入，如"A01"）
-                        type: string
-                      target_stack:
-                        description: 目标堆栈名称（从列表选择）
-                        enum:
-                        - 堆栈1左
-                        - 堆栈1右
-                        - 站内试剂存放堆栈
-                        type: string
-                    required:
-                    - materials
-                    - target_stack
-                    - target_sites
-                    type: object
-                  type: array
-              required:
-              - target_device_id
-              - transfer_groups
-              type: object
-            result: {}
-          required:
-          - goal
-          title: transfer_materials_to_reaction_station参数
-          type: object
-        type: UniLabJsonCommand
      wait_for_multiple_orders_and_get_reports:
        feedback: {}
        goal:
@@ -770,7 +688,7 @@ bioyond_dispensing_station:
          title: WaitForMultipleOrdersAndGetReports
          type: object
        type: UniLabJsonCommand
-    module: unilabos.devices.workstation.bioyond_studio.dispensing_station.dispensing_station:BioyondDispensingStation
+    module: unilabos.devices.workstation.bioyond_studio.dispensing_station:BioyondDispensingStation
    status_types: {}
    type: python
  config_info: []
@@ -781,16 +699,15 @@ bioyond_dispensing_station:
    config:
      properties:
        config:
-          type: object
+          type: string
        deck:
          type: string
-        protocol_type:
-          type: string
-      required: []
+      required:
+      - config
+      - deck
      type: object
    data:
      properties: {}
      required: []
      type: object
-  model: {}
  version: 1.0.0
--- a/unilabos/registry/devices/camera.yaml
+++ b/unilabos/registry/devices/camera.yaml
@@ -67,9 +67,6 @@ camera:
        period:
          default: 0.1
          type: number
-        registry_name:
-          default: ''
-          type: string
        resource_tracker:
          type: object
      required: []
--- a/unilabos/registry/devices/coin_cell_workstation.yaml
+++ b/unilabos/registry/devices/coin_cell_workstation.yaml
@@ -405,7 +405,7 @@ coincellassemblyworkstation_device:
            goal:
              properties:
                bottle_num:
-                  type: string
+                  type: integer
              required:
              - bottle_num
              type: object
--- a/unilabos/registry/devices/liquid_handler.yaml
+++ b/unilabos/registry/devices/liquid_handler.yaml
--- a/unilabos/registry/devices/opcua_example.yaml
+++ b/unilabos/registry/devices/opcua_example.yaml
@@ -49,7 +49,32 @@ opcua_example:
          title: load_config参数
          type: object
        type: UniLabJsonCommand
-      auto-refresh_node_values:
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: string
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
+      auto-print_cache_stats:
        feedback: {}
        goal: {}
        goal_default: {}
@@ -67,7 +92,32 @@ opcua_example:
            result: {}
          required:
          - goal
-          title: refresh_node_values参数
+          title: print_cache_stats参数
+          type: object
+        type: UniLabJsonCommand
+      auto-read_node:
+        feedback: {}
+        goal: {}
+        goal_default:
+          node_name: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                node_name:
+                  type: string
+              required:
+              - node_name
+              type: object
+            result: {}
+          required:
+          - goal
+          title: read_node参数
          type: object
        type: UniLabJsonCommand
      auto-set_node_value:
@@ -99,50 +149,9 @@ opcua_example:
          title: set_node_value参数
          type: object
        type: UniLabJsonCommand
-      auto-start_node_refresh:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: start_node_refresh参数
-          type: object
-        type: UniLabJsonCommand
-      auto-stop_node_refresh:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: stop_node_refresh参数
-          type: object
-        type: UniLabJsonCommand
    module: unilabos.device_comms.opcua_client.client:OpcUaClient
    status_types:
+      cache_stats: dict
      node_value: String
    type: python
  config_info: []
@@ -152,15 +161,23 @@ opcua_example:
  init_param_schema:
    config:
      properties:
+        cache_timeout:
+          default: 5.0
+          type: number
        config_path:
          type: string
+        deck:
+          type: string
        password:
          type: string
-        refresh_interval:
-          default: 1.0
-          type: number
+        subscription_interval:
+          default: 500
+          type: integer
        url:
          type: string
+        use_subscription:
+          default: true
+          type: boolean
        username:
          type: string
      required:
@@ -168,9 +185,12 @@ opcua_example:
      type: object
    data:
      properties:
+        cache_stats:
+          type: object
        node_value:
          type: string
      required:
      - node_value
+      - cache_stats
      type: object
  version: 1.0.0
--- a/unilabos/registry/devices/reaction_station_bioyond.yaml
+++ b/unilabos/registry/devices/reaction_station_bioyond.yaml
@@ -4,81 +4,6 @@ reaction_station.bioyond:
  - reaction_station_bioyond
  class:
    action_value_mappings:
-      add_time_constraint:
-        feedback: {}
-        goal:
-          duration: duration
-          end_point: end_point
-          end_step_key: end_step_key
-          start_point: start_point
-          start_step_key: start_step_key
-        goal_default:
-          duration: 0
-          end_point: 0
-          end_step_key: ''
-          start_point: 0
-          start_step_key: ''
-        handles: {}
-        result: {}
-        schema:
-          description: 添加时间约束 - 在两个工作流之间添加时间约束
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                duration:
-                  description: 时间(秒)
-                  type: integer
-                end_point:
-                  default: Start
-                  description: 终点计时点 (Start=开始前, End=结束后)
-                  enum:
-                  - Start
-                  - End
-                  type: string
-                end_step_key:
-                  description: 终点步骤Key (可选, 默认为空则自动选择)
-                  type: string
-                start_point:
-                  default: Start
-                  description: 起点计时点 (Start=开始前, End=结束后)
-                  enum:
-                  - Start
-                  - End
-                  type: string
-                start_step_key:
-                  description: 起点步骤Key (例如 "feeding", "liquid", 可选, 默认为空则自动选择)
-                  type: string
-              required:
-              - duration
-              type: object
-            result: {}
-          required:
-          - goal
-          title: add_time_constraint参数
-          type: object
-        type: UniLabJsonCommand
-      auto-clear_workflows:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: clear_workflows参数
-          type: object
-        type: UniLabJsonCommand
      auto-create_order:
        feedback: {}
        goal: {}
@@ -206,35 +131,6 @@ reaction_station.bioyond:
          title: process_web_workflows参数
          type: object
        type: UniLabJsonCommand
-      auto-set_reactor_temperature:
-        feedback: {}
-        goal: {}
-        goal_default:
-          reactor_id: null
-          temperature: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                reactor_id:
-                  type: integer
-                temperature:
-                  type: number
-              required:
-              - reactor_id
-              - temperature
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_reactor_temperature参数
-          type: object
-        type: UniLabJsonCommand
      auto-skip_titration_steps:
        feedback: {}
        goal: {}
@@ -260,27 +156,6 @@ reaction_station.bioyond:
          title: skip_titration_steps参数
          type: object
        type: UniLabJsonCommand
-      auto-sync_workflow_sequence_from_bioyond:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: sync_workflow_sequence_from_bioyond参数
-          type: object
-        type: UniLabJsonCommand
      auto-wait_for_multiple_orders_and_get_reports:
        feedback: {}
        goal: {}
@@ -313,33 +188,6 @@ reaction_station.bioyond:
          title: wait_for_multiple_orders_and_get_reports参数
          type: object
        type: UniLabJsonCommand
-      auto-workflow_sequence:
-        feedback: {}
-        goal: {}
-        goal_default:
-          value: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                value:
-                  items:
-                    type: string
-                  type: array
-              required:
-              - value
-              type: object
-            result: {}
-          required:
-          - goal
-          title: workflow_sequence参数
-          type: object
-        type: UniLabJsonCommand
      auto-workflow_step_query:
        feedback: {}
        goal: {}
@@ -365,36 +213,6 @@ reaction_station.bioyond:
          title: workflow_step_query参数
          type: object
        type: UniLabJsonCommand
-      clean_all_server_workflows:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        result:
-          code: code
-          message: message
-        schema:
-          description: 清空服务端所有非核心工作流 (保留核心流程)
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result:
-              properties:
-                code:
-                  description: 操作结果代码(1表示成功)
-                  type: integer
-                message:
-                  description: 结果描述
-                  type: string
-              type: object
-          required:
-          - goal
-          title: clean_all_server_workflows参数
-          type: object
-        type: UniLabJsonCommand
      drip_back:
        feedback: {}
        goal:
@@ -429,19 +247,13 @@ reaction_station.bioyond:
                  description: 观察时间(分钟)
                  type: string
                titration_type:
-                  description: 是否滴定(NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否滴定(1=否, 2=是)
                  type: string
                torque_variation:
-                  description: 是否观察 (NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否观察 (1=否, 2=是)
                  type: string
                volume:
-                  description: 分液公式(mL)
+                  description: 分液公式(μL)
                  type: string
              required:
              - volume
@@ -541,19 +353,13 @@ reaction_station.bioyond:
                  description: 观察时间(分钟)
                  type: string
                titration_type:
-                  description: 是否滴定(NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否滴定(1=否, 2=是)
                  type: string
                torque_variation:
-                  description: 是否观察 (NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否观察 (1=否, 2=是)
                  type: string
                volume:
-                  description: 分液公式(mL)
+                  description: 分液公式(μL)
                  type: string
              required:
              - volume
@@ -597,7 +403,7 @@ reaction_station.bioyond:
            label: Solvents Data From Calculation Node
        result: {}
        schema:
-          description: 液体投料-溶剂。可以直接提供volume(mL),或通过solvents对象自动从additional_solvent(mL)计算volume。
+          description: 液体投料-溶剂。可以直接提供volume(μL),或通过solvents对象自动从additional_solvent(mL)计算volume。
          properties:
            feedback: {}
            goal:
@@ -617,21 +423,15 @@ reaction_station.bioyond:
                  description: 观察时间(分钟),默认360
                  type: string
                titration_type:
-                  default: 'NO'
-                  description: 是否滴定(NO=否, YES=是),默认NO
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  default: '1'
+                  description: 是否滴定(1=否, 2=是),默认1
                  type: string
                torque_variation:
-                  default: 'YES'
-                  description: 是否观察 (NO=否, YES=是),默认YES
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  default: '2'
+                  description: 是否观察 (1=否, 2=是),默认2
                  type: string
                volume:
-                  description: 分液量(mL)。可直接提供,或通过solvents参数自动计算
+                  description: 分液量(μL)。可直接提供,或通过solvents参数自动计算
                  type: string
              required:
              - assign_material_name
@@ -704,21 +504,15 @@ reaction_station.bioyond:
                  description: 观察时间(分钟),默认90
                  type: string
                titration_type:
-                  default: 'YES'
-                  description: 是否滴定(NO=否, YES=是),默认YES
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  default: '2'
+                  description: 是否滴定(1=否, 2=是),默认2
                  type: string
                torque_variation:
-                  default: 'YES'
-                  description: 是否观察 (NO=否, YES=是),默认YES
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  default: '2'
+                  description: 是否观察 (1=否, 2=是),默认2
                  type: string
                volume_formula:
-                  description: 分液公式(mL)。可直接提供固定公式,或留空由系统根据x_value、feeding_order_data、extracted_actuals自动生成
+                  description: 分液公式(μL)。可直接提供固定公式,或留空由系统根据x_value、feeding_order_data、extracted_actuals自动生成
                  type: string
                x_value:
                  description: 公式中的x值,手工输入,格式为"{{1-2-3}}"(包含双花括号)。用于自动公式计算
@@ -766,19 +560,13 @@ reaction_station.bioyond:
                  description: 观察时间(分钟)
                  type: string
                titration_type:
-                  description: 是否滴定(NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否滴定(1=否, 2=是)
                  type: string
                torque_variation:
-                  description: 是否观察 (NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否观察 (1=否, 2=是)
                  type: string
                volume_formula:
-                  description: 分液公式(mL)
+                  description: 分液公式(μL)
                  type: string
              required:
              - volume_formula
@@ -892,35 +680,6 @@ reaction_station.bioyond:
          title: reactor_taken_out参数
          type: object
        type: UniLabJsonCommand
-      scheduler_start:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        result:
-          return_info: return_info
-        schema:
-          description: 启动调度器 - 启动Bioyond工作站的任务调度器，开始执行队列中的任务
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result:
-              properties:
-                return_info:
-                  description: 调度器启动结果，成功返回1，失败返回0
-                  type: integer
-              required:
-              - return_info
-              title: scheduler_start结果
-              type: object
-          required:
-          - goal
-          title: scheduler_start参数
-          type: object
-        type: UniLabJsonCommand
      solid_feeding_vials:
        feedback: {}
        goal:
@@ -947,11 +706,7 @@ reaction_station.bioyond:
                  description: 物料名称(用于获取试剂瓶位ID)
                  type: string
                material_id:
-                  description: 粉末类型ID，Salt=盐（21分钟），Flour=面粉（27分钟），BTDA=BTDA（38分钟）
-                  enum:
-                  - Salt
-                  - Flour
-                  - BTDA
+                  description: 粉末类型ID，1=盐（21分钟），2=面粉（27分钟），3=BTDA（38分钟）
                  type: string
                temperature:
                  description: 温度设定(°C)
@@ -960,10 +715,7 @@ reaction_station.bioyond:
                  description: 观察时间(分钟)
                  type: string
                torque_variation:
-                  description: 是否观察 (NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否观察 (1=否, 2=是)
                  type: string
              required:
              - assign_material_name
@@ -978,10 +730,10 @@ reaction_station.bioyond:
          title: solid_feeding_vials参数
          type: object
        type: UniLabJsonCommand
-    module: unilabos.devices.workstation.bioyond_studio.reaction_station.reaction_station:BioyondReactionStation
+    module: unilabos.devices.workstation.bioyond_studio.reaction_station:BioyondReactionStation
    protocol_type: []
    status_types:
-      workflow_sequence: str
+      workflow_sequence: String
    type: python
  config_info: []
  description: Bioyond反应站
@@ -1001,7 +753,9 @@ reaction_station.bioyond:
    data:
      properties:
        workflow_sequence:
-          type: string
+          items:
+            type: string
+          type: array
      required:
      - workflow_sequence
      type: object
@@ -1037,7 +791,7 @@ reaction_station.reactor:
          title: update_metrics参数
          type: object
        type: UniLabJsonCommand
-    module: unilabos.devices.workstation.bioyond_studio.reaction_station.reaction_station:BioyondReactor
+    module: unilabos.devices.workstation.bioyond_studio.reaction_station:BioyondReactor
    status_types: {}
    type: python
  config_info: []
--- a/unilabos/registry/devices/virtual_device.yaml
+++ b/unilabos/registry/devices/virtual_device.yaml
@@ -5792,482 +5792,3 @@ virtual_vacuum_pump:
      - status
      type: object
  version: 1.0.0
-virtual_workbench:
-  category:
-  - virtual_device
-  class:
-    action_value_mappings:
-      auto-move_to_heating_station:
-        feedback: {}
-        goal: {}
-        goal_default:
-          material_number: null
-        handles:
-          input:
-          - data_key: material_number
-            data_source: handle
-            data_type: workbench_material
-            handler_key: material_input
-            label: 物料编号
-          output:
-          - data_key: station_id
-            data_source: executor
-            data_type: workbench_station
-            handler_key: heating_station_output
-            label: 加热台ID
-          - data_key: material_number
-            data_source: executor
-            data_type: workbench_material
-            handler_key: material_number_output
-            label: 物料编号
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 将物料从An位置移动到空闲加热台，返回分配的加热台ID
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                material_number:
-                  description: 物料编号，1-5，物料ID自动生成为A{n}
-                  type: integer
-              required:
-              - material_number
-              type: object
-            result:
-              $defs:
-                LabSample:
-                  properties:
-                    extra:
-                      additionalProperties: true
-                      title: Extra
-                      type: object
-                    oss_path:
-                      title: Oss Path
-                      type: string
-                    sample_uuid:
-                      title: Sample Uuid
-                      type: string
-                  required:
-                  - sample_uuid
-                  - oss_path
-                  - extra
-                  title: LabSample
-                  type: object
-              description: move_to_heating_station 返回类型
-              properties:
-                material_id:
-                  title: Material Id
-                  type: string
-                material_number:
-                  title: Material Number
-                  type: integer
-                message:
-                  title: Message
-                  type: string
-                station_id:
-                  description: 分配的加热台ID
-                  title: Station Id
-                  type: integer
-                success:
-                  title: Success
-                  type: boolean
-                unilabos_samples:
-                  items:
-                    $ref: '#/$defs/LabSample'
-                  title: Unilabos Samples
-                  type: array
-              required:
-              - success
-              - station_id
-              - material_id
-              - material_number
-              - message
-              - unilabos_samples
-              title: MoveToHeatingStationResult
-              type: object
-          required:
-          - goal
-          title: move_to_heating_station参数
-          type: object
-        type: UniLabJsonCommand
-      auto-move_to_output:
-        feedback: {}
-        goal: {}
-        goal_default:
-          material_number: null
-          station_id: null
-        handles:
-          input:
-          - data_key: station_id
-            data_source: handle
-            data_type: workbench_station
-            handler_key: output_station_input
-            label: 加热台ID
-          - data_key: material_number
-            data_source: handle
-            data_type: workbench_material
-            handler_key: output_material_input
-            label: 物料编号
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 将物料从加热台移动到输出位置Cn
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                material_number:
-                  description: 物料编号，用于确定输出位置Cn
-                  type: integer
-                station_id:
-                  description: 加热台ID，1-3，从上一节点传入
-                  type: integer
-              required:
-              - station_id
-              - material_number
-              type: object
-            result:
-              $defs:
-                LabSample:
-                  properties:
-                    extra:
-                      additionalProperties: true
-                      title: Extra
-                      type: object
-                    oss_path:
-                      title: Oss Path
-                      type: string
-                    sample_uuid:
-                      title: Sample Uuid
-                      type: string
-                  required:
-                  - sample_uuid
-                  - oss_path
-                  - extra
-                  title: LabSample
-                  type: object
-              description: move_to_output 返回类型
-              properties:
-                material_id:
-                  title: Material Id
-                  type: string
-                station_id:
-                  title: Station Id
-                  type: integer
-                success:
-                  title: Success
-                  type: boolean
-                unilabos_samples:
-                  items:
-                    $ref: '#/$defs/LabSample'
-                  title: Unilabos Samples
-                  type: array
-              required:
-              - success
-              - station_id
-              - material_id
-              - unilabos_samples
-              title: MoveToOutputResult
-              type: object
-          required:
-          - goal
-          title: move_to_output参数
-          type: object
-        type: UniLabJsonCommand
-      auto-prepare_materials:
-        feedback: {}
-        goal: {}
-        goal_default:
-          count: 5
-        handles:
-          output:
-          - data_key: material_1
-            data_source: executor
-            data_type: workbench_material
-            handler_key: channel_1
-            label: 实验1
-          - data_key: material_2
-            data_source: executor
-            data_type: workbench_material
-            handler_key: channel_2
-            label: 实验2
-          - data_key: material_3
-            data_source: executor
-            data_type: workbench_material
-            handler_key: channel_3
-            label: 实验3
-          - data_key: material_4
-            data_source: executor
-            data_type: workbench_material
-            handler_key: channel_4
-            label: 实验4
-          - data_key: material_5
-            data_source: executor
-            data_type: workbench_material
-            handler_key: channel_5
-            label: 实验5
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 批量准备物料 - 虚拟起始节点，生成A1-A5物料，输出5个handle供后续节点使用
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                count:
-                  default: 5
-                  description: 待生成的物料数量，默认5 (生成 A1-A5)
-                  type: integer
-              required: []
-              type: object
-            result:
-              $defs:
-                LabSample:
-                  properties:
-                    extra:
-                      additionalProperties: true
-                      title: Extra
-                      type: object
-                    oss_path:
-                      title: Oss Path
-                      type: string
-                    sample_uuid:
-                      title: Sample Uuid
-                      type: string
-                  required:
-                  - sample_uuid
-                  - oss_path
-                  - extra
-                  title: LabSample
-                  type: object
-              description: prepare_materials 返回类型 - 批量准备物料
-              properties:
-                count:
-                  title: Count
-                  type: integer
-                material_1:
-                  title: Material 1
-                  type: integer
-                material_2:
-                  title: Material 2
-                  type: integer
-                material_3:
-                  title: Material 3
-                  type: integer
-                material_4:
-                  title: Material 4
-                  type: integer
-                material_5:
-                  title: Material 5
-                  type: integer
-                message:
-                  title: Message
-                  type: string
-                success:
-                  title: Success
-                  type: boolean
-                unilabos_samples:
-                  items:
-                    $ref: '#/$defs/LabSample'
-                  title: Unilabos Samples
-                  type: array
-              required:
-              - success
-              - count
-              - material_1
-              - material_2
-              - material_3
-              - material_4
-              - material_5
-              - message
-              - unilabos_samples
-              title: PrepareMaterialsResult
-              type: object
-          required:
-          - goal
-          title: prepare_materials参数
-          type: object
-        type: UniLabJsonCommand
-      auto-start_heating:
-        always_free: true
-        feedback: {}
-        goal: {}
-        goal_default:
-          material_number: null
-          station_id: null
-        handles:
-          input:
-          - data_key: station_id
-            data_source: handle
-            data_type: workbench_station
-            handler_key: station_id_input
-            label: 加热台ID
-          - data_key: material_number
-            data_source: handle
-            data_type: workbench_material
-            handler_key: material_number_input
-            label: 物料编号
-          output:
-          - data_key: station_id
-            data_source: executor
-            data_type: workbench_station
-            handler_key: heating_done_station
-            label: 加热完成-加热台ID
-          - data_key: material_number
-            data_source: executor
-            data_type: workbench_material
-            handler_key: heating_done_material
-            label: 加热完成-物料编号
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 启动指定加热台的加热程序
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                material_number:
-                  description: 物料编号，从上一节点传入
-                  type: integer
-                station_id:
-                  description: 加热台ID，1-3，从上一节点传入
-                  type: integer
-              required:
-              - station_id
-              - material_number
-              type: object
-            result:
-              $defs:
-                LabSample:
-                  properties:
-                    extra:
-                      additionalProperties: true
-                      title: Extra
-                      type: object
-                    oss_path:
-                      title: Oss Path
-                      type: string
-                    sample_uuid:
-                      title: Sample Uuid
-                      type: string
-                  required:
-                  - sample_uuid
-                  - oss_path
-                  - extra
-                  title: LabSample
-                  type: object
-              description: start_heating 返回类型
-              properties:
-                material_id:
-                  title: Material Id
-                  type: string
-                material_number:
-                  title: Material Number
-                  type: integer
-                message:
-                  title: Message
-                  type: string
-                station_id:
-                  title: Station Id
-                  type: integer
-                success:
-                  title: Success
-                  type: boolean
-                unilabos_samples:
-                  items:
-                    $ref: '#/$defs/LabSample'
-                  title: Unilabos Samples
-                  type: array
-              required:
-              - success
-              - station_id
-              - material_id
-              - material_number
-              - message
-              - unilabos_samples
-              title: StartHeatingResult
-              type: object
-          required:
-          - goal
-          title: start_heating参数
-          type: object
-        type: UniLabJsonCommand
-    module: unilabos.devices.virtual.workbench:VirtualWorkbench
-    status_types:
-      active_tasks_count: int
-      arm_current_task: str
-      arm_state: str
-      heating_station_1_material: str
-      heating_station_1_progress: float
-      heating_station_1_state: str
-      heating_station_2_material: str
-      heating_station_2_progress: float
-      heating_station_2_state: str
-      heating_station_3_material: str
-      heating_station_3_progress: float
-      heating_station_3_state: str
-      message: str
-      status: str
-    type: python
-  config_info: []
-  description: Virtual Workbench with 1 robotic arm and 3 heating stations for concurrent
-    material processing
-  handles: []
-  icon: ''
-  init_param_schema:
-    config:
-      properties:
-        config:
-          type: string
-        device_id:
-          type: string
-      required: []
-      type: object
-    data:
-      properties:
-        active_tasks_count:
-          type: integer
-        arm_current_task:
-          type: string
-        arm_state:
-          type: string
-        heating_station_1_material:
-          type: string
-        heating_station_1_progress:
-          type: number
-        heating_station_1_state:
-          type: string
-        heating_station_2_material:
-          type: string
-        heating_station_2_progress:
-          type: number
-        heating_station_2_state:
-          type: string
-        heating_station_3_material:
-          type: string
-        heating_station_3_progress:
-          type: number
-        heating_station_3_state:
-          type: string
-        message:
-          type: string
-        status:
-          type: string
-      required:
-      - status
-      - arm_state
-      - arm_current_task
-      - heating_station_1_state
-      - heating_station_1_material
-      - heating_station_1_progress
-      - heating_station_2_state
-      - heating_station_2_material
-      - heating_station_2_progress
-      - heating_station_3_state
-      - heating_station_3_material
-      - heating_station_3_progress
-      - active_tasks_count
-      - message
-      type: object
-  version: 1.0.0
--- a/unilabos/registry/registry.py
+++ b/unilabos/registry/registry.py
@@ -4,9 +4,6 @@ import os
 import sys
 import inspect
 import importlib
-import threading
-import traceback
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import Any, Dict, List, Union, Tuple

@@ -63,7 +60,6 @@ class Registry:
        self.device_module_to_registry = {}
        self.resource_type_registry = {}
        self._setup_called = False  # 跟踪setup是否已调用
-        self._registry_lock = threading.Lock()  # 多线程加载时的锁
        # 其他状态变量
        # self.is_host_mode = False  # 移至BasicConfig中

@@ -75,28 +71,6 @@ class Registry:

        from unilabos.app.web.utils.action_utils import get_yaml_from_goal_type

-        # 获取 HostNode 类的增强信息，用于自动生成 action schema
-        host_node_enhanced_info = get_enhanced_class_info(
-            "unilabos.ros.nodes.presets.host_node:HostNode", use_dynamic=True
-        )
-
-        # 为 test_latency 生成 schema，保留原有 description
-        test_latency_method_info = host_node_enhanced_info.get("action_methods", {}).get("test_latency", {})
-        test_latency_schema = self._generate_unilab_json_command_schema(
-            test_latency_method_info.get("args", []),
-            "test_latency",
-            test_latency_method_info.get("return_annotation"),
-        )
-        test_latency_schema["description"] = "用于测试延迟的动作，返回延迟时间和时间差。"
-
-        test_resource_method_info = host_node_enhanced_info.get("action_methods", {}).get("test_resource", {})
-        test_resource_schema = self._generate_unilab_json_command_schema(
-            test_resource_method_info.get("args", []),
-            "test_resource",
-            test_resource_method_info.get("return_annotation"),
-        )
-        test_resource_schema["description"] = "用于测试物料、设备和样本。"
-
        self.device_type_registry.update(
            {
                "host_node": {
@@ -150,48 +124,28 @@ class Registry:
                                    "output": [
                                        {
                                            "handler_key": "labware",
-                                            "data_type": "resource",
                                            "label": "Labware",
-                                            "data_source": "executor",
-                                            "data_key": "created_resource_tree.@flatten",
-                                        },
-                                        {
-                                            "handler_key": "liquid_slots",
                                            "data_type": "resource",
-                                            "label": "LiquidSlots",
-                                            "data_source": "executor",
-                                            "data_key": "liquid_input_resource_tree.@flatten",
-                                        },
-                                        {
-                                            "handler_key": "materials",
-                                            "data_type": "resource",
-                                            "label": "AllMaterials",
-                                            "data_source": "executor",
-                                            "data_key": "[created_resource_tree,liquid_input_resource_tree].@flatten.@flatten",
-                                        },
+                                            "data_source": "handle",
+                                            "data_key": "liquid",
+                                        }
                                    ]
                                },
                                "placeholder_keys": {
                                    "res_id": "unilabos_resources",  # 将当前实验室的全部物料id作为下拉框可选择
                                    "device_id": "unilabos_devices",  # 将当前实验室的全部设备id作为下拉框可选择
                                    "parent": "unilabos_nodes",  # 将当前实验室的设备/物料作为下拉框可选择
-                                    "class_name": "unilabos_class",  # 当前实验室物料的class name
-                                    "slot_on_deck": "unilabos_resource_slot:parent",  # 勾选的parent的config中的sites的name，展示name，参数对应slot（index）
                                },
                            },
                            "test_latency": {
-                                "type": (
-                                    "UniLabJsonCommandAsync"
-                                    if test_latency_method_info.get("is_async", False)
-                                    else "UniLabJsonCommand"
-                                ),
+                                "type": self.EmptyIn,
                                "goal": {},
                                "feedback": {},
                                "result": {},
-                                "schema": test_latency_schema,
-                                "goal_default": {
-                                    arg["name"]: arg["default"] for arg in test_latency_method_info.get("args", [])
-                                },
+                                "schema": ros_action_to_json_schema(
+                                    self.EmptyIn, "用于测试延迟的动作，返回延迟时间和时间差。"
+                                ),
+                                "goal_default": {},
                                "handles": {},
                            },
                            "auto-test_resource": {
@@ -199,7 +153,32 @@ class Registry:
                                "goal": {},
                                "feedback": {},
                                "result": {},
-                                "schema": test_resource_schema,
+                                "schema": {
+                                    "description": "",
+                                    "properties": {
+                                        "feedback": {},
+                                        "goal": {
+                                            "properties": {
+                                                "resource": ros_message_to_json_schema(Resource, "resource"),
+                                                "resources": {
+                                                    "items": {
+                                                        "properties": ros_message_to_json_schema(
+                                                            Resource, "resources"
+                                                        ),
+                                                        "type": "object",
+                                                    },
+                                                    "type": "array",
+                                                },
+                                                "device": {"type": "string"},
+                                                "devices": {"items": {"type": "string"}, "type": "array"},
+                                            },
+                                            "type": "object",
+                                        },
+                                        "result": {},
+                                    },
+                                    "title": "test_resource",
+                                    "type": "object",
+                                },
                                "placeholder_keys": {
                                    "device": "unilabos_devices",
                                    "devices": "unilabos_devices",
@@ -207,17 +186,7 @@ class Registry:
                                    "resources": "unilabos_resources",
                                },
                                "goal_default": {},
-                                "handles": {
-                                    "input": [
-                                        {
-                                            "handler_key": "input_resources",
-                                            "data_type": "resource",
-                                            "label": "InputResources",
-                                            "data_source": "handle",
-                                            "data_key": "resources",  # 不为空
-                                        },
-                                    ]
-                                },
+                                "handles": {},
                            },
                        },
                    },
@@ -249,115 +218,67 @@ class Registry:
        # 标记setup已被调用
        self._setup_called = True

-    def _load_single_resource_file(
-        self, file: Path, complete_registry: bool, upload_registry: bool
-    ) -> Tuple[Dict[str, Any], Dict[str, Any], bool]:
-        """
-        加载单个资源文件 (线程安全)
-
-        Returns:
-            (data, complete_data, is_valid): 资源数据, 完整数据, 是否有效
-        """
-        try:
-            with open(file, encoding="utf-8", mode="r") as f:
-                data = yaml.safe_load(io.StringIO(f.read()))
-        except Exception as e:
-            logger.warning(f"[UniLab Registry] 读取资源文件失败: {file}, 错误: {e}")
-            return {}, {}, False
-
-        if not data:
-            return {}, {}, False
-
-        complete_data = {}
-        for resource_id, resource_info in data.items():
-            if "version" not in resource_info:
-                resource_info["version"] = "1.0.0"
-            if "category" not in resource_info:
-                resource_info["category"] = [file.stem]
-            elif file.stem not in resource_info["category"]:
-                resource_info["category"].append(file.stem)
-            elif not isinstance(resource_info.get("category"), list):
-                resource_info["category"] = [resource_info["category"]]
-            if "config_info" not in resource_info:
-                resource_info["config_info"] = []
-            if "icon" not in resource_info:
-                resource_info["icon"] = ""
-            if "handles" not in resource_info:
-                resource_info["handles"] = []
-            if "init_param_schema" not in resource_info:
-                resource_info["init_param_schema"] = {}
-            if "config_info" in resource_info:
-                del resource_info["config_info"]
-            if "file_path" in resource_info:
-                del resource_info["file_path"]
-            complete_data[resource_id] = copy.deepcopy(dict(sorted(resource_info.items())))
-            if upload_registry:
-                class_info = resource_info.get("class", {})
-                if len(class_info) and "module" in class_info:
-                    if class_info.get("type") == "pylabrobot":
-                        res_class = get_class(class_info["module"])
-                        if callable(res_class) and not isinstance(res_class, type):
-                            res_instance = res_class(res_class.__name__)
-                            res_ulr = tree_to_list([resource_plr_to_ulab(res_instance)])
-                            resource_info["config_info"] = res_ulr
-            resource_info["registry_type"] = "resource"
-            resource_info["file_path"] = str(file.absolute()).replace("\\", "/")
-
-        complete_data = dict(sorted(complete_data.items()))
-        complete_data = copy.deepcopy(complete_data)
-
-        if complete_registry:
-            try:
-                with open(file, "w", encoding="utf-8") as f:
-                    yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
-            except Exception as e:
-                logger.warning(f"[UniLab Registry] 写入资源文件失败: {file}, 错误: {e}")
-
-        return data, complete_data, True
-
    def load_resource_types(self, path: os.PathLike, complete_registry: bool, upload_registry: bool):
        abs_path = Path(path).absolute()
        resource_path = abs_path / "resources"
        files = list(resource_path.glob("*/*.yaml"))
-        logger.debug(f"[UniLab Registry] resources: {resource_path.exists()}, total: {len(files)}")
-
-        if not files:
-            return
-
-        # 使用线程池并行加载
-        max_workers = min(8, len(files))
-        results = []
-
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            future_to_file = {
-                executor.submit(self._load_single_resource_file, file, complete_registry, upload_registry): file
-                for file in files
-            }
-            for future in as_completed(future_to_file):
-                file = future_to_file[future]
-                try:
-                    data, complete_data, is_valid = future.result()
-                    if is_valid:
-                        results.append((file, data))
-                except Exception as e:
-                    logger.warning(f"[UniLab Registry] 处理资源文件异常: {file}, 错误: {e}")
-
-        # 线程安全地更新注册表
+        logger.trace(f"[UniLab Registry] load resources? {resource_path.exists()}, total: {len(files)}")
        current_resource_number = len(self.resource_type_registry) + 1
-        with self._registry_lock:
-            for i, (file, data) in enumerate(results):
+        for i, file in enumerate(files):
+            with open(file, encoding="utf-8", mode="r") as f:
+                data = yaml.safe_load(io.StringIO(f.read()))
+            complete_data = {}
+            if data:
+                # 为每个资源添加文件路径信息
+                for resource_id, resource_info in data.items():
+                    if "version" not in resource_info:
+                        resource_info["version"] = "1.0.0"
+                    if "category" not in resource_info:
+                        resource_info["category"] = [file.stem]
+                    elif file.stem not in resource_info["category"]:
+                        resource_info["category"].append(file.stem)
+                    elif not isinstance(resource_info.get("category"), list):
+                        resource_info["category"] = [resource_info["category"]]
+                    if "config_info" not in resource_info:
+                        resource_info["config_info"] = []
+                    if "icon" not in resource_info:
+                        resource_info["icon"] = ""
+                    if "handles" not in resource_info:
+                        resource_info["handles"] = []
+                    if "init_param_schema" not in resource_info:
+                        resource_info["init_param_schema"] = {}
+                    if "config_info" in resource_info:
+                        del resource_info["config_info"]
+                    if "file_path" in resource_info:
+                        del resource_info["file_path"]
+                    complete_data[resource_id] = copy.deepcopy(dict(sorted(resource_info.items())))
+                    if upload_registry:
+                        class_info = resource_info.get("class", {})
+                        if len(class_info) and "module" in class_info:
+                            if class_info.get("type") == "pylabrobot":
+                                res_class = get_class(class_info["module"])
+                                if callable(res_class) and not isinstance(
+                                    res_class, type
+                                ):  # 有的是类，有的是函数，这里暂时只登记函数类的
+                                    res_instance = res_class(res_class.__name__)
+                                    res_ulr = tree_to_list([resource_plr_to_ulab(res_instance)])
+                                    resource_info["config_info"] = res_ulr
+                    resource_info["registry_type"] = "resource"
+                    resource_info["file_path"] = str(file.absolute()).replace("\\", "/")
+                complete_data = dict(sorted(complete_data.items()))
+                complete_data = copy.deepcopy(complete_data)
+                if complete_registry:
+                    with open(file, "w", encoding="utf-8") as f:
+                        yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
+
                self.resource_type_registry.update(data)
-                logger.trace(
-                    f"[UniLab Registry] Resource-{current_resource_number} File-{i+1}/{len(results)} "
+                logger.trace(  # type: ignore
+                    f"[UniLab Registry] Resource-{current_resource_number} File-{i+1}/{len(files)} "
                    + f"Add {list(data.keys())}"
                )
                current_resource_number += 1
-
-        # 记录无效文件
-        valid_files = {r[0] for r in results}
-        for file in files:
-            if file not in valid_files:
-                logger.debug(f"[UniLab Registry] Res File Not Valid YAML File: {file.absolute()}")
+            else:
+                logger.debug(f"[UniLab Registry] Res File-{i+1}/{len(files)} Not Valid YAML File: {file.absolute()}")

    def _extract_class_docstrings(self, module_string: str) -> Dict[str, str]:
        """
@@ -534,11 +455,7 @@ class Registry:
        return status_schema

    def _generate_unilab_json_command_schema(
-        self,
-        method_args: List[Dict[str, Any]],
-        method_name: str,
-        return_annotation: Any = None,
-        previous_schema: Dict[str, Any] | None = None,
+        self, method_args: List[Dict[str, Any]], method_name: str, return_annotation: Any = None
    ) -> Dict[str, Any]:
        """
        根据UniLabJsonCommand方法信息生成JSON Schema，暂不支持嵌套类型
@@ -547,7 +464,6 @@ class Registry:
            method_args: 方法信息字典，包含args等
            method_name: 方法名称
            return_annotation: 返回类型注解，用于生成result schema（仅支持TypedDict）
-            previous_schema: 之前的 schema，用于保留 goal/feedback/result 下一级字段的 description

        Returns:
            JSON Schema格式的参数schema
@@ -581,7 +497,7 @@ class Registry:
        if return_annotation is not None and self._is_typed_dict(return_annotation):
            result_schema = self._generate_typed_dict_result_schema(return_annotation)

-        final_schema = {
+        return {
            "title": f"{method_name}参数",
            "description": f"",
            "type": "object",
@@ -589,40 +505,6 @@ class Registry:
            "required": ["goal"],
        }

-        # 保留之前 schema 中 goal/feedback/result 下一级字段的 description
-        if previous_schema:
-            self._preserve_field_descriptions(final_schema, previous_schema)
-
-        return final_schema
-
-    def _preserve_field_descriptions(self, new_schema: Dict[str, Any], previous_schema: Dict[str, Any]) -> None:
-        """
-        保留之前 schema 中 goal/feedback/result 下一级字段的 description 和 title
-
-        Args:
-            new_schema: 新生成的 schema（会被修改）
-            previous_schema: 之前的 schema
-        """
-        for section in ["goal", "feedback", "result"]:
-            new_section = new_schema.get("properties", {}).get(section, {})
-            prev_section = previous_schema.get("properties", {}).get(section, {})
-
-            if not new_section or not prev_section:
-                continue
-
-            new_props = new_section.get("properties", {})
-            prev_props = prev_section.get("properties", {})
-
-            for field_name, field_schema in new_props.items():
-                if field_name in prev_props:
-                    prev_field = prev_props[field_name]
-                    # 保留字段的 description
-                    if "description" in prev_field and prev_field["description"]:
-                        field_schema["description"] = prev_field["description"]
-                    # 保留字段的 title（用户自定义的中文名）
-                    if "title" in prev_field and prev_field["title"]:
-                        field_schema["title"] = prev_field["title"]
-
    def _is_typed_dict(self, annotation: Any) -> bool:
        """
        检查类型注解是否是TypedDict
@@ -709,246 +591,209 @@ class Registry:
                "handles": {},
            }

-    def _load_single_device_file(
-        self, file: Path, complete_registry: bool, get_yaml_from_goal_type
-    ) -> Tuple[Dict[str, Any], Dict[str, Any], bool, List[str]]:
-        """
-        加载单个设备文件 (线程安全)
-
-        Returns:
-            (data, complete_data, is_valid, device_ids): 设备数据, 完整数据, 是否有效, 设备ID列表
-        """
-        try:
-            with open(file, encoding="utf-8", mode="r") as f:
-                data = yaml.safe_load(io.StringIO(f.read()))
-        except Exception as e:
-            logger.warning(f"[UniLab Registry] 读取设备文件失败: {file}, 错误: {e}")
-            return {}, {}, False, []
-
-        if not data:
-            return {}, {}, False, []
-
-        complete_data = {}
-        action_str_type_mapping = {
-            "UniLabJsonCommand": "UniLabJsonCommand",
-            "UniLabJsonCommandAsync": "UniLabJsonCommandAsync",
-        }
-        status_str_type_mapping = {}
-        device_ids = []
-
-        for device_id, device_config in data.items():
-            if "version" not in device_config:
-                device_config["version"] = "1.0.0"
-            if "category" not in device_config:
-                device_config["category"] = [file.stem]
-            elif file.stem not in device_config["category"]:
-                device_config["category"].append(file.stem)
-            if "config_info" not in device_config:
-                device_config["config_info"] = []
-            if "description" not in device_config:
-                device_config["description"] = ""
-            if "icon" not in device_config:
-                device_config["icon"] = ""
-            if "handles" not in device_config:
-                device_config["handles"] = []
-            if "init_param_schema" not in device_config:
-                device_config["init_param_schema"] = {}
-            if "class" in device_config:
-                if "status_types" not in device_config["class"] or device_config["class"]["status_types"] is None:
-                    device_config["class"]["status_types"] = {}
-                if (
-                    "action_value_mappings" not in device_config["class"]
-                    or device_config["class"]["action_value_mappings"] is None
-                ):
-                    device_config["class"]["action_value_mappings"] = {}
-                enhanced_info = {}
-                if complete_registry:
-                    device_config["class"]["status_types"].clear()
-                    enhanced_info = get_enhanced_class_info(device_config["class"]["module"], use_dynamic=True)
-                    if not enhanced_info.get("dynamic_import_success", False):
-                        continue
-                    device_config["class"]["status_types"].update(
-                        {k: v["return_type"] for k, v in enhanced_info["status_methods"].items()}
-                    )
-                for status_name, status_type in device_config["class"]["status_types"].items():
-                    if isinstance(status_type, tuple) or status_type in ["Any", "None", "Unknown"]:
-                        status_type = "String"
-                        device_config["class"]["status_types"][status_name] = status_type
-                    try:
-                        target_type = self._replace_type_with_class(status_type, device_id, f"状态 {status_name}")
-                    except ROSMsgNotFound:
-                        continue
-                    if target_type in [dict, list]:
-                        target_type = String
-                    status_str_type_mapping[status_type] = target_type
-                device_config["class"]["status_types"] = dict(sorted(device_config["class"]["status_types"].items()))
-                if complete_registry:
-                    old_action_configs = {}
-                    for action_name, action_config in device_config["class"]["action_value_mappings"].items():
-                        old_action_configs[action_name] = action_config
-
-                    device_config["class"]["action_value_mappings"] = {
-                        k: v
-                        for k, v in device_config["class"]["action_value_mappings"].items()
-                        if not k.startswith("auto-")
-                    }
-                    device_config["class"]["action_value_mappings"].update(
-                        {
-                            f"auto-{k}": {
-                                "type": "UniLabJsonCommandAsync" if v["is_async"] else "UniLabJsonCommand",
-                                "goal": {},
-                                "feedback": {},
-                                "result": {},
-                                "schema": self._generate_unilab_json_command_schema(
-                                    v["args"],
-                                    k,
-                                    v.get("return_annotation"),
-                                    old_action_configs.get(f"auto-{k}", {}).get("schema"),
-                                ),
-                                "goal_default": {i["name"]: i["default"] for i in v["args"]},
-                                "handles": old_action_configs.get(f"auto-{k}", {}).get("handles", []),
-                                "placeholder_keys": {
-                                    i["name"]: (
-                                        "unilabos_resources"
-                                        if i["type"] == "unilabos.registry.placeholder_type:ResourceSlot"
-                                        or i["type"] == ("list", "unilabos.registry.placeholder_type:ResourceSlot")
-                                        else "unilabos_devices"
-                                    )
-                                    for i in v["args"]
-                                    if i.get("type", "")
-                                    in [
-                                        "unilabos.registry.placeholder_type:ResourceSlot",
-                                        "unilabos.registry.placeholder_type:DeviceSlot",
-                                        ("list", "unilabos.registry.placeholder_type:ResourceSlot"),
-                                        ("list", "unilabos.registry.placeholder_type:DeviceSlot"),
-                                    ]
-                                },
-                                **({"always_free": True} if v.get("always_free") else {}),
-                            }
-                            for k, v in enhanced_info["action_methods"].items()
-                            if k not in device_config["class"]["action_value_mappings"]
-                        }
-                    )
-                    for action_name, old_config in old_action_configs.items():
-                        if action_name in device_config["class"]["action_value_mappings"]:
-                            old_schema = old_config.get("schema", {})
-                            if "description" in old_schema and old_schema["description"]:
-                                device_config["class"]["action_value_mappings"][action_name]["schema"][
-                                    "description"
-                                ] = old_schema["description"]
-                    device_config["init_param_schema"] = {}
-                    device_config["init_param_schema"]["config"] = self._generate_unilab_json_command_schema(
-                        enhanced_info["init_params"], "__init__"
-                    )["properties"]["goal"]
-                    device_config["init_param_schema"]["data"] = self._generate_status_types_schema(
-                        enhanced_info["status_methods"]
-                    )
-
-                device_config.pop("schema", None)
-                device_config["class"]["action_value_mappings"] = dict(
-                    sorted(device_config["class"]["action_value_mappings"].items())
-                )
-                for action_name, action_config in device_config["class"]["action_value_mappings"].items():
-                    if "handles" not in action_config:
-                        action_config["handles"] = {}
-                    elif isinstance(action_config["handles"], list):
-                        if len(action_config["handles"]):
-                            logger.error(f"设备{device_id} {action_name} 的handles配置错误，应该是字典类型")
-                            continue
-                        else:
-                            action_config["handles"] = {}
-                    if "type" in action_config:
-                        action_type_str: str = action_config["type"]
-                        if not action_type_str.startswith("UniLabJsonCommand"):
-                            try:
-                                target_type = self._replace_type_with_class(
-                                    action_type_str, device_id, f"动作 {action_name}"
-                                )
-                            except ROSMsgNotFound:
-                                continue
-                            action_str_type_mapping[action_type_str] = target_type
-                            if target_type is not None:
-                                action_config["goal_default"] = yaml.safe_load(
-                                    io.StringIO(get_yaml_from_goal_type(target_type.Goal))
-                                )
-                                action_config["schema"] = ros_action_to_json_schema(target_type)
-                            else:
-                                logger.warning(
-                                    f"[UniLab Registry] 设备 {device_id} 的动作 {action_name} 类型为空，跳过替换"
-                                )
-                complete_data[device_id] = copy.deepcopy(dict(sorted(device_config.items())))
-                for status_name, status_type in device_config["class"]["status_types"].items():
-                    device_config["class"]["status_types"][status_name] = status_str_type_mapping[status_type]
-                for action_name, action_config in device_config["class"]["action_value_mappings"].items():
-                    if action_config["type"] not in action_str_type_mapping:
-                        continue
-                    action_config["type"] = action_str_type_mapping[action_config["type"]]
-                self._add_builtin_actions(device_config, device_id)
-            device_config["file_path"] = str(file.absolute()).replace("\\", "/")
-            device_config["registry_type"] = "device"
-            device_ids.append(device_id)
-
-        complete_data = dict(sorted(complete_data.items()))
-        complete_data = copy.deepcopy(complete_data)
-        try:
-            with open(file, "w", encoding="utf-8") as f:
-                yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
-        except Exception as e:
-            logger.warning(f"[UniLab Registry] 写入设备文件失败: {file}, 错误: {e}")
-
-        return data, complete_data, True, device_ids
-
    def load_device_types(self, path: os.PathLike, complete_registry: bool):
+        # return
        abs_path = Path(path).absolute()
        devices_path = abs_path / "devices"
        device_comms_path = abs_path / "device_comms"
        files = list(devices_path.glob("*.yaml")) + list(device_comms_path.glob("*.yaml"))
-        logger.trace(
+        logger.trace(  # type: ignore
            f"[UniLab Registry] devices: {devices_path.exists()}, device_comms: {device_comms_path.exists()}, "
            + f"total: {len(files)}"
        )
-
-        if not files:
-            return
-
+        current_device_number = len(self.device_type_registry) + 1
        from unilabos.app.web.utils.action_utils import get_yaml_from_goal_type

-        # 使用线程池并行加载
-        max_workers = min(8, len(files))
-        results = []
-
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            future_to_file = {
-                executor.submit(self._load_single_device_file, file, complete_registry, get_yaml_from_goal_type): file
-                for file in files
+        for i, file in enumerate(files):
+            with open(file, encoding="utf-8", mode="r") as f:
+                data = yaml.safe_load(io.StringIO(f.read()))
+            complete_data = {}
+            action_str_type_mapping = {
+                "UniLabJsonCommand": "UniLabJsonCommand",
+                "UniLabJsonCommandAsync": "UniLabJsonCommandAsync",
            }
-            for future in as_completed(future_to_file):
-                file = future_to_file[future]
-                try:
-                    data, complete_data, is_valid, device_ids = future.result()
-                    if is_valid:
-                        results.append((file, data, device_ids))
-                except Exception as e:
-                    traceback.print_exc()
-                    logger.warning(f"[UniLab Registry] 处理设备文件异常: {file}, 错误: {e}")
+            status_str_type_mapping = {}
+            if data:
+                # 在添加到注册表前处理类型替换
+                for device_id, device_config in data.items():
+                    # 添加文件路径信息 - 使用规范化的完整文件路径
+                    if "version" not in device_config:
+                        device_config["version"] = "1.0.0"
+                    if "category" not in device_config:
+                        device_config["category"] = [file.stem]
+                    elif file.stem not in device_config["category"]:
+                        device_config["category"].append(file.stem)
+                    if "config_info" not in device_config:
+                        device_config["config_info"] = []
+                    if "description" not in device_config:
+                        device_config["description"] = ""
+                    if "icon" not in device_config:
+                        device_config["icon"] = ""
+                    if "handles" not in device_config:
+                        device_config["handles"] = []
+                    if "init_param_schema" not in device_config:
+                        device_config["init_param_schema"] = {}
+                    if "class" in device_config:
+                        if (
+                            "status_types" not in device_config["class"]
+                            or device_config["class"]["status_types"] is None
+                        ):
+                            device_config["class"]["status_types"] = {}
+                        if (
+                            "action_value_mappings" not in device_config["class"]
+                            or device_config["class"]["action_value_mappings"] is None
+                        ):
+                            device_config["class"]["action_value_mappings"] = {}
+                        enhanced_info = {}
+                        if complete_registry:
+                            device_config["class"]["status_types"].clear()
+                            enhanced_info = get_enhanced_class_info(device_config["class"]["module"], use_dynamic=True)
+                            if not enhanced_info.get("dynamic_import_success", False):
+                                continue
+                            device_config["class"]["status_types"].update(
+                                {k: v["return_type"] for k, v in enhanced_info["status_methods"].items()}
+                            )
+                        for status_name, status_type in device_config["class"]["status_types"].items():
+                            if isinstance(status_type, tuple) or status_type in ["Any", "None", "Unknown"]:
+                                status_type = "String"  # 替换成ROS的String，便于显示
+                                device_config["class"]["status_types"][status_name] = status_type
+                            try:
+                                target_type = self._replace_type_with_class(
+                                    status_type, device_id, f"状态 {status_name}"
+                                )
+                            except ROSMsgNotFound:
+                                continue
+                            if target_type in [
+                                dict,
+                                list,
+                            ]:  # 对于嵌套类型返回的对象，暂时处理成字符串，无法直接进行转换
+                                target_type = String
+                            status_str_type_mapping[status_type] = target_type
+                        device_config["class"]["status_types"] = dict(
+                            sorted(device_config["class"]["status_types"].items())
+                        )
+                        if complete_registry:
+                            # 保存原有的description信息
+                            old_descriptions = {}
+                            for action_name, action_config in device_config["class"]["action_value_mappings"].items():
+                                if "description" in action_config.get("schema", {}):
+                                    description = action_config["schema"]["description"]
+                                    if len(description):
+                                        old_descriptions[action_name] = action_config["schema"]["description"]

-        # 线程安全地更新注册表
-        current_device_number = len(self.device_type_registry) + 1
-        with self._registry_lock:
-            for file, data, device_ids in results:
-                self.device_type_registry.update(data)
-                for device_id in device_ids:
-                    logger.trace(
-                        f"[UniLab Registry] Device-{current_device_number} Add {device_id} "
+                            device_config["class"]["action_value_mappings"] = {
+                                k: v
+                                for k, v in device_config["class"]["action_value_mappings"].items()
+                                if not k.startswith("auto-")
+                            }
+                            # 处理动作值映射
+                            device_config["class"]["action_value_mappings"].update(
+                                {
+                                    f"auto-{k}": {
+                                        "type": "UniLabJsonCommandAsync" if v["is_async"] else "UniLabJsonCommand",
+                                        "goal": {},
+                                        "feedback": {},
+                                        "result": {},
+                                        "schema": self._generate_unilab_json_command_schema(
+                                            v["args"], k, v.get("return_annotation")
+                                        ),
+                                        "goal_default": {i["name"]: i["default"] for i in v["args"]},
+                                        "handles": [],
+                                        "placeholder_keys": {
+                                            i["name"]: (
+                                                "unilabos_resources"
+                                                if i["type"] == "unilabos.registry.placeholder_type:ResourceSlot"
+                                                or i["type"]
+                                                == ("list", "unilabos.registry.placeholder_type:ResourceSlot")
+                                                else "unilabos_devices"
+                                            )
+                                            for i in v["args"]
+                                            if i.get("type", "")
+                                            in [
+                                                "unilabos.registry.placeholder_type:ResourceSlot",
+                                                "unilabos.registry.placeholder_type:DeviceSlot",
+                                                ("list", "unilabos.registry.placeholder_type:ResourceSlot"),
+                                                ("list", "unilabos.registry.placeholder_type:DeviceSlot"),
+                                            ]
+                                        },
+                                    }
+                                    # 不生成已配置action的动作
+                                    for k, v in enhanced_info["action_methods"].items()
+                                    if k not in device_config["class"]["action_value_mappings"]
+                                }
+                            )
+                            # 恢复原有的description信息（auto开头的不修改）
+                            for action_name, description in old_descriptions.items():
+                                if action_name in device_config["class"]["action_value_mappings"]:  # 有一些会被删除
+                                    device_config["class"]["action_value_mappings"][action_name]["schema"][
+                                        "description"
+                                    ] = description
+                            device_config["init_param_schema"] = {}
+                            device_config["init_param_schema"]["config"] = self._generate_unilab_json_command_schema(
+                                enhanced_info["init_params"], "__init__"
+                            )["properties"]["goal"]
+                            device_config["init_param_schema"]["data"] = self._generate_status_types_schema(
+                                enhanced_info["status_methods"]
+                            )
+
+                        device_config.pop("schema", None)
+                        device_config["class"]["action_value_mappings"] = dict(
+                            sorted(device_config["class"]["action_value_mappings"].items())
+                        )
+                        for action_name, action_config in device_config["class"]["action_value_mappings"].items():
+                            if "handles" not in action_config:
+                                action_config["handles"] = {}
+                            elif isinstance(action_config["handles"], list):
+                                if len(action_config["handles"]):
+                                    logger.error(f"设备{device_id} {action_name} 的handles配置错误，应该是字典类型")
+                                    continue
+                                else:
+                                    action_config["handles"] = {}
+                            if "type" in action_config:
+                                action_type_str: str = action_config["type"]
+                                # 通过Json发放指令，而不是通过特殊的ros action进行处理
+                                if not action_type_str.startswith("UniLabJsonCommand"):
+                                    try:
+                                        target_type = self._replace_type_with_class(
+                                            action_type_str, device_id, f"动作 {action_name}"
+                                        )
+                                    except ROSMsgNotFound:
+                                        continue
+                                    action_str_type_mapping[action_type_str] = target_type
+                                    if target_type is not None:
+                                        action_config["goal_default"] = yaml.safe_load(
+                                            io.StringIO(get_yaml_from_goal_type(target_type.Goal))
+                                        )
+                                        action_config["schema"] = ros_action_to_json_schema(target_type)
+                                    else:
+                                        logger.warning(
+                                            f"[UniLab Registry] 设备 {device_id} 的动作 {action_name} 类型为空，跳过替换"
+                                        )
+                        complete_data[device_id] = copy.deepcopy(dict(sorted(device_config.items())))  # 稍后dump到文件
+                        for status_name, status_type in device_config["class"]["status_types"].items():
+                            device_config["class"]["status_types"][status_name] = status_str_type_mapping[status_type]
+                        for action_name, action_config in device_config["class"]["action_value_mappings"].items():
+                            if action_config["type"] not in action_str_type_mapping:
+                                continue
+                            action_config["type"] = action_str_type_mapping[action_config["type"]]
+                        # 添加内置的驱动命令动作
+                        self._add_builtin_actions(device_config, device_id)
+                    device_config["file_path"] = str(file.absolute()).replace("\\", "/")
+                    device_config["registry_type"] = "device"
+                    logger.trace(  # type: ignore
+                        f"[UniLab Registry] Device-{current_device_number} File-{i+1}/{len(files)} Add {device_id} "
                        + f"[{data[device_id].get('name', '未命名设备')}]"
                    )
                    current_device_number += 1
-
-        # 记录无效文件
-        valid_files = {r[0] for r in results}
-        for file in files:
-            if file not in valid_files:
-                logger.debug(f"[UniLab Registry] Device File Not Valid YAML File: {file.absolute()}")
+                complete_data = dict(sorted(complete_data.items()))
+                complete_data = copy.deepcopy(complete_data)
+                with open(file, "w", encoding="utf-8") as f:
+                    yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
+                self.device_type_registry.update(data)
+            else:
+                logger.debug(
+                    f"[UniLab Registry] Device File-{i+1}/{len(files)} Not Valid YAML File: {file.absolute()}"
+                )

    def obtain_registry_device_info(self):
        devices = []
--- a/unilabos/registry/resources/bioyond/bottles.yaml
+++ b/unilabos/registry/resources/bioyond/bottles.yaml
@@ -20,17 +20,6 @@ BIOYOND_PolymerStation_Liquid_Vial:
  icon: ''
  init_param_schema: {}
  version: 1.0.0
-BIOYOND_PolymerStation_Measurement_Vial:
-  category:
-  - bottles
-  class:
-    module: unilabos.resources.bioyond.bottles:BIOYOND_PolymerStation_Measurement_Vial
-    type: pylabrobot
-  description: 聚合站-测量小瓶（测密度）
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  version: 1.0.0
 BIOYOND_PolymerStation_Reactor:
  category:
  - bottles
--- a/unilabos/registry/resources/opentrons/lab.yaml
+++ b/unilabos/registry/resources/opentrons/lab.yaml
--- a/unilabos/resources/bioyond/YB_warehouses.py
+++ b/unilabos/resources/bioyond/YB_warehouses.py
@@ -84,12 +84,12 @@ def bioyond_warehouse_reagent_storage(name: str) -> WareHouse:
    )

 def bioyond_warehouse_tipbox_storage(name: str) -> WareHouse:
-    """创建BioYond站内Tip盒堆栈（A01～B03, 2行×3列）"""
+    """创建BioYond站内Tip盒堆栈（A01～B03），用于存放枪头盒"""
    return warehouse_factory(
        name=name,
-        num_items_x=3,      # 3列（01-03）
-        num_items_y=2,      # 2行（A-B）
-        num_items_z=1,      # 1层
+        num_items_x=3,  # 3列（01-03）
+        num_items_y=2,  # 2行（A-B）
+        num_items_z=1,  # 1层
        dx=10.0,
        dy=10.0,
        dz=10.0,
@@ -167,7 +167,7 @@ def bioyond_warehouse_1x4x2(name: str) -> WareHouse:

 def bioyond_warehouse_1x2x2(name: str) -> WareHouse:
    """创建BioYond 1x2x2仓库（1列×2行×2层）- 旧版本，已弃用
-
+    
    布局（2层）:
    层1: A01
         B01
@@ -191,7 +191,7 @@ def bioyond_warehouse_1x2x2(name: str) -> WareHouse:

 def bioyond_warehouse_2x2x1(name: str) -> WareHouse:
    """创建BioYond 2x2x1仓库（2行×2列×1层）
-
+    
    布局:
    A01 | A02
    B01 | B02
@@ -246,14 +246,14 @@ def bioyond_warehouse_1x3x3(name: str) -> WareHouse:

 def bioyond_warehouse_5x3x1(name: str, row_offset: int = 0) -> WareHouse:
    """创建BioYond 5x3x1仓库（5行×3列×1层）
-
+    
    标准布局（row_offset=0）:
    A01 | A02 | A03
    B01 | B02 | B03
    C01 | C02 | C03
    D01 | D02 | D03
    E01 | E02 | E03
-
+    
    带偏移布局（row_offset=5）:
    F01 | F02 | F03
    G01 | G02 | G03
@@ -281,7 +281,7 @@ def bioyond_warehouse_5x3x1(name: str, row_offset: int = 0) -> WareHouse:

 def bioyond_warehouse_3x3x1(name: str) -> WareHouse:
    """创建BioYond 3x3x1仓库（3行×3列×1层）
-
+    
    布局:
    A01 | A02 | A03
    B01 | B02 | B03
--- a/unilabos/resources/bioyond/bottles.py
+++ b/unilabos/resources/bioyond/bottles.py
@@ -193,20 +193,3 @@ def BIOYOND_PolymerStation_Flask(
        barcode=barcode,
        model="BIOYOND_PolymerStation_Flask",
    )
-
-def BIOYOND_PolymerStation_Measurement_Vial(
-    name: str,
-    diameter: float = 25.0,
-    height: float = 60.0,
-    max_volume: float = 20000.0,  # 20mL
-    barcode: str = None,
-) -> Bottle:
-    """创建测量小瓶"""
-    return Bottle(
-        name=name,
-        diameter=diameter,
-        height=height,
-        max_volume=max_volume,
-        barcode=barcode,
-        model="BIOYOND_PolymerStation_Measurement_Vial",
-    )
--- a/unilabos/resources/bioyond/decks.py
+++ b/unilabos/resources/bioyond/decks.py
@@ -18,12 +18,9 @@ from unilabos.resources.bioyond.YB_warehouses import (
    bioyond_warehouse_1x8x4,
    bioyond_warehouse_reagent_storage,
    # bioyond_warehouse_liquid_preparation,
+    bioyond_warehouse_tipbox_storage,  # 新增：Tip盒堆栈
    bioyond_warehouse_density_vial,
 )
-from unilabos.resources.bioyond.warehouses import (
-    bioyond_warehouse_tipbox_storage_left,   # 新增：Tip盒堆栈(左)
-    bioyond_warehouse_tipbox_storage_right,  # 新增：Tip盒堆栈(右)
-)


 class BIOYOND_PolymerReactionStation_Deck(Deck):
@@ -50,22 +47,24 @@ class BIOYOND_PolymerReactionStation_Deck(Deck):
            "堆栈1右": bioyond_warehouse_1x4x4_right("堆栈1右"),  # 右侧堆栈: A05～D08
            "站内试剂存放堆栈": bioyond_warehouse_reagent_storage("站内试剂存放堆栈"),  # A01～A02
            # "移液站内10%分装液体准备仓库": bioyond_warehouse_liquid_preparation("移液站内10%分装液体准备仓库"),  # A01～B04
-            "站内Tip盒堆栈(左)": bioyond_warehouse_tipbox_storage_left("站内Tip盒堆栈(左)"),  # A02～B03
-            "站内Tip盒堆栈(右)": bioyond_warehouse_tipbox_storage_right("站内Tip盒堆栈(右)"),  # A01～B01
+            "站内Tip盒堆栈": bioyond_warehouse_tipbox_storage("站内Tip盒堆栈"),  # A01～B03, 存放枪头盒.
            "测量小瓶仓库(测密度)": bioyond_warehouse_density_vial("测量小瓶仓库(测密度)"),  # A01～B03
        }
        self.warehouse_locations = {
-            "堆栈1左": Coordinate(-200.0, 400.0, 0.0),  # 左侧位置
-            "堆栈1右": Coordinate(2350.0, 400.0, 0.0),  # 右侧位置
-            "站内试剂存放堆栈": Coordinate(640.0, 400.0, 0.0),
-            "站内Tip盒堆栈(左)": Coordinate(300.0, 100.0, 0.0),
-            "站内Tip盒堆栈(右)": Coordinate(2250.0, 100.0, 0.0),  # 向右偏移 2 * item_dx (137.0)
-            "测量小瓶仓库(测密度)": Coordinate(1000.0, 530.0, 0.0),
+            "堆栈1左": Coordinate(0.0, 430.0, 0.0),  # 左侧位置
+            "堆栈1右": Coordinate(2500.0, 430.0, 0.0),  # 右侧位置
+            "站内试剂存放堆栈": Coordinate(640.0, 480.0, 0.0),
+            # "移液站内10%分装液体准备仓库": Coordinate(1200.0, 600.0, 0.0),
+            "站内Tip盒堆栈": Coordinate(300.0, 150.0, 0.0),
+            "测量小瓶仓库(测密度)": Coordinate(922.0, 552.0, 0.0),
        }
+        self.warehouses["站内试剂存放堆栈"].rotation = Rotation(z=90)
+        self.warehouses["测量小瓶仓库(测密度)"].rotation = Rotation(z=270)

        for warehouse_name, warehouse in self.warehouses.items():
            self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])

+
 class BIOYOND_PolymerPreparationStation_Deck(Deck):
    def __init__(
        self,
@@ -93,9 +92,9 @@ class BIOYOND_PolymerPreparationStation_Deck(Deck):
            "溶液堆栈": bioyond_warehouse_1x4x4("溶液堆栈"),  # 4行×4列 (A01-D04)
        }
        self.warehouse_locations = {
-            "粉末堆栈": Coordinate(-200.0, 400.0, 0.0),
-            "试剂堆栈": Coordinate(1750.0, 160.0, 0.0),
-            "溶液堆栈": Coordinate(2350.0, 400.0, 0.0),
+            "粉末堆栈": Coordinate(0.0, 450.0, 0.0),
+            "试剂堆栈": Coordinate(1850.0, 200.0, 0.0),
+            "溶液堆栈": Coordinate(2500.0, 450.0, 0.0),
        }

        for warehouse_name, warehouse in self.warehouses.items():
@@ -149,7 +148,6 @@ class BIOYOND_YB_Deck(Deck):

        for warehouse_name, warehouse in self.warehouses.items():
            self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
-
 def YB_Deck(name: str) -> Deck:
    by=BIOYOND_YB_Deck(name=name)
    by.setup()
--- a/unilabos/resources/bioyond/warehouses.py
+++ b/unilabos/resources/bioyond/warehouses.py
@@ -46,80 +46,48 @@ def bioyond_warehouse_1x4x4_right(name: str) -> WareHouse:
    )

 def bioyond_warehouse_density_vial(name: str) -> WareHouse:
-    """创建测量小瓶仓库(测密度) - 竖向排列2列3行
-    布局（从下到上，从左到右）：
-    | A03 | B03 |  ← 顶部
-    | A02 | B02 |  ← 中部
-    | A01 | B01 |  ← 底部
-    """
+    """创建测量小瓶仓库(测密度) A01～B03"""
    return warehouse_factory(
        name=name,
-        num_items_x=2,  # 2列（A, B）
-        num_items_y=3,  # 3行（01-03，从下到上）
+        num_items_x=3,  # 3列（01-03）
+        num_items_y=2,  # 2行（A-B）
        num_items_z=1,  # 1层
        dx=10.0,
        dy=10.0,
        dz=10.0,
-        item_dx=40.0,  # 列间距（A到B的横向距离）
-        item_dy=40.0,  # 行间距（01到02到03的竖向距离）
+        item_dx=40.0,
+        item_dy=40.0,
        item_dz=50.0,
-        # ⭐ 竖向warehouse：槽位尺寸也是竖向的（小瓶已经是正方形，无需调整）
+        # 用更小的 resource_size 来表现 "小点的孔位"
        resource_size_x=30.0,
        resource_size_y=30.0,
        resource_size_z=12.0,
        category="warehouse",
        col_offset=0,
-        layout="vertical-col-major",  # ⭐ 竖向warehouse专用布局
-    )
-
-def bioyond_warehouse_reagent_storage(name: str) -> WareHouse:
-    """创建BioYond站内试剂存放堆栈 - 竖向排列1列2行
-    布局（竖向，从下到上）：
-    | A02 |  ← 顶部
-    | A01 |  ← 底部
-    """
-    return warehouse_factory(
-        name=name,
-        num_items_x=1,  # 1列
-        num_items_y=2,  # 2行（01-02，从下到上）
-        num_items_z=1,  # 1层
-        dx=10.0,
-        dy=10.0,
-        dz=10.0,
-        item_dx=96.0,   # 列间距（这里只有1列，不重要）
-        item_dy=137.0,  # 行间距（A01到A02的竖向距离）
-        item_dz=120.0,
-        # ⭐ 竖向warehouse：交换槽位尺寸，使槽位框也是竖向的
-        resource_size_x=86.0,   # 原来的 resource_size_y
-        resource_size_y=127.0,  # 原来的 resource_size_x
-        resource_size_z=25.0,
-        category="warehouse",
-        layout="vertical-col-major",  # ⭐ 竖向warehouse专用布局
-    )
-
-def bioyond_warehouse_tipbox_storage_left(name: str) -> WareHouse:
-    """创建BioYond站内Tip盒堆栈左侧部分（A02～B03），2列2行"""
-    return warehouse_factory(
-        name=name,
-        num_items_x=2,  # 2列
-        num_items_y=2,  # 2行（A-B）
-        num_items_z=1,  # 1层
-        dx=10.0,
-        dy=10.0,
-        dz=10.0,
-        item_dx=137.0,
-        item_dy=96.0,
-        item_dz=120.0,
-        category="warehouse",
-        col_offset=1,   # 从02开始: A02, A03
        layout="row-major",
    )

-def bioyond_warehouse_tipbox_storage_right(name: str) -> WareHouse:
-    """创建BioYond站内Tip盒堆栈右侧部分（A01～B01），1列2行"""
+def bioyond_warehouse_reagent_storage(name: str) -> WareHouse:
+    """创建BioYond站内试剂存放堆栈（A01～A02, 1行×2列）"""
    return warehouse_factory(
        name=name,
-        num_items_x=1,  # 1列
+        num_items_x=2,  # 2列（01-02）
+        num_items_y=1,  # 1行（A）
+        num_items_z=1,  # 1层
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+    )
+
+def bioyond_warehouse_tipbox_storage(name: str) -> WareHouse:
+    """创建BioYond站内Tip盒堆栈（A01～B03），用于存放枪头盒"""
+    return warehouse_factory(
+        name=name,
+        num_items_x=3,  # 3列（01-03）
        num_items_y=2,  # 2行（A-B）
        num_items_z=1,  # 1层
        dx=10.0,
@@ -129,7 +97,7 @@ def bioyond_warehouse_tipbox_storage_right(name: str) -> WareHouse:
        item_dy=96.0,
        item_dz=120.0,
        category="warehouse",
-        col_offset=0,   # 从01开始: A01
+        col_offset=0,
        layout="row-major",
    )

--- a/unilabos/resources/container.py
+++ b/unilabos/resources/container.py
@@ -1,6 +1,10 @@
+import json
 from typing import Dict, Any

 from pylabrobot.resources import Container
+from unilabos_msgs.msg import Resource
+
+from unilabos.ros.msgs.message_converter import convert_from_ros_msg


 class RegularContainer(Container):
@@ -12,19 +16,20 @@ class RegularContainer(Container):
            kwargs["size_y"] = 0
        if "size_z" not in kwargs:
            kwargs["size_z"] = 0
-
        self.kwargs = kwargs
+        self.state = {}
        super().__init__(*args, category="container", **kwargs)

    def load_state(self, state: Dict[str, Any]):
-        super().load_state(state)
+        self.state = state


 def get_regular_container(name="container"):
    r = RegularContainer(name=name)
    r.category = "container"
-    return r
+    return RegularContainer(name=name)

+#
 # class RegularContainer(object):
 #     # 第一个参数必须是id传入
 #     # noinspection PyShadowingBuiltins
@@ -84,4 +89,4 @@ def get_regular_container(name="container"):
 #         return to_dict
 #
 #     def __str__(self):
-#         return f"{self.id}"
+#         return f"{self.id}"
--- a/unilabos/resources/graphio.py
+++ b/unilabos/resources/graphio.py
@@ -76,7 +76,7 @@ def canonicalize_nodes_data(
            if sample_id:
                logger.error(f"{node}的sample_id参数已弃用，sample_id: {sample_id}")
        for k in list(node.keys()):
-            if k not in ["id", "uuid", "name", "description", "schema", "model", "icon", "parent_uuid", "parent", "type", "class", "position", "config", "data", "children", "pose", "extra"]:
+            if k not in ["id", "uuid", "name", "description", "schema", "model", "icon", "parent_uuid", "parent", "type", "class", "position", "config", "data", "children", "pose"]:
                v = node.pop(k)
                node["config"][k] = v
    if outer_host_node_id is not None:
@@ -151,40 +151,12 @@ def canonicalize_links_ports(links: List[Dict[str, Any]], resource_tree_set: Res
    """
    # 构建 id 到 uuid 的映射
    id_to_uuid: Dict[str, str] = {}
-    uuid_to_id: Dict[str, str] = {}
    for node in resource_tree_set.all_nodes:
        id_to_uuid[node.res_content.id] = node.res_content.uuid
-        uuid_to_id[node.res_content.uuid] = node.res_content.id
-
-    # 第三遍处理：为每个 link 添加 source_uuid 和 target_uuid
-    for link in links:
-        source_id = link.get("source")
-        target_id = link.get("target")
-
-        # 添加 source_uuid
-        if source_id and source_id in id_to_uuid:
-            link["source_uuid"] = id_to_uuid[source_id]
-
-        # 添加 target_uuid
-        if target_id and target_id in id_to_uuid:
-            link["target_uuid"] = id_to_uuid[target_id]
-
-        source_uuid = link.get("source_uuid")
-        target_uuid = link.get("target_uuid")
-
-        # 添加 source_uuid
-        if source_uuid and source_uuid in uuid_to_id:
-            link["source"] = uuid_to_id[source_uuid]
-
-        # 添加 target_uuid
-        if target_uuid and target_uuid in uuid_to_id:
-            link["target"] = uuid_to_id[target_uuid]

    # 第一遍处理：将字符串类型的port转换为字典格式
    for link in links:
        port = link.get("port")
-        if port is None:
-            continue
        if link.get("type", "physical") == "physical":
            link["type"] = "fluid"
        if isinstance(port, int):
@@ -207,15 +179,13 @@ def canonicalize_links_ports(links: List[Dict[str, Any]], resource_tree_set: Res
            link["port"] = {link["source"]: None, link["target"]: None}

    # 构建边字典，键为(source节点, target节点)，值为对应的port信息
-    edges = {(link["source"], link["target"]): link["port"] for link in links if link.get("port")}
+    edges = {(link["source"], link["target"]): link["port"] for link in links}

    # 第二遍处理：填充反向边的dest信息
    delete_reverses = []
    for i, link in enumerate(links):
        s, t = link["source"], link["target"]
-        current_port = link.get("port")
-        if current_port is None:
-            continue
+        current_port = link["port"]
        if current_port.get(t) is None:
            reverse_key = (t, s)
            reverse_port = edges.get(reverse_key)
@@ -230,6 +200,20 @@ def canonicalize_links_ports(links: List[Dict[str, Any]], resource_tree_set: Res
                current_port[t] = current_port[s]
    # 删除已被使用反向端口信息的反向边
    standardized_links = [link for i, link in enumerate(links) if i not in delete_reverses]
+
+    # 第三遍处理：为每个 link 添加 source_uuid 和 target_uuid
+    for link in standardized_links:
+        source_id = link.get("source")
+        target_id = link.get("target")
+
+        # 添加 source_uuid
+        if source_id and source_id in id_to_uuid:
+            link["source_uuid"] = id_to_uuid[source_id]
+
+        # 添加 target_uuid
+        if target_id and target_id in id_to_uuid:
+            link["target_uuid"] = id_to_uuid[target_id]
+
    return standardized_links


@@ -276,7 +260,7 @@ def read_node_link_json(
    resource_tree_set = canonicalize_nodes_data(nodes)

    # 标准化边数据
-    links = data.get("links", data.get("edges", []))
+    links = data.get("links", [])
    standardized_links = canonicalize_links_ports(links, resource_tree_set)

    # 构建 NetworkX 图（需要转换回 dict 格式）
@@ -300,8 +284,6 @@ def modify_to_backend_format(data: list[dict[str, Any]]) -> list[dict[str, Any]]
            edge["sourceHandle"] = port[source]
        elif "source_port" in edge:
            edge["sourceHandle"] = edge.pop("source_port")
-        elif "source_handle" in edge:
-            edge["sourceHandle"] = edge.pop("source_handle")
        else:
            typ = edge.get("type")
            if typ == "communication":
@@ -310,8 +292,6 @@ def modify_to_backend_format(data: list[dict[str, Any]]) -> list[dict[str, Any]]
            edge["targetHandle"] = port[target]
        elif "target_port" in edge:
            edge["targetHandle"] = edge.pop("target_port")
-        elif "target_handle" in edge:
-            edge["targetHandle"] = edge.pop("target_handle")
        else:
            typ = edge.get("type")
            if typ == "communication":
@@ -617,8 +597,6 @@ def resource_plr_to_ulab(resource_plr: "ResourcePLR", parent_name: str = None, w
            "tube": "tube",
            "bottle_carrier": "bottle_carrier",
            "plate_adapter": "plate_adapter",
-            "electrode_sheet": "electrode_sheet",
-            "material_hole": "material_hole",
        }
        if source in replace_info:
            return replace_info[source]
@@ -801,22 +779,6 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
            if not locations:
                logger.debug(f"[物料位置] {unique_name} 没有location信息，跳过warehouse放置")

-            # ⭐ 预先检查：如果物料的任何location在竖向warehouse中，提前交换尺寸
-            # 这样可以避免多个location时尺寸不一致的问题
-            needs_size_swap = False
-            for loc in locations:
-                wh_name_check = loc.get("whName")
-                if wh_name_check in ["站内试剂存放堆栈", "测量小瓶仓库(测密度)"]:
-                    needs_size_swap = True
-                    break
-
-            if needs_size_swap and hasattr(plr_material, 'size_x') and hasattr(plr_material, 'size_y'):
-                original_x = plr_material.size_x
-                original_y = plr_material.size_y
-                plr_material.size_x = original_y
-                plr_material.size_y = original_x
-                logger.debug(f"   物料 {unique_name} 将放入竖向warehouse，预先交换尺寸: {original_x}×{original_y} → {plr_material.size_x}×{plr_material.size_y}")
-
            for loc in locations:
                wh_name = loc.get("whName")
                logger.debug(f"[物料位置] {unique_name} 尝试放置到 warehouse: {wh_name} (Bioyond坐标: x={loc.get('x')}, y={loc.get('y')}, z={loc.get('z')})")
@@ -833,20 +795,12 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
                        logger.warning(f"物料 {material['name']} 的列号 x={x_val} 超出范围，无法映射到堆栈1左或堆栈1右")
                        continue

-                # 特殊处理: Bioyond的"站内Tip盒堆栈"也需要进行拆分映射
-                if wh_name == "站内Tip盒堆栈":
-                    y_val = loc.get("y", 1)
-                    if y_val == 1:
-                        wh_name = "站内Tip盒堆栈(右)"
-                    elif y_val in [2, 3]:
-                        wh_name = "站内Tip盒堆栈(左)"
-                        y = y - 1  # 调整列号，因为左侧仓库对应的 Bioyond y=2 实际上是它的第1列
-
                if hasattr(deck, "warehouses") and wh_name in deck.warehouses:
                    warehouse = deck.warehouses[wh_name]
                    logger.debug(f"[Warehouse匹配] 找到warehouse: {wh_name} (容量: {warehouse.capacity}, 行×列: {warehouse.num_items_x}×{warehouse.num_items_y})")

                    # Bioyond坐标映射 (重要！): x→行(1=A,2=B...), y→列(1=01,2=02...), z→层(通常=1)
+                    # PyLabRobot warehouse是列优先存储: A01,B01,C01,D01, A02,B02,C02,D02, ...
                    x = loc.get("x", 1)  # 行号 (1-based: 1=A, 2=B, 3=C, 4=D)
                    y = loc.get("y", 1)  # 列号 (1-based: 1=01, 2=02, 3=03...)
                    z = loc.get("z", 1)  # 层号 (1-based, 通常为1)
@@ -855,23 +809,12 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
                    if wh_name == "堆栈1右":
                        y = y - 4  # 将5-8映射到1-4

-                    # 特殊处理竖向warehouse（站内试剂存放堆栈、测量小瓶仓库）
-                    # 这些warehouse使用 vertical-col-major 布局
-                    if wh_name in ["站内试剂存放堆栈", "测量小瓶仓库(测密度)"]:
-                        # vertical-col-major 布局的坐标映射：
-                        # - Bioyond的x(1=A,2=B)对应warehouse的列(col, x方向)
-                        # - Bioyond的y(1=01,2=02,3=03)对应warehouse的行(row, y方向)，从下到上
-                        # vertical-col-major 中: row=0 对应底部，row=n-1 对应顶部
-                        # Bioyond y=1(01) 对应底部 → row=0, y=2(02) 对应中间 → row=1
-                        # 索引计算: idx = row * num_cols + col
-                        col_idx = x - 1  # Bioyond的x(A,B) → col索引(0,1)
-                        row_idx = y - 1  # Bioyond的y(01,02,03) → row索引(0,1,2)
-                        layer_idx = z - 1
-
-                        idx = layer_idx * (warehouse.num_items_x * warehouse.num_items_y) + row_idx * warehouse.num_items_y + col_idx
-                        logger.debug(f"🔍 竖向warehouse {wh_name}: Bioyond(x={x},y={y},z={z}) → warehouse(col={col_idx},row={row_idx},layer={layer_idx}) → idx={idx}, capacity={warehouse.capacity}")
-
-                    # 普通横向warehouse的处理
+                    # 特殊处理：对于1行×N列的横向warehouse（如站内试剂存放堆栈）
+                    # Bioyond的y坐标表示线性位置序号，而不是列号
+                    if warehouse.num_items_y == 1:
+                        # 1行warehouse: 直接用y作为线性索引
+                        idx = y - 1
+                        logger.debug(f"1行warehouse {wh_name}: y={y} → idx={idx}")
                    else:
                        # 多行warehouse: 根据 layout 使用不同的索引计算
                        row_idx = x - 1  # x表示行: 转为0-based
@@ -895,7 +838,6 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st

                    if 0 <= idx < warehouse.capacity:
                        if warehouse[idx] is None or isinstance(warehouse[idx], ResourceHolder):
-                            # 物料尺寸已在放入warehouse前根据需要进行了交换
                            warehouse[idx] = plr_material
                            logger.debug(f"✅ 物料 {unique_name} 放置到 {wh_name}[{idx}] (Bioyond坐标: x={loc.get('x')}, y={loc.get('y')})")
                    else:
@@ -1069,24 +1011,11 @@ def resource_plr_to_bioyond(plr_resources: list[ResourcePLR], type_mapping: dict
                logger.debug(f"  📭 [单瓶物料] {resource.name} 无液体，使用资源名: {material_name}")

            # 🎯 处理物料默认参数和单位
-            # 优先级: typeId参数 > 物料名称参数 > 默认值
+            # 检查是否有该物料名称的默认参数配置
            default_unit = "个"  # 默认单位
            material_parameters = {}

-            # 1️⃣ 首先检查是否有 typeId 对应的参数配置（从 material_params 中获取，key 格式为 "type:<typeId>"）
-            type_params_key = f"type:{type_id}"
-            if type_params_key in material_params:
-                params_config = material_params[type_params_key].copy()
-
-                # 提取 unit 字段（如果有）
-                if "unit" in params_config:
-                    default_unit = params_config.pop("unit")  # 从参数中移除，放到外层
-
-                # 剩余的字段放入 Parameters
-                material_parameters = params_config
-                logger.debug(f"  🔧 [物料参数-按typeId] 为 typeId={type_id[:8]}... 应用配置: unit={default_unit}, parameters={material_parameters}")
-            # 2️⃣ 其次检查是否有该物料名称的默认参数配置
-            elif material_name in material_params:
+            if material_name in material_params:
                params_config = material_params[material_name].copy()

                # 提取 unit 字段（如果有）
@@ -1095,7 +1024,7 @@ def resource_plr_to_bioyond(plr_resources: list[ResourcePLR], type_mapping: dict

                # 剩余的字段放入 Parameters
                material_parameters = params_config
-                logger.debug(f"  🔧 [物料参数-按名称] 为 {material_name} 应用配置: unit={default_unit}, parameters={material_parameters}")
+                logger.debug(f"  🔧 [物料参数] 为 {material_name} 应用配置: unit={default_unit}, parameters={material_parameters}")

            # 转换为 JSON 字符串
            parameters_json = json.dumps(material_parameters) if material_parameters else "{}"
@@ -1222,7 +1151,11 @@ def initialize_resource(resource_config: dict, resource_type: Any = None) -> Uni
        if resource_class_config["type"] == "pylabrobot":
            resource_plr = RESOURCE(name=resource_config["name"])
            if resource_type != ResourcePLR:
-                tree_sets = ResourceTreeSet.from_plr_resources([resource_plr], known_newly_created=True)
+                tree_sets = ResourceTreeSet.from_plr_resources([resource_plr])
+                # r = resource_plr_to_ulab(resource_plr=resource_plr, parent_name=resource_config.get("parent", None))
+                # # r = resource_plr_to_ulab(resource_plr=resource_plr)
+                # if resource_config.get("position") is not None:
+                #     r["position"] = resource_config["position"]
                r = tree_sets.dump()
            else:
                r = resource_plr
--- a/unilabos/resources/itemized_carrier.py
+++ b/unilabos/resources/itemized_carrier.py
@@ -50,45 +50,12 @@ class Bottle(Well):
        self.barcode = barcode

    def serialize(self) -> dict:
-        # Pylabrobot expects barcode to be an object with serialize(), but here it is a str.
-        # We temporarily unset it to avoid AttributeError in super().serialize().
-        _barcode = self.barcode
-        self.barcode = None
-        try:
-            data = super().serialize()
-        finally:
-            self.barcode = _barcode
-
        return {
-            **data,
+            **super().serialize(),
            "diameter": self.diameter,
            "height": self.height,
        }

-    @classmethod
-    def deserialize(cls, data: dict, allow_marshal: bool = False):
-        # Extract barcode before calling parent deserialize to avoid type error
-        barcode_data = data.pop("barcode", None)
-
-        # Call parent deserialize
-        instance = super(Bottle, cls).deserialize(data, allow_marshal=allow_marshal)
-
-        # Set barcode as string (not as Barcode object)
-        if barcode_data:
-            if isinstance(barcode_data, str):
-                instance.barcode = barcode_data
-            elif isinstance(barcode_data, dict):
-                # If it's a dict (Barcode serialized format), extract the data field
-                instance.barcode = barcode_data.get("data", "")
-        else:
-            instance.barcode = ""
-
-        # Set additional attributes
-        instance.diameter = data.get("diameter", instance._size_x)
-        instance.height = data.get("height", instance._size_z)
-
-        return instance
-
 T = TypeVar("T", bound=ResourceHolder)

 S = TypeVar("S", bound=ResourceHolder)
--- a/unilabos/resources/lab_resources.py
+++ b/unilabos/resources/lab_resources.py
--- a/unilabos/resources/opentrons_custom_labware_defs.json
+++ b/unilabos/resources/opentrons_custom_labware_defs.json
--- a/unilabos/resources/resource_tracker.py
+++ b/unilabos/resources/resource_tracker.py
@@ -1,12 +1,10 @@
 import inspect
 import traceback
 import uuid
-from pydantic import BaseModel, field_serializer, field_validator, ValidationError
+from pydantic import BaseModel, field_serializer, field_validator
 from pydantic import Field
 from typing import List, Tuple, Any, Dict, Literal, Optional, cast, TYPE_CHECKING, Union

-from typing_extensions import TypedDict
-
 from unilabos.resources.plr_additional_res_reg import register
 from unilabos.utils.log import logger

@@ -15,84 +13,24 @@ if TYPE_CHECKING:
    from pylabrobot.resources import Resource as PLRResource


-EXTRA_CLASS = "unilabos_resource_class"
-FRONTEND_POSE_EXTRA = "unilabos_frontend_pose_extra"
-EXTRA_SAMPLE_UUID = "sample_uuid"
-EXTRA_UNILABOS_SAMPLE_UUID = "unilabos_sample_uuid"
-
-# 函数参数名常量 - 用于自动注入 sample_uuids 列表
-PARAM_SAMPLE_UUIDS = "sample_uuids"
-
-# JSON Command 中的系统参数字段名
-JSON_UNILABOS_PARAM = "unilabos_param"
-
-# 返回值中的 samples 字段名
-RETURN_UNILABOS_SAMPLES = "unilabos_samples"
-
-# sample_uuids 参数类型 (用于 virtual bench 等设备添加 sample_uuids 参数)
-SampleUUIDsType = Dict[str, Optional["PLRResource"]]
-
-
-class LabSample(TypedDict):
-    sample_uuid: str
-    oss_path: str
-    extra: Dict[str, Any]
-
-
-class ResourceDictPositionSizeType(TypedDict):
-    depth: float
-    width: float
-    height: float
-
-
 class ResourceDictPositionSize(BaseModel):
    depth: float = Field(description="Depth", default=0.0)  # z
    width: float = Field(description="Width", default=0.0)  # x
    height: float = Field(description="Height", default=0.0)  # y


-class ResourceDictPositionScaleType(TypedDict):
-    x: float
-    y: float
-    z: float
-
-
 class ResourceDictPositionScale(BaseModel):
    x: float = Field(description="x scale", default=0.0)
    y: float = Field(description="y scale", default=0.0)
    z: float = Field(description="z scale", default=0.0)


-class ResourceDictPositionObjectType(TypedDict):
-    x: float
-    y: float
-    z: float
-
-
 class ResourceDictPositionObject(BaseModel):
    x: float = Field(description="X coordinate", default=0.0)
    y: float = Field(description="Y coordinate", default=0.0)
    z: float = Field(description="Z coordinate", default=0.0)


-class ResourceDictPoseExtraObjectType(BaseModel):
-    z_index: int
-
-
-class ResourceDictPoseExtraObject(BaseModel):
-    z_index: Optional[int] = Field(alias="zIndex", default=None)
-
-
-class ResourceDictPositionType(TypedDict):
-    size: ResourceDictPositionSizeType
-    scale: ResourceDictPositionScaleType
-    layout: Literal["2d", "x-y", "z-y", "x-z"]
-    position: ResourceDictPositionObjectType
-    position3d: ResourceDictPositionObjectType
-    rotation: ResourceDictPositionObjectType
-    cross_section_type: Literal["rectangle", "circle", "rounded_rectangle"]
-
-
 class ResourceDictPosition(BaseModel):
    size: ResourceDictPositionSize = Field(description="Resource size", default_factory=ResourceDictPositionSize)
    scale: ResourceDictPositionScale = Field(description="Resource scale", default_factory=ResourceDictPositionScale)
@@ -109,25 +47,6 @@ class ResourceDictPosition(BaseModel):
    cross_section_type: Literal["rectangle", "circle", "rounded_rectangle"] = Field(
        description="Cross section type", default="rectangle"
    )
-    extra: Optional[ResourceDictPoseExtraObject] = Field(description="Extra data", default=None)
-
-
-class ResourceDictType(TypedDict):
-    id: str
-    uuid: str
-    name: str
-    description: str
-    resource_schema: Dict[str, Any]
-    model: Dict[str, Any]
-    icon: str
-    parent_uuid: Optional[str]
-    parent: Optional["ResourceDictType"]
-    type: Union[Literal["device"], str]
-    klass: str
-    pose: ResourceDictPositionType
-    config: Dict[str, Any]
-    data: Dict[str, Any]
-    extra: Dict[str, Any]


 # 统一的资源字典模型，parent 自动序列化为 parent_uuid，children 不序列化
@@ -228,24 +147,20 @@ class ResourceDictInstance(object):
        if not content.get("extra"):  # MagicCode
            content["extra"] = {}
        if "position" in content:
-            pose = content.get("pose", {})
-            if "position" not in pose:
+            pose = content.get("pose",{})
+            if "position" not in pose :
                if "position" in content["position"]:
                    pose["position"] = content["position"]["position"]
                else:
                    pose["position"] = {"x": 0, "y": 0, "z": 0}
            if "size" not in pose:
                pose["size"] = {
-                    "width": content["config"].get("size_x", 0),
-                    "height": content["config"].get("size_y", 0),
-                    "depth": content["config"].get("size_z", 0),
+                    "width": content["config"].get("size_x", 0), 
+                    "height": content["config"].get("size_y", 0), 
+                    "depth": content["config"].get("size_z", 0)
                }
            content["pose"] = pose
-        try:
-            res_dict = ResourceDict.model_validate(content)
-            return ResourceDictInstance(res_dict)
-        except ValidationError as err:
-            raise err
+        return ResourceDictInstance(ResourceDict.model_validate(content))

    def get_plr_nested_dict(self) -> Dict[str, Any]:
        """获取资源实例的嵌套字典表示"""
@@ -407,7 +322,7 @@ class ResourceTreeSet(object):
            )

    @classmethod
-    def from_plr_resources(cls, resources: List["PLRResource"], known_newly_created=False) -> "ResourceTreeSet":
+    def from_plr_resources(cls, resources: List["PLRResource"]) -> "ResourceTreeSet":
        """
        从plr资源创建ResourceTreeSet
        """
@@ -421,20 +336,9 @@ class ResourceTreeSet(object):
                "tip_spot": "tip_spot",
                "tube": "tube",
                "bottle_carrier": "bottle_carrier",
-                "material_hole": "material_hole",
-                "container": "container",
-                "material_plate": "material_plate",
-                "electrode_sheet": "electrode_sheet",
-                "warehouse": "warehouse",
-                "magazine_holder": "magazine_holder",
-                "resource_group": "resource_group",
-                "trash": "trash",
-                "plate_adapter": "plate_adapter",
            }
            if source in replace_info:
                return replace_info[source]
-            elif source is None:
-                return ""
            else:
                print("转换pylabrobot的时候，出现未知类型", source)
                return source
@@ -445,8 +349,7 @@ class ResourceTreeSet(object):
            if not uid:
                uid = str(uuid.uuid4())
                res.unilabos_uuid = uid
-                if not known_newly_created:
-                    logger.warning(f"{res}没有uuid，请设置后再传入，默认填充{uid}！\n{traceback.format_exc()}")
+                logger.warning(f"{res}没有uuid，请设置后再传入，默认填充{uid}！\n{traceback.format_exc()}")

            # 获取unilabos_extra，默认为空字典
            extra = getattr(res, "unilabos_extra", {})
@@ -473,7 +376,6 @@ class ResourceTreeSet(object):
                "position3d": raw_pos,
                "rotation": d["rotation"],
                "cross_section_type": d.get("cross_section_type", "rectangle"),
-                "extra": extra.get(FRONTEND_POSE_EXTRA)
            }

            # 先构建当前节点的字典（不包含children）
@@ -484,7 +386,7 @@ class ResourceTreeSet(object):
                "parent": parent_resource,  # 直接传入 ResourceDict 对象
                "parent_uuid": parent_uuid,  # 使用 parent_uuid 而不是 parent 对象
                "type": replace_plr_type(d.get("category", "")),
-                "class": extra.get(EXTRA_CLASS, ""),
+                "class": d.get("class", ""),
                "position": pos,
                "pose": pos,
                "config": {
@@ -534,17 +436,10 @@ class ResourceTreeSet(object):
            trees.append(tree_instance)
        return cls(trees)

-    def to_plr_resources(
-        self, skip_devices: bool = True, requested_uuids: Optional[List[str]] = None
-    ) -> List["PLRResource"]:
+    def to_plr_resources(self) -> List["PLRResource"]:
        """
        将 ResourceTreeSet 转换为 PLR 资源列表

-        Args:
-            skip_devices: 是否跳过 device 类型节点
-            requested_uuids: 若指定，则按此 UUID 顺序返回对应资源（用于批量查询时一一对应），
-                否则返回各树的根节点列表
-
        Returns:
            List[PLRResource]: PLR 资源实例列表
        """
@@ -553,21 +448,13 @@ class ResourceTreeSet(object):
        from pylabrobot.utils.object_parsing import find_subclass

        # 类型映射
-        TYPE_MAP = {
-            "plate": "Plate",
-            "well": "Well",
-            "deck": "Deck",
-            "container": "RegularContainer",
-            "tip_spot": "TipSpot",
-        }
+        TYPE_MAP = {"plate": "Plate", "well": "Well", "deck": "Deck", "container": "RegularContainer", "tip_spot": "TipSpot"}

        def collect_node_data(node: ResourceDictInstance, name_to_uuid: dict, all_states: dict, name_to_extra: dict):
            """一次遍历收集 name_to_uuid, all_states 和 name_to_extra"""
            name_to_uuid[node.res_content.name] = node.res_content.uuid
            all_states[node.res_content.name] = node.res_content.data
            name_to_extra[node.res_content.name] = node.res_content.extra
-            name_to_extra[node.res_content.name][FRONTEND_POSE_EXTRA] = node.res_content.pose.extra
-            name_to_extra[node.res_content.name][EXTRA_CLASS] = node.res_content.klass
            for child in node.children:
                collect_node_data(child, name_to_uuid, all_states, name_to_extra)

@@ -600,71 +487,6 @@ class ResourceTreeSet(object):
                d["model"] = res.config.get("model", None)
            return d

-        # deserialize 会单独处理的元数据 key，不传给构造函数
-        _META_KEYS = {"type", "parent_name", "location", "children", "rotation", "barcode"}
-        # deserialize 自定义逻辑使用的 key（如 TipSpot 用 prototype_tip 构建 make_tip），需保留
-        _DESERIALIZE_PRESERVED_KEYS = {"prototype_tip"}
-
-        def remove_incompatible_params(plr_d: dict) -> None:
-            """递归移除 PLR 类不接受的参数，避免 deserialize 报错。
-            - 移除构造函数不接受的参数（如 compute_height_from_volume、ordering、category）
-            - 对 TubeRack：将 ordering 转为 ordered_items
-            - 保留 deserialize 自定义逻辑需要的 key（如 prototype_tip）
-            """
-            if "type" in plr_d:
-                sub_cls = find_subclass(plr_d["type"], PLRResource)
-                if sub_cls is not None:
-                    spec = inspect.signature(sub_cls)
-                    valid_params = set(spec.parameters.keys())
-                    # TubeRack 特殊处理：先转换 ordering，再参与后续过滤
-                    if "ordering" not in valid_params and "ordering" in plr_d:
-                        ordering = plr_d.pop("ordering", None)
-                        if sub_cls.__name__ == "TubeRack":
-                            plr_d["ordered_items"] = (
-                                _ordering_to_ordered_items(plr_d, ordering)
-                                if ordering
-                                else {}
-                            )
-                    # 移除构造函数不接受的参数（保留 META 和 deserialize 自定义逻辑需要的 key）
-                    for key in list(plr_d.keys()):
-                        if (
-                            key not in _META_KEYS
-                            and key not in _DESERIALIZE_PRESERVED_KEYS
-                            and key not in valid_params
-                        ):
-                            plr_d.pop(key, None)
-            for child in plr_d.get("children", []):
-                remove_incompatible_params(child)
-
-        def _ordering_to_ordered_items(plr_d: dict, ordering: dict) -> dict:
-            """将 ordering 转为 ordered_items，从 children 构建 Tube 对象"""
-            from pylabrobot.resources import Tube, Coordinate
-            from pylabrobot.serializer import deserialize as plr_deserialize
-
-            children = plr_d.get("children", [])
-            ordered_items = {}
-            for idx, (ident, child_name) in enumerate(ordering.items()):
-                child_data = children[idx] if idx < len(children) else None
-                if child_data is None:
-                    continue
-                loc_data = child_data.get("location")
-                loc = (
-                    plr_deserialize(loc_data)
-                    if loc_data
-                    else Coordinate(0, 0, 0)
-                )
-                tube = Tube(
-                    name=child_data.get("name", child_name or ident),
-                    size_x=child_data.get("size_x", 10),
-                    size_y=child_data.get("size_y", 10),
-                    size_z=child_data.get("size_z", 50),
-                    max_volume=child_data.get("max_volume", 1000),
-                )
-                tube.location = loc
-                ordered_items[ident] = tube
-            plr_d["children"] = []  # 已并入 ordered_items，避免重复反序列化
-            return ordered_items
-
        plr_resources = []
        tracker = DeviceNodeResourceTracker()

@@ -677,20 +499,14 @@ class ResourceTreeSet(object):
            plr_dict = node_to_plr_dict(tree.root_node, has_model)
            try:
                sub_cls = find_subclass(plr_dict["type"], PLRResource)
-                if skip_devices and plr_dict["type"] == "device":
-                    logger.info(f"跳过更新 {plr_dict['name']} 设备是class")
-                    continue
-                elif sub_cls is None:
+                if sub_cls is None:
                    raise ValueError(
                        f"无法找到类型 {plr_dict['type']} 对应的 PLR 资源类。原始信息：{tree.root_node.res_content}"
                    )
-                remove_incompatible_params(plr_dict)
+                spec = inspect.signature(sub_cls)
+                if "category" not in spec.parameters:
+                    plr_dict.pop("category", None)
                plr_resource = sub_cls.deserialize(plr_dict, allow_marshal=True)
-                from pylabrobot.resources import Coordinate
-                from pylabrobot.serializer import deserialize
-
-                location = cast(Coordinate, deserialize(plr_dict["location"]))
-                plr_resource.location = location
                plr_resource.load_all_state(all_states)
                # 使用 DeviceNodeResourceTracker 设置 UUID 和 Extra
                tracker.loop_set_uuid(plr_resource, name_to_uuid)
@@ -704,41 +520,6 @@ class ResourceTreeSet(object):
                logger.error(f"堆栈: {traceback.format_exc()}")
                raise

-        if requested_uuids:
-            # 按请求的 UUID 顺序返回对应资源（从整棵树中按 uuid 提取）
-            # 优先使用 tracker.uuid_to_resources；若映射缺失，再递归遍历 PLR 树兜底搜索。
-            def _find_plr_by_uuid(roots: List["PLRResource"], uid: str) -> Optional["PLRResource"]:
-                stack = list(roots)
-                while stack:
-                    node = stack.pop()
-                    node_uid = getattr(node, "unilabos_uuid", None)
-                    if node_uid == uid:
-                        return node
-                    children = getattr(node, "children", None) or []
-                    stack.extend(children)
-                return None
-
-            result = []
-            missing_uuids = []
-            for uid in requested_uuids:
-                found = tracker.uuid_to_resources.get(uid)
-                if found is None:
-                    found = _find_plr_by_uuid(plr_resources, uid)
-                    if found is not None:
-                        # 回填缓存，后续相同 uuid 可直接命中
-                        tracker.uuid_to_resources[uid] = found
-                if found is None:
-                    missing_uuids.append(uid)
-                else:
-                    result.append(found)
-
-            if missing_uuids:
-                raise ValueError(
-                    f"请求的 UUID 未在资源树中找到: {missing_uuids}。"
-                    f"可用 UUID 数量: {len(tracker.uuid_to_resources)}，"
-                    f"资源树数量: {len(self.trees)}"
-                )
-            return result
        return plr_resources

    @classmethod
@@ -827,16 +608,6 @@ class ResourceTreeSet(object):
        """
        return [tree.root_node for tree in self.trees]

-    @property
-    def root_nodes_uuid(self) -> List[ResourceDictInstance]:
-        """
-        获取所有树的根节点
-
-        Returns:
-            所有根节点的资源实例列表
-        """
-        return [tree.root_node.res_content.uuid for tree in self.trees]
-
    @property
    def all_nodes(self) -> List[ResourceDictInstance]:
        """
@@ -1147,33 +918,6 @@ class DeviceNodeResourceTracker(object):

        return self._traverse_and_process(resource, process)

-    def loop_find_with_uuid(self, resource, target_uuid: str):
-        """
-        递归遍历资源树，根据 uuid 查找并返回对应的资源
-
-        Args:
-            resource: 资源对象（可以是list、dict或实例）
-            target_uuid: 要查找的uuid
-
-        Returns:
-            找到的资源对象，未找到则返回None
-        """
-        found_resource = None
-
-        def process(res):
-            nonlocal found_resource
-            if found_resource is not None:
-                return 0  # 已找到，跳过后续处理
-            current_uuid = self._get_resource_attr(res, "uuid", "unilabos_uuid")
-            if current_uuid and current_uuid == target_uuid:
-                found_resource = res
-                logger.trace(f"找到资源UUID: {target_uuid}")
-                return 1
-            return 0
-
-        self._traverse_and_process(resource, process)
-        return found_resource
-
    def loop_set_extra(self, resource, name_to_extra_map: Dict[str, dict]) -> int:
        """
        递归遍历资源树，根据 name 设置所有节点的 extra
@@ -1192,7 +936,7 @@ class DeviceNodeResourceTracker(object):
                extra = name_to_extra_map[resource_name]
                self.set_resource_extra(res, extra)
                if len(extra):
-                    logger.trace(f"设置资源Extra: {resource_name} -> {extra}")
+                    logger.debug(f"设置资源Extra: {resource_name} -> {extra}")
                return 1
            return 0

@@ -1359,7 +1103,7 @@ class DeviceNodeResourceTracker(object):
        for key in keys_to_remove:
            self.resource2parent_resource.pop(key, None)

-        logger.trace(f"[ResourceTracker] 成功移除资源: {resource}")
+        logger.debug(f"成功移除资源: {resource}")
        return True

    def clear_resource(self):
--- a/unilabos/resources/warehouse.py
+++ b/unilabos/resources/warehouse.py
@@ -43,10 +43,6 @@ def warehouse_factory(
                if layout == "row-major":
                    # 行优先：row=0(A行) 应该显示在上方，需要较小的 y 值
                    y = dy + row * item_dy
-                elif layout == "vertical-col-major":
-                    # 竖向warehouse: row=0 对应顶部（y小），row=n-1 对应底部（y大）
-                    # 但标签 01 应该在底部，所以使用反向映射
-                    y = dy + (num_items_y - row - 1) * item_dy
                else:
                    # 列优先：保持原逻辑（row=0 对应较大的 y）
                    y = dy + (num_items_y - row - 1) * item_dy
--- a/unilabos/ros/device_node_wrapper.py
+++ b/unilabos/ros/device_node_wrapper.py
@@ -44,7 +44,8 @@ def ros2_device_node(
    # 从属性中自动发现可发布状态
    if status_types is None:
        status_types = {}
-    assert device_config is not None, "device_config cannot be None"
+    if device_config is None:
+        raise ValueError("device_config cannot be None")
    if action_value_mappings is None:
        action_value_mappings = {}
    if hardware_interface is None:
--- a/unilabos/ros/main_slave_run.py
+++ b/unilabos/ros/main_slave_run.py
@@ -51,7 +51,6 @@ def main(
    bridges: List[Any] = [],
    visual: str = "disable",
    resources_mesh_config: dict = {},
-    resources_mesh_resource_list: list = [],
    rclpy_init_args: List[str] = ["--log-level", "debug"],
    discovery_interval: float = 15.0,
 ) -> None:
@@ -78,12 +77,12 @@ def main(
    if visual != "disable":
        from unilabos.ros.nodes.presets.joint_republisher import JointRepublisher

-        # 优先使用从 main.py 传入的完整资源列表（包含所有子资源）
-        if resources_mesh_resource_list:
-            resources_list = resources_mesh_resource_list
-        else:
-            # fallback: 从 ResourceTreeSet 获取
-            resources_list = [node.res_content.model_dump(by_alias=True) for node in resources_config.all_nodes]
+        # 将 ResourceTreeSet 转换为 list 用于 visual 组件
+        resources_list = (
+            [node.res_content.model_dump(by_alias=True) for node in resources_config.all_nodes]
+            if resources_config
+            else []
+        )
        resource_mesh_manager = ResourceMeshManager(
            resources_mesh_config,
            resources_list,
@@ -91,7 +90,7 @@ def main(
            device_id="resource_mesh_manager",
            device_uuid=str(uuid.uuid4()),
        )
-        joint_republisher = JointRepublisher("joint_republisher","joint_republisher", host_node.resource_tracker)
+        joint_republisher = JointRepublisher("joint_republisher", host_node.resource_tracker)
        # lh_joint_pub = LiquidHandlerJointPublisher(
        #     resources_config=resources_list, resource_tracker=host_node.resource_tracker
        # )
@@ -115,7 +114,6 @@ def slave(
    bridges: List[Any] = [],
    visual: str = "disable",
    resources_mesh_config: dict = {},
-    resources_mesh_resource_list: list = [],
    rclpy_init_args: List[str] = ["--log-level", "debug"],
 ) -> None:
    """从节点函数"""
@@ -210,12 +208,12 @@ def slave(
    if visual != "disable":
        from unilabos.ros.nodes.presets.joint_republisher import JointRepublisher

-        # 优先使用从 main.py 传入的完整资源列表（包含所有子资源）
-        if resources_mesh_resource_list:
-            resources_list = resources_mesh_resource_list
-        else:
-            # fallback: 从 ResourceTreeSet 获取
-            resources_list = [node.res_content.model_dump(by_alias=True) for node in resources_config.all_nodes]
+        # 将 ResourceTreeSet 转换为 list 用于 visual 组件
+        resources_list = (
+            [node.res_content.model_dump(by_alias=True) for node in resources_config.all_nodes]
+            if resources_config
+            else []
+        )
        resource_mesh_manager = ResourceMeshManager(
            resources_mesh_config,
            resources_list,
--- a/unilabos/ros/msgs/message_converter.py
+++ b/unilabos/ros/msgs/message_converter.py
@@ -159,14 +159,10 @@ _msg_converter: Dict[Type, Any] = {
            else Pose()
        ),
        config=json.dumps(x.get("config", {})),
-        data=json.dumps(obtain_data_with_uuid(x)),
+        data=json.dumps(x.get("data", {})),
    ),
 }

-def obtain_data_with_uuid(x: dict):
-    data = x.get("data", {})
-    data["unilabos_uuid"] = x.get("uuid", None)
-    return data

 def json_or_yaml_loads(data: str) -> Any:
    try:
@@ -770,16 +766,13 @@ def ros_message_to_json_schema(msg_class: Any, field_name: str) -> Dict[str, Any
    return schema


-def ros_action_to_json_schema(
-    action_class: Any, description="", previous_schema: Optional[Dict[str, Any]] = None
-) -> Dict[str, Any]:
+def ros_action_to_json_schema(action_class: Any, description="") -> Dict[str, Any]:
    """
    将 ROS Action 类转换为 JSON Schema

    Args:
        action_class: ROS Action 类
        description: 描述
-        previous_schema: 之前的 schema，用于保留 goal/feedback/result 下一级字段的 description

    Returns:
        完整的 JSON Schema 定义
@@ -813,44 +806,9 @@ def ros_action_to_json_schema(
        "required": ["goal"],
    }

-    # 保留之前 schema 中 goal/feedback/result 下一级字段的 description
-    if previous_schema:
-        _preserve_field_descriptions(schema, previous_schema)
-
    return schema


-def _preserve_field_descriptions(
-    new_schema: Dict[str, Any], previous_schema: Dict[str, Any]
-) -> None:
-    """
-    保留之前 schema 中 goal/feedback/result 下一级字段的 description 和 title
-
-    Args:
-        new_schema: 新生成的 schema（会被修改）
-        previous_schema: 之前的 schema
-    """
-    for section in ["goal", "feedback", "result"]:
-        new_section = new_schema.get("properties", {}).get(section, {})
-        prev_section = previous_schema.get("properties", {}).get(section, {})
-
-        if not new_section or not prev_section:
-            continue
-
-        new_props = new_section.get("properties", {})
-        prev_props = prev_section.get("properties", {})
-
-        for field_name, field_schema in new_props.items():
-            if field_name in prev_props:
-                prev_field = prev_props[field_name]
-                # 保留字段的 description
-                if "description" in prev_field and prev_field["description"]:
-                    field_schema["description"] = prev_field["description"]
-                # 保留字段的 title（用户自定义的中文名）
-                if "title" in prev_field and prev_field["title"]:
-                    field_schema["title"] = prev_field["title"]
-
-
 def convert_ros_action_to_jsonschema(
    action_name_or_type: Union[str, Type], output_file: Optional[str] = None, format: str = "json"
 ) -> Dict[str, Any]:
--- a/unilabos/ros/nodes/base_device_node.py
+++ b/unilabos/ros/nodes/base_device_node.py
--- a/unilabos/ros/nodes/presets/camera.py
+++ b/unilabos/ros/nodes/presets/camera.py
@@ -6,13 +6,12 @@ from cv_bridge import CvBridge
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, DeviceNodeResourceTracker

 class VideoPublisher(BaseROS2DeviceNode):
-    def __init__(self, device_id='video_publisher', registry_name="", device_uuid='', camera_index=0, period: float = 0.1, resource_tracker: DeviceNodeResourceTracker = None):
+    def __init__(self, device_id='video_publisher', device_uuid='', camera_index=0, period: float = 0.1, resource_tracker: DeviceNodeResourceTracker = None):
        # 初始化BaseROS2DeviceNode，使用自身作为driver_instance
        BaseROS2DeviceNode.__init__(
            self,
            driver_instance=self,
            device_id=device_id,
-            registry_name=registry_name,
            device_uuid=device_uuid,
            status_types={},
            action_value_mappings={},
--- a/unilabos/ros/nodes/presets/controller_node.py
+++ b/unilabos/ros/nodes/presets/controller_node.py
@@ -10,7 +10,6 @@ class ControllerNode(BaseROS2DeviceNode):
    def __init__(
        self,
        device_id: str,
-        registry_name: str,
        controller_func: Callable,
        update_rate: float,
        inputs: Dict[str, Dict[str, type | str]],
@@ -52,7 +51,6 @@ class ControllerNode(BaseROS2DeviceNode):
            self,
            driver_instance=self,
            device_id=device_id,
-            registry_name=registry_name,
            status_types=status_types,
            action_value_mappings=action_value_mappings,
            hardware_interface=hardware_interface,
--- a/unilabos/ros/nodes/presets/host_node.py
+++ b/unilabos/ros/nodes/presets/host_node.py
@@ -1,17 +1,16 @@
 import collections
+from dataclasses import dataclass, field
 import json
 import threading
 import time
 import traceback
 import uuid
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Optional, Dict, Any, List, ClassVar, Set, Union
+from typing import TYPE_CHECKING, Optional, Dict, Any, List, ClassVar, Set, TypedDict, Union

 from action_msgs.msg import GoalStatus
 from geometry_msgs.msg import Point
 from rclpy.action import ActionClient, get_action_server_names_and_types_by_node
 from rclpy.service import Service
-from typing_extensions import TypedDict
 from unilabos_msgs.msg import Resource  # type: ignore
 from unilabos_msgs.srv import (
    ResourceAdd,
@@ -23,20 +22,9 @@ from unilabos_msgs.srv import (
 from unilabos_msgs.srv._serial_command import SerialCommand_Request, SerialCommand_Response
 from unique_identifier_msgs.msg import UUID

-from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
 from unilabos.registry.registry import lab_registry
-from unilabos.resources.container import RegularContainer
 from unilabos.resources.graphio import initialize_resource
 from unilabos.resources.registry import add_schema
-from unilabos.resources.resource_tracker import (
-    ResourceDict,
-    ResourceDictInstance,
-    ResourceTreeSet,
-    ResourceTreeInstance,
-    RETURN_UNILABOS_SAMPLES,
-    JSON_UNILABOS_PARAM,
-    PARAM_SAMPLE_UUIDS, SampleUUIDsType, LabSample,
-)
 from unilabos.ros.initialize_device import initialize_device_from_dict
 from unilabos.ros.msgs.message_converter import (
    get_msg_type,
@@ -47,11 +35,17 @@ from unilabos.ros.msgs.message_converter import (
 )
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, ROS2DeviceNode, DeviceNodeResourceTracker
 from unilabos.ros.nodes.presets.controller_node import ControllerNode
+from unilabos.resources.resource_tracker import (
+    ResourceDict,
+    ResourceDictInstance,
+    ResourceTreeSet,
+    ResourceTreeInstance,
+)
 from unilabos.utils import logger
 from unilabos.utils.exception import DeviceClassInvalid
 from unilabos.utils.log import warning
 from unilabos.utils.type_check import serialize_result_info
-from unilabos.config.config import BasicConfig
+from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot

 if TYPE_CHECKING:
    from unilabos.app.ws_client import QueueItem
@@ -64,20 +58,7 @@ class DeviceActionStatus:

 class TestResourceReturn(TypedDict):
    resources: List[List[ResourceDict]]
-    devices: List[Dict[str, Any]]
-    unilabos_samples: List[LabSample]
-
-
-class TestLatencyReturn(TypedDict):
-    """test_latency方法的返回值类型"""
-
-    avg_rtt_ms: float
-    avg_time_diff_ms: float
-    max_time_error_ms: float
-    task_delay_ms: float
-    raw_delay_ms: float
-    test_count: int
-    status: str
+    devices: List[DeviceSlot]


 class HostNode(BaseROS2DeviceNode):
@@ -250,7 +231,6 @@ class HostNode(BaseROS2DeviceNode):
            self,
            driver_instance=self,
            device_id=device_id,
-            registry_name="host_node",
            device_uuid=host_node_dict["uuid"],
            status_types={},
            action_value_mappings=lab_registry.device_type_registry["host_node"]["class"]["action_value_mappings"],
@@ -305,8 +285,7 @@ class HostNode(BaseROS2DeviceNode):
        }  # 用来存储多个ActionClient实例
        self._action_value_mappings: Dict[str, Dict] = (
            {}
-        )  # device_id -> action_value_mappings(本地+远程设备统一存储)
-        self._slave_registry_configs: Dict[str, Dict] = {}  # registry_name -> registry_config(含action_value_mappings)
+        )  # 用来存储多个ActionClient的type, goal, feedback, result的变量名映射关系
        self._goals: Dict[str, Any] = {}  # 用来存储多个目标的状态
        self._online_devices: Set[str] = {f"{self.namespace}/{device_id}"}  # 用于跟踪在线设备
        self._last_discovery_time = 0.0  # 上次设备发现的时间
@@ -382,7 +361,8 @@ class HostNode(BaseROS2DeviceNode):
            request.command = ""
            future = sclient.call_async(request)
            # Use timeout for result as well
-            future.result()
+            future.result(timeout_sec=5.0)
+            self.lab_logger().debug(f"[Host Node] Re-register completed for {device_namespace}")
        except Exception as e:
            # Gracefully handle destruction during shutdown
            if "destruction was requested" in str(e) or self._shutting_down:
@@ -606,10 +586,11 @@ class HostNode(BaseROS2DeviceNode):
        )

        try:
-            assert len(response) == 1, "Create Resource应当只返回一个结果"
+            new_li = []
            for i in response:
                res = json.loads(i)
-                return res
+                new_li.append(res)
+            return {"resources": new_li, "liquid_input_resources": new_li}
        except Exception as ex:
            pass
        _n = "\n"
@@ -640,8 +621,6 @@ class HostNode(BaseROS2DeviceNode):
        self.device_machine_names[device_id] = "本地"
        self.devices_instances[device_id] = d
        # noinspection PyProtectedMember
-        self._action_value_mappings[device_id] = d._ros_node._action_value_mappings
-        # noinspection PyProtectedMember
        for action_name, action_value_mapping in d._ros_node._action_value_mappings.items():
            if action_name.startswith("auto-") or str(action_value_mapping.get("type", "")).startswith(
                "UniLabJsonCommand"
@@ -764,7 +743,6 @@ class HostNode(BaseROS2DeviceNode):
        item: "QueueItem",
        action_type: str,
        action_kwargs: Dict[str, Any],
-        sample_material: Dict[str, str],
        server_info: Optional[Dict[str, Any]] = None,
    ) -> None:
        """
@@ -778,29 +756,18 @@ class HostNode(BaseROS2DeviceNode):
        u = uuid.UUID(item.job_id)
        device_id = item.device_id
        action_name = item.action_name
-
-        if BasicConfig.test_mode:
-            action_id = f"/devices/{device_id}/{action_name}"
-            self.lab_logger().info(
-                f"[TEST MODE] 模拟执行: {action_id} (job={item.job_id[:8]}), 参数: {str(action_kwargs)[:500]}"
-            )
-            # 根据注册表 handles 构建模拟返回值
-            mock_return = self._build_test_mode_return(device_id, action_name, action_kwargs)
-            self._handle_test_mode_result(item, action_id, mock_return)
-            return
-
        if action_type.startswith("UniLabJsonCommand"):
            if action_name.startswith("auto-"):
                action_name = action_name[5:]
            action_id = f"/devices/{device_id}/_execute_driver_command"
-            json_command: Dict[str, Any] = {
-                "function_name": action_name,
-                "function_args": action_kwargs,
-                JSON_UNILABOS_PARAM: {
-                    PARAM_SAMPLE_UUIDS: sample_material,
-                },
+            action_kwargs = {
+                "string": json.dumps(
+                    {
+                        "function_name": action_name,
+                        "function_args": action_kwargs,
+                    }
+                )
            }
-            action_kwargs = {"string": json.dumps(json_command)}
            if action_type.startswith("UniLabJsonCommandAsync"):
                action_id = f"/devices/{device_id}/_execute_driver_command_async"
        else:
@@ -811,11 +778,24 @@ class HostNode(BaseROS2DeviceNode):
            raise ValueError(f"ActionClient {action_id} not found.")

        action_client: ActionClient = self._action_clients[action_id]
+
+        # 遍历action_kwargs下的所有子dict，将"sample_uuid"的值赋给"sample_id"
+        def assign_sample_id(obj):
+            if isinstance(obj, dict):
+                if "sample_uuid" in obj:
+                    obj["sample_id"] = obj["sample_uuid"]
+                    obj.pop("sample_uuid")
+                for k, v in obj.items():
+                    if k != "unilabos_extra":
+                        assign_sample_id(v)
+            elif isinstance(obj, list):
+                for item in obj:
+                    assign_sample_id(item)
+
+        assign_sample_id(action_kwargs)
        goal_msg = convert_to_ros_msg(action_client._action_type.Goal(), action_kwargs)

-        # self.lab_logger().trace(f"[Host Node] Sending goal for {action_id}: {str(goal_msg)[:1000]}")
-        self.lab_logger().trace(f"[Host Node] Sending goal for {action_id}: {action_kwargs}")
-        self.lab_logger().trace(f"[Host Node] Sending goal for {action_id}: {goal_msg}")
+        self.lab_logger().info(f"[Host Node] Sending goal for {action_id}: {goal_msg}")
        action_client.wait_for_server()
        goal_uuid_obj = UUID(uuid=list(u.bytes))

@@ -826,51 +806,6 @@ class HostNode(BaseROS2DeviceNode):
        )
        future.add_done_callback(lambda f: self.goal_response_callback(item, action_id, f))

-    def _build_test_mode_return(
-        self, device_id: str, action_name: str, action_kwargs: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        根据注册表 handles 的 output 定义构建测试模式的模拟返回值
-
-        根据 data_key 中 @flatten 的层数决定嵌套数组层数，叶子值为空字典。
-        例如: "vessel" → {}, "plate.@flatten" → [{}], "a.@flatten.@flatten" → [[{}]]
-        """
-        mock_return: Dict[str, Any] = {"test_mode": True, "action_name": action_name}
-        action_mappings = self._action_value_mappings.get(device_id, {})
-        action_mapping = action_mappings.get(action_name, {})
-        handles = action_mapping.get("handles", {})
-        if isinstance(handles, dict):
-            for output_handle in handles.get("output", []):
-                data_key = output_handle.get("data_key", "")
-                handler_key = output_handle.get("handler_key", "")
-                # 根据 @flatten 层数构建嵌套数组，叶子为空字典
-                flatten_count = data_key.count("@flatten")
-                value: Any = {}
-                for _ in range(flatten_count):
-                    value = [value]
-                mock_return[handler_key] = value
-        return mock_return
-
-    def _handle_test_mode_result(
-        self, item: "QueueItem", action_id: str, mock_return: Dict[str, Any]
-    ) -> None:
-        """
-        测试模式下直接构建结果并走正常的结果回调流程（跳过 ROS）
-        """
-        job_id = item.job_id
-        status = "success"
-        return_info = serialize_result_info("", True, mock_return)
-
-        self.lab_logger().info(f"[TEST MODE] Result for {action_id} ({job_id[:8]}): {status}")
-
-        from unilabos.app.web.controller import store_job_result
-        store_job_result(job_id, status, return_info, mock_return)
-
-        # 发布状态到桥接器
-        for bridge in self.bridges:
-            if hasattr(bridge, "publish_job_status"):
-                bridge.publish_job_status(mock_return, item, status, return_info)
-
    def goal_response_callback(self, item: "QueueItem", action_id: str, future) -> None:
        """目标响应回调"""
        goal_handle = future.result()
@@ -918,14 +853,9 @@ class HostNode(BaseROS2DeviceNode):
                        # 适配后端的一些额外处理
                        return_value = return_info.get("return_value")
                        if isinstance(return_value, dict):
-                            unilabos_samples = return_value.pop(RETURN_UNILABOS_SAMPLES, None)
-                            if isinstance(unilabos_samples, list) and unilabos_samples:
-                                self.lab_logger().info(
-                                    f"[Host Node] Job {job_id[:8]} returned {len(unilabos_samples)} sample(s): "
-                                    f"{[s.get('name', s.get('id', 'unknown')) if isinstance(s, dict) else str(s)[:20] for s in unilabos_samples[:5]]}"
-                                    f"{'...' if len(unilabos_samples) > 5 else ''}"
-                                )
-                                return_info["samples"] = unilabos_samples
+                            unilabos_samples = return_info.get("unilabos_samples")
+                            if isinstance(unilabos_samples, list):
+                                return_info["unilabos_samples"] = unilabos_samples
                        suc = return_info.get("suc", False)
                        if not suc:
                            status = "failed"
@@ -951,7 +881,7 @@ class HostNode(BaseROS2DeviceNode):
            # 清理 _goals 中的记录
            if job_id in self._goals:
                del self._goals[job_id]
-                self.lab_logger().trace(f"[Host Node] Removed goal {job_id[:8]} from _goals")
+                self.lab_logger().debug(f"[Host Node] Removed goal {job_id[:8]} from _goals")

            # 存储结果供 HTTP API 查询
            try:
@@ -1195,7 +1125,7 @@ class HostNode(BaseROS2DeviceNode):
                self.lab_logger().info(f"[Host Node-Resource] UUID映射: {len(uuid_mapping)} 个节点")
            # 还需要加入到资源图中，暂不实现，考虑资源图新的获取方式
            response.response = json.dumps(uuid_mapping)
-            self.lab_logger().info(f"[Host Node-Resource] Resource tree update completed, success: {success}")
+            self.lab_logger().info(f"[Host Node-Resource] Resource tree add completed, success: {success}")

    async def _resource_tree_update_callback(self, request: SerialCommand_Request, response: SerialCommand_Response):
        """
@@ -1203,11 +1133,11 @@ class HostNode(BaseROS2DeviceNode):

        接收序列化的 ResourceTreeSet 数据并进行处理
        """
+        self.lab_logger().info(f"[Host Node-Resource] Resource tree add request received")
        try:
            # 解析请求数据
            data = json.loads(request.command)
            action = data["action"]
-            self.lab_logger().info(f"[Host Node-Resource] Resource tree {action} request received")
            data = data["data"]
            if action == "add":
                await self._resource_tree_action_add_callback(data, response)
@@ -1230,12 +1160,8 @@ class HostNode(BaseROS2DeviceNode):
    def _node_info_update_callback(self, request, response):
        """
        更新节点信息回调
-
-        处理两种消息:
-        1. 首次上报(main_slave_run): 带 devices_config + registry_config,存储 action_value_mappings
-        2. 设备重注册(SYNC_SLAVE_NODE_INFO): 带 edge_device_id + registry_name,用 registry_name 索引已存储的 mappings
        """
-        self.lab_logger().trace(f"[Host Node] Node info update request received: {request}")
+        # self.lab_logger().info(f"[Host Node] Node info update request received: {request}")
        try:
            from unilabos.app.communication import get_communication_client
            from unilabos.app.web.client import HTTPClient, http_client
@@ -1245,48 +1171,12 @@ class HostNode(BaseROS2DeviceNode):
                info = info["SYNC_SLAVE_NODE_INFO"]
                machine_name = info["machine_name"]
                edge_device_id = info["edge_device_id"]
-                registry_name = info.get("registry_name", "")
                self.device_machine_names[edge_device_id] = machine_name
-
-                # 用 registry_name 索引已存储的 registry_config,获取 action_value_mappings
-                if registry_name and registry_name in self._slave_registry_configs:
-                    action_mappings = self._slave_registry_configs[registry_name].get(
-                        "class", {}
-                    ).get("action_value_mappings", {})
-                    if action_mappings:
-                        self._action_value_mappings[edge_device_id] = action_mappings
-                        self.lab_logger().info(
-                            f"[Host Node] Loaded {len(action_mappings)} action mappings "
-                            f"for remote device {edge_device_id} (registry: {registry_name})"
-                        )
            else:
                devices_config = info.pop("devices_config")
                registry_config = info.pop("registry_config")
                if registry_config:
                    http_client.resource_registry({"resources": registry_config})
-
-                    # 存储 slave 的 registry_config,用于后续 SYNC_SLAVE_NODE_INFO 索引
-                    for reg_name, reg_data in registry_config.items():
-                        if isinstance(reg_data, dict) and "class" in reg_data:
-                            self._slave_registry_configs[reg_name] = reg_data
-
-                # 解析 devices_config,建立 device_id -> action_value_mappings 映射
-                if devices_config:
-                    for device_tree in devices_config:
-                        for device_dict in device_tree:
-                            device_id = device_dict.get("id", "")
-                            class_name = device_dict.get("class", "")
-                            if device_id and class_name and class_name in self._slave_registry_configs:
-                                action_mappings = self._slave_registry_configs[class_name].get(
-                                    "class", {}
-                                ).get("action_value_mappings", {})
-                                if action_mappings:
-                                    self._action_value_mappings[device_id] = action_mappings
-                                    self.lab_logger().info(
-                                        f"[Host Node] Stored {len(action_mappings)} action mappings "
-                                        f"for remote device {device_id} (class: {class_name})"
-                                    )
-
            self.lab_logger().debug(f"[Host Node] Node info update: {info}")
            response.response = "OK"
        except Exception as e:
@@ -1353,7 +1243,7 @@ class HostNode(BaseROS2DeviceNode):
            data = json.loads(request.command)
            if "uuid" in data and data["uuid"] is not None:
                http_req = http_client.resource_tree_get([data["uuid"]], data["with_children"])
-            elif "id" in data:
+            elif "id" in data and data["id"].startswith("/"):
                http_req = http_client.resource_get(data["id"], data["with_children"])
            else:
                raise ValueError("没有使用正确的物料 id 或 uuid")
@@ -1436,20 +1326,10 @@ class HostNode(BaseROS2DeviceNode):
        self.lab_logger().debug(f"[Host Node-Resource] List parameters: {request}")
        return response

-    def test_latency(self) -> TestLatencyReturn:
+    def test_latency(self):
        """
        测试网络延迟的action实现
        通过5次ping-pong机制校对时间误差并计算实际延迟
-
-        Returns:
-            TestLatencyReturn: 包含延迟测试结果的字典，包括：
-                - avg_rtt_ms: 平均往返时间（毫秒）
-                - avg_time_diff_ms: 平均时间差（毫秒）
-                - max_time_error_ms: 最大时间误差（毫秒）
-                - task_delay_ms: 实际任务延迟（毫秒），-1表示无法计算
-                - raw_delay_ms: 原始时间差（毫秒），-1表示无法计算
-                - test_count: 有效测试次数
-                - status: 测试状态，"success"表示成功，"all_timeout"表示全部超时
        """
        import uuid as uuid_module

@@ -1512,15 +1392,7 @@ class HostNode(BaseROS2DeviceNode):

        if not ping_results:
            self.lab_logger().error("❌ 所有ping-pong测试都失败了")
-            return {
-                "avg_rtt_ms": -1.0,
-                "avg_time_diff_ms": -1.0,
-                "max_time_error_ms": -1.0,
-                "task_delay_ms": -1.0,
-                "raw_delay_ms": -1.0,
-                "test_count": 0,
-                "status": "all_timeout",
-            }
+            return {"status": "all_timeout"}

        # 统计分析
        rtts = [r["rtt_ms"] for r in ping_results]
@@ -1528,7 +1400,7 @@ class HostNode(BaseROS2DeviceNode):

        avg_rtt_ms = sum(rtts) / len(rtts)
        avg_time_diff_ms = sum(time_diffs) / len(time_diffs)
-        max_time_diff_error_ms: float = max(abs(min(time_diffs)), abs(max(time_diffs)))
+        max_time_diff_error_ms = max(abs(min(time_diffs)), abs(max(time_diffs)))

        self.lab_logger().info("-" * 50)
        self.lab_logger().info("[测试统计]")
@@ -1568,7 +1440,7 @@ class HostNode(BaseROS2DeviceNode):

        self.lab_logger().info("=" * 60)

-        res: TestLatencyReturn = {
+        return {
            "avg_rtt_ms": avg_rtt_ms,
            "avg_time_diff_ms": avg_time_diff_ms,
            "max_time_error_ms": max_time_diff_error_ms,
@@ -1579,26 +1451,13 @@ class HostNode(BaseROS2DeviceNode):
            "test_count": len(ping_results),
            "status": "success",
        }
-        return res

    def test_resource(
-        self,
-        sample_uuids: SampleUUIDsType,
-        resource: ResourceSlot = None,
-        resources: List[ResourceSlot] = None,
-        device: DeviceSlot = None,
-        devices: List[DeviceSlot] = None,
+        self, resource: ResourceSlot, resources: List[ResourceSlot], device: DeviceSlot, devices: List[DeviceSlot]
    ) -> TestResourceReturn:
-        if resources is None:
-            resources = []
-        if devices is None:
-            devices = []
-        if resource is None:
-            resource = RegularContainer("test_resource传入None")
        return {
-            "resources": ResourceTreeSet.from_plr_resources([resource, *resources], known_newly_created=True).dump(),
+            "resources": ResourceTreeSet.from_plr_resources([resource, *resources]).dump(),
            "devices": [device, *devices],
-            "unilabos_samples": [LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for sample_uuid, content in sample_uuids.items()]
        }

    def handle_pong_response(self, pong_data: dict):
@@ -1649,9 +1508,7 @@ class HostNode(BaseROS2DeviceNode):

            # 构建服务地址
            srv_address = f"/srv{namespace}/s2c_resource_tree"
-            self.lab_logger().trace(
-                f"[Host Node-Resource] Host -> {device_id} ResourceTree {action} operation started -------"
-            )
+            self.lab_logger().info(f"[Host Node-Resource] Notifying {device_id} for resource tree {action} operation")

            # 创建服务客户端
            sclient = self.create_client(SerialCommand, srv_address)
@@ -1686,8 +1543,8 @@ class HostNode(BaseROS2DeviceNode):
                time.sleep(0.05)

            response = future.result()
-            self.lab_logger().trace(
-                f"[Host Node-Resource] Host -> {device_id} ResourceTree {action} operation completed -------"
+            self.lab_logger().info(
+                f"[Host Node-Resource] Resource tree {action} notification completed for {device_id}"
            )
            return True

--- a/Show More
+++ b/Show More