提示词修改

Introduce ENU offset tool support with controlled tool-call handling, update prompts to gate coordinate tooling, and enable jinja tools in startup.

README.md

@@ -228,14 +228,96 @@ python ingest.py
 
 完成前两个阶段后，即可启动并测试后端服务。
 
-#### 1. 启动后端服务
+#### 1. 启动所有服务（推荐方式：一键启动脚本）
 
-启动服务的关键在于**按顺序激活环境**：先激活ROS 2工作空间，再激活Conda环境。
+我们提供了一个一键启动脚本 `start_all.sh`，可以自动启动所有必需的服务：
 
 ```bash
 # 1. 切换到项目根目录
 cd /path/to/your/drone
 
+# 2. 使用一键启动脚本（推荐）
+./start_all.sh start
+
+# 或者直接运行（start是默认命令）
+./start_all.sh
+```
+
+**脚本功能：**
+- 自动启动推理模型服务（llama-server，端口8081）
+- 自动启动Embedding模型服务（llama-server，端口8090）
+- 自动启动FastAPI后端服务（端口8000）
+- 自动检查端口占用、模型文件、环境配置等
+- 自动等待服务就绪
+- 统一管理日志文件（保存在 `logs/` 目录）
+
+**环境变量配置（可选）：**
+
+在运行脚本前，可以通过环境变量自定义配置：
+
+```bash
+# 设置llama-server路径（如果不在默认位置）
+export LLAMA_SERVER_DIR="/path/to/llama.cpp/build/bin"
+
+# 设置模型路径（如果不在默认位置）
+export INFERENCE_MODEL="~/models/gguf/Qwen/Qwen3-8B-GGUF/Qwen3-8B-Q4_K_M.gguf"
+export EMBEDDING_MODEL="~/models/gguf/Qwen/Qwen3-embedding-4B/Qwen3-Embedding-4B-Q4_K_M.gguf"
+
+# 设置Conda环境名称（如果使用不同的环境名）
+export CONDA_ENV="backend"
+
+# 然后运行脚本
+./start_all.sh
+```
+
+**脚本命令：**
+
+```bash
+./start_all.sh start    # 启动所有服务（默认）
+./start_all.sh stop     # 停止所有服务
+./start_all.sh restart  # 重启所有服务
+./start_all.sh status   # 查看服务状态
+```
+
+**日志查看：**
+
+所有服务的日志都保存在 `logs/` 目录下：
+```bash
+# 查看所有日志
+tail -f logs/*.log
+
+# 查看特定服务日志
+tail -f logs/inference_model.log  # 推理模型
+tail -f logs/embedding_model.log  # Embedding模型
+tail -f logs/fastapi.log          # FastAPI服务
+```
+
+#### 2. 手动启动服务（备选方式）
+
+如果您需要手动控制每个服务的启动，可以按照以下步骤操作：
+
+**启动推理模型服务：**
+
+```bash
+cd /llama.cpp/build/bin
+./llama-server -m ~/models/gguf/Qwen/Qwen3-8B-GGUF/Qwen3-8B-Q4_K_M.gguf --port 8081 --gpu-layers 36 --host 0.0.0.0 -c 8192
+```
+
+**启动Embedding模型服务：**
+
+在另一个终端中：
+```bash
+cd /llama.cpp/build/bin
+./llama-server -m ~/models/gguf/Qwen/Qwen3-embedding-4B/Qwen3-Embedding-4B-Q4_K_M.gguf --gpu-layers 36 --port 8090 --embeddings --pooling last --host 0.0.0.0
+```
+
+**启动FastAPI后端服务：**
+
+在第三个终端中：
+```bash
+# 1. 切换到项目根目录
+cd /path/to/your/drone
+
 # 2. 激活ROS 2编译环境
 #    作用：将我们编译好的`drone_interfaces`包的路径告知系统，否则Python会报`ModuleNotFoundError`。
 #    注意：此命令必须在每次打开新终端时执行一次。
@@ -248,6 +330,7 @@ conda activate backend
 cd backend_service/
 uvicorn src.main:app --host 0.0.0.0 --port 8000
 ```
+
 当您看到日志中出现 `Uvicorn running on http://0.0.0.0:8000` 时，表示服务已成功启动。
 
 #### 2. 运行API接口测试

backend_service/generated_reasoning_content/reasoning_content.md

@@ -6,38 +6,80 @@
 
 接下来，任务流程应该是：起飞→飞往搜索区域→搜索目标→检测到目标后跟踪→打击。同时必须包含安全监控。
 
-根据用户提供的参考知识，可能需要将搜索区域设置为某个中心点。比如，用户提到的“跷跷板”在(x:15, y:-8.5, z:1.2)，但z坐标需要调整到至少1米，这里已经是1.2，没问题。或者可能选择其他地点作为搜索中心。但用户没有明确说明，可能需要假设搜索区域是这些地点附近，或者使用一个综合的中心点。
+根据用户提供的参考知识，可能需要将搜索区域设置为某个中心点。比如，用户提到的“跷跷板”在(x:15, y:-8.5, z:1.2)，但z坐标需要调整到至少1米，所以可能设置为z=2。或者选择其他地点作为搜索中心。但用户没有明确说明，可能需要假设搜索区域是这些地点的附近，或者使用其中一个作为中心。
 
-不过用户可能希望无人机先飞往某个特定的搜索区。比如，参考知识中的“学生宿舍”可能是一个可能的区域，但需要确认。或者用户可能希望无人机在某个中心点周围进行搜索。例如，使用search_pattern的中心点可能选在某个已知地点，比如“跷跷板”附近，或者综合多个点。
+另外，用户提到要搜索并锁定危险性最高的气球，所以需要使用search_pattern或者object_detect。但因为是未知区域，可能更适合使用search_pattern，或者先飞到某个区域再进行检测。
 
-但用户没有明确指定搜索区域，所以可能需要使用search_pattern的中心点为某个已知地点，比如“跷跷板”的坐标，或者选择一个合理的中心点。例如，假设搜索区域是“跷跷板”所在的位置，那么中心坐标为(15, -8.5, 1.2)。或者可能需要将搜索区域设置为多个地点的组合，但用户没有说明，所以可能需要选择一个中心点。
+根据任务范式，可能需要先飞到某个坐标点，然后进行搜索。例如，使用fly_to_waypoint飞到某个中心点，然后执行search_pattern。或者直接使用search_pattern覆盖多个区域。
 
-接下来，考虑使用search_pattern来搜索，因为目标位置未知。参数中需要指定pattern_type，比如spiral或grid。假设选择spiral模式，覆盖更大的区域。中心点可能选在某个已知地点，比如“跷跷板”的坐标，或者综合多个点。但用户没有明确，所以可能需要选择一个合理的中心点，比如“跷跷板”的坐标。
+不过参考知识中的三个地点可能作为搜索区域的中心，可能需要将搜索区域设置为这些点的附近。但用户没有明确说明，可能需要选择一个中心点，比如“学生宿舍”的坐标，或者综合考虑。
 
-然后，检测到目标后，需要跟踪30秒，再打击。所以流程是：起飞→飞往搜索区→搜索→检测→跟踪→打击→降落。
+另外，用户提到要锁定危险性最高的气球，所以需要检测到红色气球。因此，在search_pattern中，target_class应为balloon，并且description为“红色气球危险性高于蓝色气球高于绿色气球”，或者在object_detect中设置description参数为“红>蓝>绿”。
 
-安全监控必须包含在Parallel节点中，监控电池和GPS，并在紧急情况下返航。
+但根据搜索模式，search_pattern的参数需要target_class和description。所以可能需要设置target_class为balloon，description为“红>蓝>绿”。
 
-现在，构建行为树的结构：
+接下来，流程应该是：
 
-根节点是Parallel，包含主任务和安全监控。主任务是Sequence，包含起飞、飞往搜索区、搜索、检测、跟踪、打击、降落。安全监控是Selector，包含电池和GPS条件，以及紧急处理Sequence。
+1. 起飞到一定高度。
+2. 飞往搜索区域的中心点（比如学生宿舍的坐标，调整z到2）。
+3. 执行search_pattern，搜索红色气球。
+4. 一旦检测到目标，进行跟踪。
+5. 跟踪30秒后打击。
 
-在搜索部分，使用search_pattern，参数包括pattern_type为spiral，中心点选在某个已知地点，比如“跷跷板”的坐标(15, -8.5, 1.2)，半径可能设为50米，覆盖较大区域。目标类别是balloon，描述为“红色气球危险性高于蓝色气球高于绿色气球”，但参数中description需要描述目标属性，比如“红>蓝>绿”。
+同时，安全监控必须包含电池和GPS检查，以及紧急处理。
 
-检测到目标后，使用track_object，参数target_class为balloon，description为“红>蓝>绿”，track_time为30秒。然后strike_target，最后评估战损。
+现在需要构建行为树结构。根节点是Parallel，包含主任务和安全监控。主任务是Sequence，包含起飞、飞往搜索点、搜索、跟踪、打击、降落。
 
-需要确保所有参数符合约束，比如z坐标在1-5000米之间，半径在5-1000米之间，速度等参数在合理范围。
+在搜索部分，可能需要使用search_pattern，或者先飞到某个点再进行object_detect。但根据用户指令，可能更适合使用search_pattern，因为需要在未知区域搜索。
 
-现在，将各个步骤的参数填入JSON中。例如，起飞到2米，飞往搜索区的中心点可能选在“跷跷板”的坐标(15, -8.5, 1.2)，但z需要调整到至少1米，这里已经是1.2。所以fly_to_waypoint的参数x=15，y=-8.5，z=1.2，接受半径2米。
+所以，主任务步骤：
 
-搜索使用search_pattern，pattern_type为spiral，中心点为(15, -8.5, 1.2)，半径设为50米，覆盖区域。目标类别是balloon，description为“红>蓝>绿”。
+- preflight_checks
+- takeoff
+- fly_to_waypoint到某个中心点（比如学生宿舍的坐标，调整z为2）
+- search_pattern，参数为balloon，description为“红>蓝>绿”，pattern_type可能是spiral或grid，假设用spiral，中心点为学生宿舍的坐标，半径适当，比如50米。
+- 然后，当检测到目标后，进行track_object，跟踪30秒。
+- 然后strike_target，打击。
+- 最后降落。
 
-检测到目标后，使用track_object，参数target_class为balloon，description为“红>蓝>绿”，track_time为30秒，min_confidence设为0.7，safe_distance设为15米。
+但需要确保在search_pattern之后，检测到目标，然后进入跟踪。或者可能需要使用Selector来选择直接检测或搜索。
 
-然后strike_target，参数target_class为balloon，description为“红>蓝>绿”，count为1。
+但根据用户指令，可能需要先飞到某个点，再执行search_pattern。或者直接使用search_pattern覆盖多个区域。
 
-最后，降落。
+参考知识中的三个地点可能作为搜索区域的中心，但用户没有明确说明，可能需要选择其中一个作为搜索中心。比如学生宿舍的坐标(x:5, y:3, z:2)，调整z为2。
 
-安全监控部分，电池阈值设为0.35，GPS的min_satellites设为8，紧急处理Sequence包括emergency_return和land。
+所以，fly_to_waypoint的参数是x=5, y=3, z=2, acceptance_radius=2.0。
 
-现在，将所有步骤的参数填入JSON中，确保符合所有规则。
+然后执行search_pattern，参数为balloon，description为“红>蓝>绿”，pattern_type为spiral，中心点为学生宿舍的坐标，半径比如50米。
+
+之后，当检测到目标后，进行track_object，参数为balloon，description为“红>蓝>绿”，track_time=30.0，min_confidence=0.7，safe_distance=15.0。
+
+然后strike_target，参数为balloon，description为“红>蓝>绿”，count=1。
+
+最后降落。
+
+同时，安全监控需要包含电池和GPS检查，以及紧急处理。
+
+现在需要构建JSON结构，确保所有参数符合约束，并且流程正确。
+
+可能的搜索中心是学生宿舍的坐标，调整z为2。然后search_pattern的参数为balloon，description为“红>蓝>绿”，pattern_type为spiral，radius为50米，center_x=5, center_y=3, center_z=2。
+
+然后，当检测到目标后，进行track_object，跟踪30秒，然后打击。
+
+在行为树中，主任务Sequence的步骤包括：
+
+- preflight_checks
+- takeoff (altitude=2.0)
+- fly_to_waypoint到学生宿舍的坐标，调整z为2
+- search_pattern，参数为balloon，description为“红>蓝>绿”，pattern_type为spiral，radius=50，center_x=5, center_y=3, center_z=2
+- 然后，当检测到目标后，进行track_object
+- strike_target
+- land
+
+同时，安全监控的Selector包含电池和GPS条件，以及紧急处理。
+
+现在需要检查所有参数是否符合约束，例如z=2，符合≥1。
+
+其他参数如radius=50，符合[5,1000]。
+
+所以，生成的JSON结构应该符合这些要求，并且流程正确。

backend_service/requirements.txt

@@ -15,8 +15,8 @@ chromadb>=0.4.0
 # Visualization
 graphviz>=0.20.0
 
-# ROS 2 Python Client
-rclpy>=0.0.1
+# ROS 2 Python Client - 已注释，项目已与ROS2解耦
+# rclpy>=0.0.1
 
 # Document Processing
 unstructured[all]>=0.11.0
@@ -30,10 +30,10 @@ rich>=13.7.0
 # Type Hints Support
 typing-extensions>=4.8.0
 
-# ROS 2 Build Dependencies
-empy==3.3.4
-catkin-pkg>=0.4.0
-lark>=1.1.0
-colcon-common-extensions>=0.3.0
-vcstool>=0.2.0
-rosdep>=0.22.0
+# ROS 2 Build Dependencies - 已注释，项目已与ROS2解耦
+# empy==3.3.4
+# catkin-pkg>=0.4.0
+# lark>=1.1.0
+# colcon-common-extensions>=0.3.0
+# vcstool>=0.2.0
+# rosdep>=0.22.0

backend_service/src/main.py

@@ -3,13 +3,13 @@ import os
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 from fastapi.staticfiles import StaticFiles
 import logging
-import threading
-import rclpy
+# import threading  # ROS2相关，已注释
+# import rclpy  # ROS2相关，已注释
 
 from .models import GeneratePlanRequest, ExecuteMissionRequest
 from .websocket_manager import websocket_manager
 from .py_tree_generator import py_tree_generator
-from .ros2_client import MissionActionClient
+# from .ros2_client import MissionActionClient  # ROS2相关，已注释
 
 # --- Application Setup ---
 app = FastAPI(
@@ -23,14 +23,15 @@ static_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'gene
 app.mount("/static", StaticFiles(directory=static_dir), name="static")
 
 # --- ROS2 Node and Client Initialization ---
-rclpy.init()
-ros2_client = MissionActionClient()
+# ROS2相关代码已注释，项目已与ROS2解耦
+# rclpy.init()
+# ros2_client = MissionActionClient()
 
-def run_ros2_node():
-    """Spins the ROS2 node in a dedicated thread."""
-    logging.info("Starting to spin ROS2 node...")
-    rclpy.spin(ros2_client)
-    logging.info("ROS2 node has stopped spinning.")
+# def run_ros2_node():
+#     """Spins the ROS2 node in a dedicated thread."""
+#     logging.info("Starting to spin ROS2 node...")
+#     rclpy.spin(ros2_client)
+#     logging.info("ROS2 node has stopped spinning.")
 
 # --- API Endpoints ---
 
@@ -49,9 +50,12 @@ async def generate_plan_endpoint(request: GeneratePlanRequest):
 async def execute_mission_endpoint(request: ExecuteMissionRequest):
     """
     Receives a `py_tree.json` and sends it to the drone for execution.
+    ROS2相关功能已注释，项目已与ROS2解耦。
     """
-    ros2_client.send_goal(request.py_tree)
-    return {"status": "execution_started"}
+    # ROS2相关代码已注释
+    # ros2_client.send_goal(request.py_tree)
+    logging.warning("execute_mission endpoint called but ROS2 is disabled. Mission execution is not available.")
+    return {"status": "execution_disabled", "message": "ROS2 integration is disabled. Mission execution is not available."}
 
 @app.websocket("/ws/status")
 async def websocket_endpoint(websocket: WebSocket):
@@ -73,21 +77,23 @@ async def websocket_endpoint(websocket: WebSocket):
 async def startup_event():
     """
     On startup, get the current asyncio event loop and pass it to the websocket manager.
-    Also, start the ROS2 node in a background thread.
+    ROS2相关功能已注释，项目已与ROS2解耦。
     """
     # Configure WebSocket Manager
     loop = asyncio.get_running_loop()
     websocket_manager.set_loop(loop)
     logging.info("WebSocket event loop configured.")
 
+    # ROS2相关代码已注释
     # Start ROS2 node in a background thread
-    ros2_thread = threading.Thread(target=run_ros2_node, daemon=True)
-    ros2_thread.start()
-    logging.info("ROS2 node thread started.")
+    # ros2_thread = threading.Thread(target=run_ros2_node, daemon=True)
+    # ros2_thread.start()
+    # logging.info("ROS2 node thread started.")
 
 @app.on_event("shutdown")
 async def shutdown_event():
     logging.info("Backend service shutting down.")
-    ros2_client.destroy_node()
-    rclpy.shutdown()
-    logging.info("ROS2 node shut down successfully.")
+    # ROS2相关代码已注释
+    # ros2_client.destroy_node()
+    # rclpy.shutdown()
+    # logging.info("ROS2 node shut down successfully.")

backend_service/src/prompts/classifier_prompt.txt

@@ -1,8 +1,12 @@
 你是一个严格的任务分类器。只输出一个JSON对象，不要输出解释或多余文本。
 根据用户指令与下述可用节点定义，判断其为“简单”或“复杂”。
 
-- 简单：单一原子动作即可完成（例如“起飞”“飞机自检”“移动到某地(已给定坐标)”“对着某点环绕XY圈（如‘对着学生宿舍环绕三十两圈’）”等），且无需行为树与安全并行监控。
-- 复杂：需要多步流程、搜索/检测/跟踪/评估、战损确认、或需要模板化任务结构与安全并行监控。
+- 简单：单一动作节点即可完成（例如"起飞""飞机自检""移动到某地(已给定坐标)"等），且无需行为树。
+- 复杂：需要两个动作及以上、多步流程、搜索/检测/跟踪/评估、战损确认、或需要模板化任务结构。
+
+判断简单/复杂任务一定要结合无人机状态，在地面还是在空中：
+1. 如果提及无人机在地面，则执行任何任务前都需要起飞，因此凡是起飞后还有其他动作的应当判定为复杂；
+2. 如果提及无人机在空中，则执行任务时如果是"无人机当前在空中，飞到某地"这一类任务应当判定为简单。
 
 输出格式（严格遵守）：
 {"mode":"simple"} 或 {"mode":"complex"}
@@ -11,14 +15,46 @@
 ```json
 {
   "actions": [
-    {"name": "takeoff"}, {"name": "land"}, {"name": "fly_to_waypoint"}, {"name": "move_direction"}, {"name": "orbit_around_point"}, {"name": "orbit_around_target"}, {"name": "loiter"},
-    {"name": "object_detect"}, {"name": "strike_target"}, {"name": "battle_damage_assessment"},
-    {"name": "search_pattern"}, {"name": "track_object"}, {"name": "deliver_payload"},
-    {"name": "preflight_checks"}, {"name": "emergency_return"}
+    {"name":"takeoff","params":{"altitude":"float[1,100]，默认2"}},
+    {"name":"land","params":{"mode":"'current'/'home'"}},
+    {"name":"fly_to_waypoint","params":{"x":"±10000","y":"±10000","z":"[1,5000]","acceptance_radius":"默认2.0"}},
+    {"name":"fly_sequence","params":{"waypoints":"list[dict] (e.g. [{'x':10,'y':20,'z':5}, ...])","coordinate_frame":"'global'/'local_enu'（global:经纬度, local_enu:以起飞点为原点的东北天坐标系）","speed":"float,可选"}},
+    {"name":"move_direction","params":{"direction":"north/south/east/west/forward/backward/left/right","distance":"[1,10000]，缺省持续移动","speed":"float,可选"}},
+    {"name":"approach_target","params":{"target_class":"string,要趋近的目标类别","description":"string,可选,目标属性描述","stop_distance":"float,期望的最终停止距离","speed":"float,可选,期望的逼近速度"}},
+    {"name":"rotate","params":{"angle":"float,无人机自身旋转角度(正数逆时针,负数顺时针)","angular_velocity":"rad/s,旋转角速度"}},
+    {"name":"rotate_search","params":{"target_class":"string,要搜寻的目标类别","description":"string,可选,目标属性描述","step_angle":"float,可选,每一步旋转的角度","total_rotation":"float,可选,总共旋转搜索的角度"}},
+    {"name":"manual_confirmation","params":{}},
+    {"name":"loiter","params":{"duration":"[1,600]秒/until_condition:可选"}},
+    {"name":"object_detect","params":{"target_class":"person,bicycle,car,motorcycle,airplane,bus,train,truck,boat,traffic_light,fire_hydrant,stop_sign,parking_meter,bench,bird,cat,dog,horse,sheep,cow,elephant,bear,zebra,giraffe,backpack,umbrella,handbag,tie,suitcase,frisbee,skis,snowboard,sports_ball,kite,baseball_bat,baseball_glove,skateboard,surfboard,tennis_racket,bottle,wine_glass,cup,fork,knife,spoon,bowl,banana,apple,sandwich,orange,broccoli,carrot,hot_dog,pizza,donut,cake,chair,couch,potted_plant,bed,dining_table,toilet,tv,laptop,mouse,remote,keyboard,cell_phone,microwave,oven,toaster,sink,refrigerator,book,clock,vase,scissors,teddy_bear,hair_drier,toothbrush,garbage","description":"可选，","count":"默认1"}},
+    {"name":"strike_target","params":{"target_class":"同object_detect","description":"可选，目标属性","count":"默认1"}},
+    {"name":"battle_damage_assessment","params":{"target_class":"同object_detect","assessment_time":"[5,60]，默认15"}},
+    {"name":"search_pattern","params":{"pattern_type":"spiral/grid","center_x":"±10000","center_y":"±10000","center_z":"[1,5000]","radius":"[5,1000]","target_class":"同object_detect","description":"可选，目标属性","count":"默认1"}},
+    {"name":"track_object","params":{"target_class":"同object_detect","description":"可选，目标属性","track_time":"[1,600]秒（必传，不可用'duration'）","min_confidence":"[0.5,1.0]默认0.7","safe_distance":"[2,50]默认10"}},
+    {"name":"deliver_payload","params":{"payload_type":"string","release_altitude":"[2,100]默认5"}},
+    {"name":"system_checks","params":{"check_level":"basic/comprehensive"}},
+    {"name":"emergency_return","params":{"reason":"string"}},
+    {"name":"take_photos","params":{"target_class":"同object_detect","description":"可选，目标属性","track_time":"[1,600]秒（必传，不可用'duration'）","min_confidence":"[0.5,1.0]默认0.7","safe_distance":"[2,50]默认10"}}
   ],
   "conditions": [
-    {"name": "battery_above"}, {"name": "at_waypoint"}, {"name": "object_detected"},
-    {"name": "target_destroyed"}, {"name": "time_elapsed"}, {"name": "gps_status"}
+    {"name":"at_waypoint","params":{"x":"±10000","y":"±10000","z":"[1,5000]","tolerance":"默认3.0"}},
+    {"name":"object_detected","params":{"target_class":"同object_detect（必传）","description":"可选，目标属性","count":"默认1"}},
+    {"name":"target_destroyed","params":{"target_class":"同object_detect","description":"可选，目标属性","confidence":"[0.5,1.0]默认0.8"}},
+    {"name":"time_elapsed","params":{"duration":"[1,2700]秒"}},
+    {"name":"gps_status","params":{"min_satellites":"int[6,15]，必传（如8）"}}
+  ],
+  "control_flow": [
+    {"name":"Sequence","params":{},"children":"子节点数组（按序执行，全成功则成功）"},
+    {"name":"Selector","params":{"memory":"默认true"},"children":"子节点数组（执行到成功为止）"},
+    {"name":"Parallel","params":{"policy":"all_success"},"children":"子节点数组（同时执行，严禁用'one_success'）"}
+  ],
+  "decorators": [
+    {"name":"SuccessIsFailure","params":{},"child":"单一子节点（将子节点的成功结果反转为失败）"}
   ]
 }
 ```
+
+# 需要辨析的情况
+1. "无人机当前在空中，往东边飞50米,停个20s就好返航了。"这样的指令应该被判定为复杂，因为需要多步执行。
+2. 到某地执行某动作，这样的任务应该是复杂。
+3. "无人机当前在空中，飞到广场"这样的任务，无人机只需要执行fly_to_waypoint即可，无需起飞，这样的任务是简单。
+4. "无人机当前在地面，飞到广场"这样的任务，无人机需要先起飞再飞到广场，这样的任务是复杂。

backend_service/src/prompts/simple_mode_prompt.txt

@@ -1,43 +1,46 @@
-你是一个无人机简单指令执行规划器。你的任务：输出一个严格的JSON对象。
+你是一个无人机简单指令执行规划器。你的任务：当用户给出“简单指令”（单一原子动作即可完成）时，输出一个严格的JSON对象。
 
 输出要求（必须遵守）：
 - 只输出一个JSON对象，不要任何解释或多余文本。
 - JSON结构：
-{"mode":"simple","action":{"name":"<action_name>","params":{...}}}
-- 不包含任何行为树结构与安全监控并行，仅输出单一原子动作。
+{"root":{"type":"action","name":"<action_name>","params":{...}}}
+- root节点必须是action类型节点，不能是控制流节点。
 
 示例：
-- “起飞到10米” → {"mode":"simple","action":{"name":"takeoff","params":{"altitude":10.0}}}
-- “移动到(120,80,20)” → {"mode":"simple","action":{"name":"fly_to_waypoint","params":{"x":120.0,"y":80.0,"z":20.0,"acceptance_radius":2.0}}}
-- “飞机自检” → {"mode":"simple","action":{"name":"preflight_checks","params":{"check_level":"comprehensive"}}}
+- “起飞到10米” → {"root":{"type":"action","name":"takeoff","params":{"altitude":10.0}}}
+- “移动到(120,80,20)” → {"root":{"type":"action","name":"fly_to_waypoint","params":{"x":120.0,"y":80.0,"z":20.0,"acceptance_radius":2.0}}}
+- “飞机自检” → {"root":{"type":"action","name":"system_checks","params":{"check_level":"comprehensive"}}}
 
 —— 可用节点定义——
 ```json
 {
   "actions": [
-    {"name": "takeoff", "description": "无人机从当前位置垂直起飞到指定的海拔高度。", "params": {"altitude": "float, 目标海拔高度(米)，范围[1, 100]，默认为2"}},
-    {"name": "land", "description": "降落无人机。可选择当前位置或返航点降落。", "params": {"mode": "string, 可选值: 'current'（当前位置）, 'home'（返航点）"}},
-    {"name": "fly_to_waypoint", "description": "导航至一个指定坐标点。使用相对坐标系（x,y,z），单位为米。", "params": {"x": "float", "y": "float", "z": "float", "acceptance_radius": "float, 可选，默认2.0"}},
-    {"name": "move_direction", "description": "按指定方向直线移动。方向可为绝对方位或相对机体朝向。", "params": {"direction": "string: north|south|east|west|forward|backward|left|right", "distance": "float[1,10000], 可选, 不指定则持续移动"}},
-    {"name": "orbit_around_point", "description": "以给定中心点为中心，等速圆周飞行指定圈数。", "params": {"center_x": "float", "center_y": "float", "center_z": "float", "radius": "float[5,1000]", "laps": "int[1,20]", "clockwise": "boolean, 可选, 默认true", "speed_mps": "float[0.5,15], 可选", "gimbal_lock": "boolean, 可选, 默认true"}},
-    {"name": "orbit_around_target", "description": "以目标为中心，等速圆周飞行指定圈数（需已有目标）。", "params": {"target_class": "string, 取值同object_detect列表", "description": "string, 可选", "radius": "float[5,1000]", "laps": "int[1,20]", "clockwise": "boolean, 可选, 默认true", "speed_mps": "float[0.5,15], 可选", "gimbal_lock": "boolean, 可选, 默认true"}},
-    {"name": "loiter", "description": "在当前位置上空悬停一段时间或直到条件触发。", "params": {"duration": "float, 可选[1,600]", "until_condition": "string, 可选"}},
-    {"name": "object_detect", "description": "识别特定目标对象。一般是用户提到的需要检测的目标；如果用户给出了需要探索的目标的优先级，比如蓝色球危险性大于红色球大于绿色球，需要检测最危险的球，此处应给出检测优先级，描述应当为 '蓝>红>绿'", "params": {"target_class": "string, 要识别的目标类别，必须为以下值之一: balloon,person, bicycle, car, motorcycle, airplane, bus, train, truck, boat, traffic_light, fire_hydrant, stop_sign, parking_meter, bench, bird, cat, dog, horse, sheep, cow, elephant, bear, zebra, giraffe, backpack, umbrella, handbag, tie, suitcase, frisbee, skis, snowboard, sports_ball, kite, baseball_bat, baseball_glove, skateboard, surfboard, tennis_racket, bottle, wine_glass, cup, fork, knife, spoon, bowl, banana, apple, sandwich, orange, broccoli, carrot, hot_dog, pizza, donut, cake, chair, couch, potted_plant, bed, dining_table, toilet, tv, laptop, mouse, remote, keyboard, cell_phone, microwave, oven, toaster, sink, refrigerator, book, clock, vase, scissors, teddy_bear, hair_drier, toothbrush", "description": "string, 可选", "count": "int, 可选, 默认1"}},
-    {"name": "strike_target", "description": "对已识别目标进行打击。", "params": {"target_class": "string", "description": "string, 可选", "count": "int, 可选, 默认1"}},
-    {"name": "battle_damage_assessment", "description": "战损评估。", "params": {"target_class": "string", "assessment_time": "float[5-60], 默认15.0"}},
-    {"name": "search_pattern", "description": "按模式搜索。", "params": {"pattern_type": "string: spiral|grid", "center_x": "float", "center_y": "float", "center_z": "float", "radius": "float[5,1000]", "target_class": "string", "description": "string, 可选", "count": "int, 可选, 默认1"}},
-    {"name": "track_object", "description": "持续跟踪目标。", "params": {"target_class": "string, 取值同object_detect列表", "description": "string, 可选", "track_time": "float[1,600], 默认30.0", "min_confidence": "float[0.5-1.0], 默认0.7", "safe_distance": "float[2-50], 默认10.0"}},
-    {"name": "deliver_payload", "description": "投放物资。", "params": {"payload_type": "string", "release_altitude": "float[2,100], 默认5.0"}},
-    {"name": "preflight_checks", "description": "飞行前系统自检。", "params": {"check_level": "string: basic|comprehensive"}},
-    {"name": "emergency_return", "description": "执行紧急返航程序。", "params": {"reason": "string"}}
+    {"name":"takeoff","params":{"altitude":"float[1,100]，默认2"}},
+    {"name":"land","params":{"mode":"'current'/'home'"}},
+    {"name":"fly_to_waypoint","params":{"x":"±10000","y":"±10000","z":"[1,5000]","acceptance_radius":"默认2.0"}},
+    {"name":"fly_sequence","params":{"waypoints":"list[dict] (e.g. [{'x':10,'y':20,'z':5}, ...])","coordinate_frame":"'global'/'local_enu'（global:经纬度, local_enu:以起飞点为原点的东北天坐标系）","speed":"float,可选"}},
+    {"name":"move_direction","params":{"direction":"north/south/east/west/forward/backward/left/right/up/down","distance":"[1,10000]，缺省持续移动","speed":"float,可选"}},
+    {"name":"approach_target","params":{"target_class":"string,要趋近的目标类别","description":"string,可选,目标属性描述","stop_distance":"float,期望的最终停止距离","speed":"float,可选,期望的逼近速度"}},
+    {"name":"rotate","params":{"angle":"float,无人机自身旋转角度(正数逆时针,负数顺时针)","angular_velocity":"rad/s,旋转角速度"}},
+    {"name":"rotate_search","params":{"target_class":"string,要搜寻的目标类别","description":"string,可选,目标属性描述","step_angle":"float,可选,每一步旋转的角度","total_rotation":"float,可选,总共旋转搜索的角度"}},
+    {"name":"manual_confirmation","params":{}},
+    {"name":"loiter","params":{"duration":"[1,600]秒/until_condition:可选"}},
+    {"name":"object_detect","params":{"target_class":"person,bicycle,car,motorcycle,airplane,bus,train,truck,boat,traffic_light,fire_hydrant,stop_sign,parking_meter,bench,bird,cat,dog,horse,sheep,cow,elephant,bear,zebra,giraffe,backpack,umbrella,handbag,tie,suitcase,frisbee,skis,snowboard,sports_ball,kite,baseball_bat,baseball_glove,skateboard,surfboard,tennis_racket,bottle,wine_glass,cup,fork,knife,spoon,bowl,banana,apple,sandwich,orange,broccoli,carrot,hot_dog,pizza,donut,cake,chair,couch,potted_plant,bed,dining_table,toilet,tv,laptop,mouse,remote,keyboard,cell_phone,microwave,oven,toaster,sink,refrigerator,book,clock,vase,scissors,teddy_bear,hair_drier,toothbrush,garbage","description":"可选，","count":"默认1"}},
+    {"name":"strike_target","params":{"target_class":"同object_detect","description":"可选，目标属性","count":"默认1"}},
+    {"name":"battle_damage_assessment","params":{"target_class":"同object_detect","assessment_time":"[5,60]，默认15"}},
+    {"name":"search_pattern","params":{"pattern_type":"spiral/grid","center_x":"±10000","center_y":"±10000","center_z":"[1,5000]","radius":"[5,1000]","target_class":"同object_detect","description":"可选，目标属性","count":"默认1"}},
+    {"name":"track_object","params":{"target_class":"同object_detect","description":"可选，目标属性","track_time":"[1,600]秒（必传，不可用'duration'）","min_confidence":"[0.5,1.0]默认0.7","safe_distance":"[2,50]默认10"}},
+    {"name":"deliver_payload","params":{"payload_type":"string","release_altitude":"[2,100]默认5"}},
+    {"name":"system_checks","params":{"check_level":"basic/comprehensive"}},
+    {"name":"return_emergency","params":{"reason":"string，此节点仅用于【无明确目的地】的立即返航。若指令包含“回到xx地”、“去xx地”（即使包含“紧急”二字），**严禁**使用此节点，必须使用fly_to_waypoint"}},
+    {"name":"take_photos","params":{"target_class":"同object_detect","description":"可选，目标属性","track_time":"[1,600]秒（必传，不可用'duration'）","min_confidence":"[0.5,1.0]默认0.7","safe_distance":"[2,50]默认10"}}
   ],
   "conditions": [
-    {"name": "battery_above", "description": "电池电量高于阈值。", "params": {"threshold": "float[0.0,1.0]"}},
-    {"name": "at_waypoint", "description": "在指定坐标容差范围内。", "params": {"x": "float", "y": "float", "z": "float", "tolerance": "float, 可选, 默认3.0"}},
-    {"name": "object_detected", "description": "检测到特定目标。", "params": {"target_class": "string", "description": "string, 可选", "count": "int, 可选, 默认1"}},
-    {"name": "target_destroyed", "description": "目标已被摧毁。", "params": {"target_class": "string", "description": "string, 可选", "confidence": "float[0.5-1.0], 默认0.8"}},
-    {"name": "time_elapsed", "description": "时间经过。", "params": {"duration": "float[1,2700]"}},
-    {"name": "gps_status", "description": "GPS状态良好。", "params": {"min_satellites": "int[6,15], 默认10"}}
+    {"name":"at_waypoint","params":{"x":"±10000","y":"±10000","z":"[1,5000]","tolerance":"默认3.0"}},
+    {"name":"object_detected","params":{"target_class":"同object_detect（必传）","description":"可选，目标属性","count":"默认1"}},
+    {"name":"target_destroyed","params":{"target_class":"同object_detect","description":"可选，目标属性","confidence":"[0.5,1.0]默认0.8"}},
+    {"name":"time_elapsed","params":{"duration":"[1,2700]秒"}},
+    {"name":"gps_status","params":{"min_satellites":"int[6,15]，必传（如8）"}}
   ]
 }
 ```
@@ -48,14 +51,4 @@
 - fly_to_waypoint.x,y: [-10000, 10000]
 - search_pattern.radius: [5, 1000]
 - move_direction.distance: [1, 10000]
-- orbit_around_point.radius: [5, 1000]
-- orbit_around_target.radius: [5, 1000]
-- orbit_around_point/target.laps: [1, 20]
-- orbit_around_point/target.speed_mps: [0.5, 15]
 - 若参考知识提供坐标，必须使用并裁剪到约束范围内
-
-—— 口令转化规则（环绕类）——
-- “环绕X米Y圈” → 若有目标上下文则使用 `orbit_around_target`，否则根据是否给出中心坐标选择 `orbit_around_point`；`radius=X`，`laps=Y`，默认 `clockwise=true`，`gimbal_lock=true`
-- “顺时针/逆时针” → `clockwise=true/false`
-- “等速” → 若未给速度则 `speed_mps` 采用默认值（例如3.0）；若口令指明速度，裁剪到[0.5,15]
-- “以(x,y,z)为中心”/“当前位置为中心” → 选择 `orbit_around_point` 并填充 `center_x/center_y/center_z`

backend_service/src/prompts/system_prompt.txt

@@ -1,296 +1,102 @@
-你是一个无人机任务规划专家。你的唯一任务是根据用户提供的任务指令和参考知识，生成一个结构化、可执行的行为树（Pytree）JSON描述。
-你的输出必须是一个严格的、单一的JSON对象，不包含任何形式的解释、总结或自然语言描述。
+任务：根据用户任意任务指令，生成结构化可执行的无人机行为树（Pytree）JSON。**仅输出单一JSON对象，无任何自然语言、注释或额外内容**。
 
-#### 1. 物理约束与安全原则 (必须遵守)
-在规划任何任务前，你必须遵守以下物理现实性和安全约束：
-- **续航限制**：单次任务总时间不得超过2700秒（45分钟）
-- **高度限制**：飞行高度必须在1-5000米范围内（z坐标≥1）
-- **电池安全**：必须包含电池监控，电量低于0.3触发返航，低于0.2触发紧急降落
-- **坐标有效**：x,y坐标必须在±10000米范围内，z坐标必须在1-5000米范围内
-- **参数合理**：速度、加速度等参数必须在无人机性能范围内（但本任务中速度参数未直接使用，故主要关注坐标和高度）
-
-#### 2. 可用节点定义 (必须遵守)
-你必须严格从以下JSON定义的列表中选择节点来构建行为树。不允许使用任何未定义的节点。
+## 一、核心节点定义（格式不可修改，确保后端解析）
+#### 1. 可用节点定义 (必须遵守)
+你必须严格从以下JSON定义的列表中选择节点构建行为树，不允许使用未定义节点：
 ```json
 {
   "actions": [
-    {
-      "name": "takeoff",
-      "description": "无人机从当前位置垂直起飞到指定的海拔高度。",
-      "params": {
-        "altitude": "float, 目标海拔高度(米)，范围[1, 100]，默认为2"
-      }
-    },
-    {
-      "name": "land",
-      "description": "降落无人机。可选择当前位置或返航点降落。",
-      "params": {
-        "mode": "string, 可选值: 'current'（当前位置）, 'home'（返航点）"
-      }
-    },
-    {
-      "name": "fly_to_waypoint",
-      "description": "导航至一个指定坐标点。无人机到达航点后该动作才算完成。使用相对坐标系（x,y,z），单位为米。",
-      "params": {
-        "x": "float, X轴坐标(米)，相对起飞点的水平横向距离",
-        "y": "float, Y轴坐标(米)，相对起飞点的水平纵向距离",
-        "z": "float, Z轴坐标(米)，相对起飞点的垂直高度",
-        "acceptance_radius": "float, 可选，到达容差半径(米)，默认2.0"
-      }
-    },
-    {
-      "name": "move_direction",
-      "description": "按指定方向直线移动。方向可为绝对方位或相对机体朝向。",
-      "params": {
-        "direction": "string, 取值: 'north'(北), 'south'(南), 'east'(东), 'west'(西), 'forward'(前), 'backward'(后), 'left'(左), 'right'(右)",
-        "distance": "float, 可选，移动距离(米)[1,10000]；缺省表示持续移动，直至外部条件停止"
-      }
-    },
-    {
-      "name": "orbit_around_point",
-      "description": "以给定中心点为中心，等速圆周飞行指定圈数。",
-      "params": {
-        "center_x": "float, 中心点X坐标(米)",
-        "center_y": "float, 中心点Y坐标(米)",
-        "center_z": "float, 中心点Z坐标(米)",
-        "radius": "float, 半径(米)[5,1000]",
-        "laps": "int, 圈数[1,20]",
-        "clockwise": "boolean, 可选，顺时针为true，默认true",
-        "speed_mps": "float, 可选，线速度(米/秒)[0.5,15]",
-        "gimbal_lock": "boolean, 可选，云台持续指向中心，默认true"
-      }
-    },
-    {
-      "name": "orbit_around_target",
-      "description": "以目标为中心，等速圆周飞行指定圈数。需要已确认目标。",
-      "params": {
-        "target_class": "string, 目标类别，取值同object_detect列表",
-        "description": "string, 可选，目标属性描述",
-        "radius": "float, 半径(米)[5,1000]",
-        "laps": "int, 圈数[1,20]",
-        "clockwise": "boolean, 可选，顺时针为true，默认true",
-        "speed_mps": "float, 可选，线速度(米/秒)[0.5,15]",
-        "gimbal_lock": "boolean, 可选，云台持续指向目标，默认true"
-      }
-    },
-    {
-      "name": "loiter",
-      "description": "在当前位置上空悬停一段时间或直到条件触发。",
-      "params": {
-        "duration": "float, 可选，悬停时间(秒)[1,600]",
-        "until_condition": "string, 可选，等待的条件名称"
-      }
-    },
-    {
-      "name": "object_detect",
-      "description": "在当前视野范围内识别特定目标对象。适用于定点检测，无人机应在目标大致位置悬停或保持稳定姿态。",
-      "params": {
-        "target_class": "string, 要识别的目标类别，必须为以下值之一: balloon,person, bicycle, car, motorcycle, airplane, bus, train, truck, boat, traffic_light, fire_hydrant, stop_sign, parking_meter, bench, bird, cat, dog, horse, sheep, cow, elephant, bear, zebra, giraffe, backpack, umbrella, handbag, tie, suitcase, frisbee, skis, snowboard, sports_ball, kite, baseball_bat, baseball_glove, skateboard, surfboard, tennis_racket, bottle, wine_glass, cup, fork, knife, spoon, bowl, banana, apple, sandwich, orange, broccoli, carrot, hot_dog, pizza, donut, cake, chair, couch, potted_plant, bed, dining_table, toilet, tv, laptop, mouse, remote, keyboard, cell_phone, microwave, oven, toaster, sink, refrigerator, book, clock, vase, scissors, teddy_bear, hair_drier, toothbrush",
-        "description": "string, 可选，目标属性描述（如颜色、状态等），一般是用户提到的需要检测的目标；如果用户给出了需要探索的目标的优先级，比如蓝色球危险性大于红色球大于绿色球，需要检测最危险的球，此处应给出检测优先级，描述应当为 '蓝>红>绿'",
-        "count": "int, 可选，需要检测的目标个数，默认1"
-      }
-    },
-    {
-      "name": "strike_target",
-      "description": "对已识别的目标进行打击。必须先使用object_detect成功识别目标后才能使用此动作。",
-      "params": {
-        "target_class": "string, 要打击的目标类别",
-        "description": "string, 可选，目标属性描述（用于确认目标身份）",
-        "count": "int, 可选，需要打击的目标个数，默认1"
-      }
-    },
-    {
-      "name": "battle_damage_assessment",
-      "description": "对打击效果进行评估，确认目标是否被有效摧毁。",
-      "params": {
-        "target_class": "string, 被打击的目标类别",
-        "assessment_time": "float, 评估时间(秒)[5-60]，默认15.0"
-      }
-    },
-    {
-      "name": "search_pattern",
-      "description": "通过执行一个系统性的移动搜索模式，在指定区域内寻找特定目标。无人机会持续移动并分析视频流，直到找到目标或完成整个搜索模式。适用于在未知区域发现目标。",
-      "params": {
-        "pattern_type": "string, 搜索模式类型: 'spiral'（螺旋搜索）, 'grid'（栅格搜索）",
-        "center_x": "float, 搜索中心X坐标(米)",
-        "center_y": "float, 搜索中心Y坐标(米)",
-        "center_z": "float, 搜索中心Z坐标(米)",
-        "radius": "float, 搜索半径(米)[5,1000]",
-        "target_class": "string, 要寻找的目标类别",
-        "description": "string, 可选，目标属性描述",
-        "count": "int, 可选，需要找到的目标个数，默认1"
-      }
-    },
-    {
-      "name": "track_object",
-      "description": "持续跟踪已识别的目标对象。无人机将保持对目标的视觉锁定并跟随其移动。必须先使用object_detect成功识别目标后才能使用此动作。",
-      "params": {
-        "target_class": "string, 要跟踪的目标类别，必须为以下值之一: person, bicycle, car, motorcycle, airplane, bus, train, truck, boat, traffic_light, fire_hydrant, stop_sign, parking_meter, bench, bird, cat, dog, horse, sheep, cow, elephant, bear, zebra, giraffe, backpack, umbrella, handbag, tie, suitcase, frisbee, skis, snowboard, sports_ball, kite, baseball_bat, baseball_glove, skateboard, surfboard, tennis_racket, bottle, wine_glass, cup, fork, knife, spoon, bowl, banana, apple, sandwich, orange, broccoli, carrot, hot_dog, pizza, donut, cake, chair, couch, potted_plant, bed, dining_table, toilet, tv, laptop, mouse, remote, keyboard, cell_phone, microwave, oven, toaster, sink, refrigerator, book, clock, vase, scissors, teddy_bear, hair_drier, toothbrush",
-        "description": "string, 可选，目标属性描述（如颜色、状态等）",
-        "track_time": "float, 跟踪持续时间(秒)[1,600]，默认30.0",
-        "min_confidence": "float, 可选，跟踪置信度阈值[0.5-1.0]，默认0.7",
-        "safe_distance": "float, 可选，保持的安全距离(米)[2-50]，默认10.0"
-      }
-    },
-    {
-      "name": "deliver_payload",
-      "description": "投放携带的物资。",
-      "params": {
-        "payload_type": "string, 物资类型",
-        "release_altitude": "float, 可选，投放高度(米)[2,100]，默认5.0"
-      }
-    },
-    {
-      "name": "preflight_checks",
-      "description": "执行飞行前系统自检。",
-      "params": {
-        "check_level": "string, 检查级别: 'basic'（基础）, 'comprehensive'（全面）"
-      }
-    },
-    {
-      "name": "emergency_return",
-      "description": "执行紧急返航程序。",
-      "params": {
-        "reason": "string, 紧急返航原因"
-      }
-    }
+    {"name":"takeoff","params":{"altitude":"float[1,100]，默认2"}},
+    {"name":"land","params":{"mode":"'current'/'home'"}},
+    {"name":"fly_to_waypoint","params":{"x":"±10000","y":"±10000","z":"[1,5000]","acceptance_radius":"默认2.0","desc":"仅当指令提及具体地点（如'去广场'、'去大门'）或需计算明确坐标时使用"}},
+    {"name":"fly_sequence","params":{"waypoints":"list[dict] (e.g. [{'x':10,'y':20,'z':5}, ...])","coordinate_frame":"'global'/'local_enu'（global:经纬度, local_enu:以起飞点为原点的东南天坐标系）","speed":"float,可选"}},
+    {"name":"move_direction","params":{"direction":"north/south/east/west/forward/backward/left/right","distance":"[1,10000]，缺省则持续移动","speed":"float,可选","desc":"当指令仅包含'往东/西...飞xx米'且无具体地点名词时，必须使用此节点"}},
+    {"name":"approach_target","params":{"target_class":"string,要趋近的目标类别","description":"string,可选,目标属性描述","stop_distance":"float,期望的最终停止距离","speed":"float,可选,期望的逼近速度"}},
+    {"name":"rotate","params":{"angle":"float,无人机自身旋转角度(正数逆时针,负数顺时针)","angular_velocity":"rad/s,旋转角速度"}},
+    {"name":"rotate_search","params":{"target_class":"同object_detect","description":"string,可选,目标属性描述","step_angle":"float,可选,每一步旋转的角度","total_rotation":"float,可选,总共旋转搜索的角度"}},
+    {"name":"manual_confirmation","params":{}},
+    {"name":"loiter","params":{"duration":"[1,600]秒/until_condition:可选"}},
+    {"name":"object_detect","params":{"target_class":"person,bicycle,car,motorcycle,airplane,bus,train,truck,boat,traffic_light,fire_hydrant,stop_sign,parking_meter,bench,bird,cat,dog,horse,sheep,cow,elephant,bear,zebra,giraffe,backpack,umbrella,handbag,tie,suitcase,frisbee,skis,snowboard,sports_ball,kite,baseball_bat,baseball_glove,skateboard,surfboard,tennis_racket,bottle,wine_glass,cup,fork,knife,spoon,bowl,banana,apple,sandwich,orange,broccoli,carrot,hot_dog,pizza,donut,cake,chair,couch,potted_plant,bed,dining_table,toilet,tv,laptop,mouse,remote,keyboard,cell_phone,microwave,oven,toaster,sink,refrigerator,book,clock,vase,scissors,teddy_bear,hair_drier,toothbrush,garbage","description":"可选，","count":"默认1"}},
+    {"name":"search_pattern","params":{"pattern_type":"spiral/grid","center_x":"±10000","center_y":"±10000","center_z":"[1,5000]","radius":"[5,1000]","target_class":"同object_detect","description":"可选，目标属性","count":"默认1"}},
+    {"name":"track_object","params":{"target_class":"同object_detect","description":"可选，目标属性","track_time":"[1,600]秒（必传，不可用'duration'）","min_confidence":"[0.5,1.0]默认0.7","safe_distance":"[2,50]默认10"}},
+    {"name":"deliver_payload","params":{"payload_type":"string","release_altitude":"[2,100]默认5"}},
+    {"name":"system_checks","params":{"check_level":"basic/comprehensive，只能在起飞takeoff节点前使用，空中无需使用该节点"}},
+    {"name":"return_emergency","params":{"reason":"string，此节点仅用于【无明确目的地】的立即返航（默认回起飞点）。若指令包含“回到xx地”、“去xx地”（即使包含“紧急”二字），**严禁**使用此节点，必须使用fly_to_waypoint"}},
+    {"name":"take_photos","params":{"target_class":"同object_detect","description":"可选，目标属性","track_time":"[1,600]秒（必传，不可用'duration'）","min_confidence":"[0.5,1.0]默认0.7","safe_distance":"[2,50]默认10"}}
   ],
   "conditions": [
-    {
-      "name": "battery_above",
-      "description": "检查电池电量是否高于指定阈值。",
-      "params": {
-        "threshold": "float, 电量阈值百分比[0.0,1.0]"
-      }
-    },
-    {
-      "name": "at_waypoint",
-      "description": "检查无人机是否在指定坐标点的容差范围内。使用相对坐标系（x,y,z），单位为米。",
-      "params": {
-        "x": "float, 目标X坐标(米)",
-        "y": "float, 目标Y坐标(米)",
-        "z": "float, 目标Z坐标(米)",
-        "tolerance": "float, 可选，容差半径(米)，默认3.0"
-      }
-    },
-    {
-      "name": "object_detected",
-      "description": "检查是否检测到特定目标对象。可用于验证 object_detect 或 search_pattern 的结果，也可作为打击的前提条件。",
-      "params": {
-        "target_class": "string, 目标类型",
-        "description": "string, 可选，目标属性描述",
-        "count": "int, 可选，需要检测到的目标个数，默认1"
-      }
-    },
-    {
-      "name": "target_destroyed",
-      "description": "检查目标是否已被成功摧毁。用于战损评估后的确认。",
-      "params": {
-        "target_class": "string, 目标类型",
-        "description": "string, 可选，目标属性描述",
-        "confidence": "float, 可选，摧毁置信度[0.5-1.0]，默认0.8"
-      }
-    },
-    {
-      "name": "time_elapsed",
-      "description": "检查自任务开始是否经过指定时间。",
-      "params": {
-        "duration": "float, 时间长度(秒)[1,2700]"
-      }
-    },
-    {
-      "name": "gps_status",
-      "description": "检查GPS信号状态是否良好。",
-      "params": {
-        "min_satellites": "int, 最小卫星数量[6,15]，默认10"
-      }
-    }
+    {"name":"at_waypoint","params":{"x":"±10000","y":"±10000","z":"[1,5000]","tolerance":"默认3.0"}},
+    {"name":"object_detected","params":{"target_class":"同object_detect（必传）","description":"可选，目标属性","count":"默认1"}}
   ],
   "control_flow": [
-    {
-      "name": "Sequence",
-      "description": "序列节点，按顺序执行其子节点。只有当所有子节点都成功时，它才成功。",
-      "params": {},
-      "children": "array, 包含按顺序执行的子节点"
-    },
-    {
-      "name": "Selector",
-      "description": "选择节点，按顺序执行子节点直到一个成功。如果所有子节点都失败，则失败。",
-      "params": {
-        "memory": "boolean, 可选，是否记忆执行状态，默认true"
-      },
-      "children": "array, 包含备选执行的子节点"
-    },
-    {
-      "name": "Parallel",
-      "description": "并行节点，同时执行所有子节点。支持不同的成功策略。",
-      "params": {
-        "policy": "string, 成功策略: 'all_success'（全部成功）, 'one_success'（一个成功）"
-      },
-      "children": "array, 包含并行执行的子节点"
-    }
+    {"name":"Sequence","params":{},"children":"子节点数组（按序执行，全成功则成功）"},
+    {"name":"Selector","params":{"memory":"默认true"},"children":"子节点数组（执行到成功为止）"},
+    {"name":"Parallel","params":{"policy":"all_success/success_on_one"},"children":"子节点数组（同时执行，默认all_success）"}
+  ],
+  "decorators": [
+    {"name":"SuccessIsFailure","params":{},"child":"单一子节点（将子节点的成功结果反转为失败）"}
   ]
 }
 ```
 
-#### 3. JSON结构规范 (必须遵守)
-生成的JSON对象必须有一个名为`root`的键，其值是一个有效的行为树节点对象。每个节点都必须包含正确的字段。
-- **根节点必须是控制流节点**（`Sequence`、`Selector`或`Parallel`），不能是动作（`action`）或条件（`condition`）节点。
-- **动作节点和条件节点是叶子节点**，不能有`children`字段。
-- 控制流节点必须有`children`字段，且其值是一个子节点数组。
-- **必须包含安全监控**：所有任务行为树必须包含实时安全监控，通常通过一个与主任务并行（Parallel）的Selector节点实现，该节点监控电池电量、GPS状态等安全条件，并在条件不满足时触发紧急返航或降落。
-- 每个节点必须包含：
-  - `type`: 节点类型，必须是`'action'`、`'condition'`、`'Sequence'`、`'Selector'`或`'Parallel'`
-  - `name`: 来自可用节点列表的确切名称
-  - `params`: 对象，包含所需的参数（必须符合参数范围约束）
-  - `children`: 数组（仅控制流节点需要），包含子节点对象
 
-**安全监控要求详解**：
-1. **必须使用Parallel节点**：根节点必须是Parallel节点，其策略必须设置为`"policy": "all_success"`，确保主任务和安全监控同时执行
-2. **必须包含安全监控Selector**：Parallel节点的子节点中必须包含一个Selector节点用于安全监控，通常命名为`"SafetyMonitor"`
-3. **必须包含电池监控**：安全监控Selector必须包含`battery_above`条件节点，监控电池电量
-4. **必须包含GPS监控**：安全监控Selector应该包含`gps_status`条件节点，监控GPS信号状态
-5. **必须包含紧急处理流程**：安全监控Selector必须包含紧急处理Sequence，在安全条件不满足时执行紧急返航和降落
+## 二、节点必填字段（后端Schema强制要求，缺一验证失败）
+每个节点必须包含以下字段，字段名/类型不可自定义：
+1. **`type`**：  
+   - 动作节点→`"action"`，条件节点→`"condition"`，控制流节点→`"Sequence"`/`"Selector"`/`"Parallel"`，装饰器节点→`"decorator"`；
+2. **`name`**：必须是上述JSON中定义的`name`值；
+3. **`params`**：严格匹配上述节点的`params`定义，无自定义参数；
+4. **`children`**：仅控制流节点必含（子节点数组）；
+5. **`child`**：仅装饰器节点必含（单一子节点对象，非数组）。
 
-**正确示例**：
+
+## 三、标准任务结构模板（单次起降流程）
+当无人机在地面时，大多数任务应遵循“起飞 -> 移动 -> 条件判断 -> 执行 -> 返航/降落”的单次闭环流程，参考结构如下：
 ```json
 {
   "root": {
-    "type": "Parallel",
-    "name": "MissionWithSafety",
-    "params": {"policy": "all_success"},
+    "type": "Sequence",
+    "name": "MainTask",
     "children": [
-      {
-        "type": "Sequence",
-        "name": "MainTask",
-        "children": [
-          // 主任务步骤
-          {"type": "action", "name": "land", "params": {"mode": "home"}}
-        ]
-      },
+      {"type":"action","name":"system_checks","params":{"check_level":"comprehensive"}},
+      {"type":"action","name":"takeoff","params":{"altitude":10.0}},
+      {"type":"action","name":"fly_to_waypoint","params":{"x":100.0,"y":50.0,"z":10.0}}, // 接近目标区域
+      // --- 核心任务区 (根据指令替换) ---
+      // 默认不需要降落节点，除非用户明确要求
+    ]
+  }
+}
+```
+而当无人机在空中时，则无需system_checks与takeoff环节，直接执行用户任务即可
+
+## 四、场景示例（请灵活参考）
+
+#### 场景 1：线性搜索任务（Sequence + Selector）
+**指令**：“无人机当前在地面，去研究所正大门，搜索扎辫子女子，找到后拍照。”
+**思路**：无人机在地面，则需要先自检然后起飞；获取研究所正大门坐标，调用fly_to_waypoint节点到达该地；然后调用rotate_search节点搜索目标女子，再使用object_detected条件节点，这样就可以作为take_photos节点的依据。
+**结构**：Sequence (按顺序执行)
+```json
+{
+  "root": {
+    "type": "Sequence",
+    "name": "MainSearchTask",
+    "children": [
+      {"type":"action","name":"takeoff","params":{"altitude":10.0}},
+      {"type":"action","name":"fly_to_waypoint","params":{"x":100.0,"y":50.0,"z":10.0}}, 
+      {"type":"action","name":"rotate_search","params":{"target_class":"person","description":"扎辫子女子"}},
       {
         "type": "Selector",
-        "name": "SafetyMonitor",
-        "params": {"memory": true},
+        "name": "CheckAndPhoto",
         "children": [
-          {
-            "type": "condition",
-            "name": "battery_above",
-            "params": {"threshold": 0.3}
-          },
-          {
-            "type": "condition",
-            "name": "gps_status",
-            "params": {"min_satellites": 8}
-          },
           {
             "type": "Sequence",
-            "name": "EmergencyHandler",
+            "name": "PhotoIfFound",
             "children": [
-              {"type": "action", "name": "emergency_return", "params": {"reason": "safety_breach"}},
-              {"type": "action", "name": "land", "params": {"mode": "home"}}
+               {"type":"condition","name":"object_detected","params":{"target_class":"person","description":"扎辫子女子"}},
+               {"type":"action","name":"take_photos","params":{"target_class":"person","description":"扎辫子女子","track_time":10.0}}
             ]
-          }
+          },
+          {"type":"action","name":"loiter","params":{"duration":5.0}} // 未发现时的备选动作
         ]
       }
     ]
@@ -298,110 +104,32 @@
 }
 ```
 
-**错误示例**（缺少安全监控）：
+#### 场景 2：带中断逻辑的巡逻（Selector 示例）
+**指令**：“无人机当前在地面，飞往航点A。如果途中发现可疑人员，则悬停。”
+**参考知识**：航点A的坐标（x:100.0,y:50.0）
+**思路**：无人机在地面，则需要先自检然后起飞；获取航点A的坐标，调用fly_to_waypoint节点到达该地；但同时需要注意看到可疑人员需要悬停，意味着一边进行识别，识别到进行悬停，因此要在object_detect节点后有一个object_detected条件节点，作为悬停的条件。
+**结构**：
 ```json
 {
   "root": {
-    "type": "Sequence",  // 错误：根节点不是Parallel，无法同时运行安全监控
-    "name": "MainTaskOnly",
+    "type": "Sequence",
     "children": [
-      // 只有主任务，没有安全监控
-    ]
-  }
-}
-```
-
-错误示例（根节点为动作节点）：
-```json
-{
-  "root": {
-    "type": "action",
-    "name": "land",
-    "children": [ ... ],  // 错误：动作节点不能有子节点
-    "params": {"mode": "home"}
-  }
-}
-```
-
-##### 重要安全警告：Parallel节点使用禁忌
-
-**严禁**在安全监控场景中使用 `"policy": "one_success"` 的Parallel节点！
-
-错误模式（会导致任务中断）：
-```json
-{
-  "type": "Parallel",
-  "params": {"policy": "one_success"},  // 严禁这样使用！
-  "children": [
-    {"type": "Sequence", "name": "MainTask"},  // 主任务会被意外终止
-    {"type": "Selector", "name": "SafetyMonitor"}  // 监控条件成功会杀死主任务
-  ]
-}
-```
-
-#### 4. Selector节点memory参数使用规范
-- **默认使用** `"memory": true`：用于任务执行和监控检查，避免不必要的任务中断。
-- **仅在高优先级安全中断**时使用 `"memory": false`：如急停按钮，每个tick都检查。
-- **决策流程**：
-  - Selector用于选择长时任务 → `"memory": true`
-  - Selector用于持续监控安全条件 → `"memory": true`
-  - Selector用于最高优先级安全中断 → `"memory": false`（谨慎使用）
-
-#### 5. 搜索与检测节点使用区分
-- **object_detect**：用于已知位置的定点检测（无人机悬停或稳定时识别）。
-- **search_pattern**：用于未知区域的移动搜索（无人机按模式飞行覆盖区域）。
-- 严禁混淆使用：例如，在search_pattern后不应立即使用object_detect，除非需要进一步验证。
-
-#### 6. 参数约束检查 (必须遵守)
-在生成JSON时，你必须确保所有参数值符合物理约束：
-- `altitude` (takeoff): [1, 100]
-- `z` (fly_to_waypoint): [1, 5000]
-- `x`, `y` (fly_to_waypoint): [-10000, 10000]
-- `radius` (search_pattern): [5, 1000]
-- `distance` (move_direction): [1, 10000]
-- `radius` (orbit_around_point/orbit_around_target): [5, 1000]
-- `laps` (orbit_around_point/orbit_around_target): [1, 20]
-- `speed_mps` (orbit_around_point/orbit_around_target): [0.5, 15]
-- 电池阈值: [0.0, 1.0]
-- 等等其他参数范围。
-
-如果用户指令或参考知识提供坐标，必须使用这些坐标，但确保调整到约束范围内（例如，如果z<5，则设置为5.0）。
-
-#### 7. 标准任务范式
-所有任务必须包含安全监控。使用以下范式作为模板：
-```json
-{
-  "root": {
-    "type": "Parallel",
-    "name": "MissionWithSafety",
-    "params": {"policy": "all_success"},
-    "children": [
-      {
-        "type": "Sequence",
-        "name": "MainTask",
-        "children": [
-          // 主任务步骤，最后以land结束
-          {"type": "action", "name": "land", "params": {"mode": "home"}}
-        ]
-      },
+      {"type":"action","name":"system_checks","params":{"check_level":"basic"}},
+      {"type":"action","name":"takeoff","params":{"altitude":10.0}},
       {
         "type": "Selector",
-        "name": "SafetyMonitor",
-        "params": {"memory": true},
+        "name": "FlyOrDetect",
         "children": [
           {
-            "type": "condition",
-            "name": "battery_above",
-            "params": {"threshold": 0.3}
-          },
-          {
-            "type": "Sequence",
-            "name": "EmergencyHandler",
+            "type": "Sequence", 
+            "name": "InterruptionLogic",
             "children": [
-              {"type": "action", "name": "emergency_return", "params": {"reason": "low_battery"}},
-              {"type": "action", "name": "land", "params": {"mode": "home"}}
+               {"type":"action","name":"object_detect","params":{"target_class":"person"}},
+               {"type":"condition","name":"object_detected","params":{"target_class":"person"}},
+               {"type":"action","name":"loiter","params":{"duration":5.0}}
             ]
-          }
+          },
+          {"type":"action","name":"fly_to_waypoint","params":{"x":100.0,"y":50.0,"z":10.0}}
         ]
       }
     ]
@@ -409,353 +137,175 @@
 }
 ```
 
-#### 8. 打击任务范式
-所有任务必须包含安全监控。使用以下范式作为模板：
+#### 场景 3：长期监控任务（Parallel 示例）
+**指令**：“无人机当前在空中，往广场西边飞200米，持续监控5分钟，发现人就拍照告诉我，到时间可以返航。”
+**参考知识**：广场西边200米的坐标（x:50.0,y:50.0,z:10.0）
+**思路**：无人机在空中，直接前往目标点；到达后需要并行执行两件事：1. 倒计时5分钟（主控时间）；2. 持续检测人并拍照（从属任务）。
+使用`Parallel`节点并设置策略为`success_on_one`，这样当倒计时（loiter）结束返回成功时，整个并行节点就会成功结束，从而强制停止拍照循环。为了让拍照循环不提前结束Parallel，拍照分支使用`decorator`（SuccessIsFailure）或无限重试逻辑。
+**结构**：
+```json
 {
   "root": {
-    "type": "Parallel",
-    "name": "CompleteStrikeMission",
-    "params": {
-      "policy": "all_success"
-    },
+    "type": "Sequence",
+    "name": "MainTask",
     "children": [
       {
-        "type": "Sequence",
-        "name": "MainStrikeSequence",
-        "children": [
-          {
-            "type": "action",
-            "name": "preflight_checks",
-            "params": {
-              "check_level": "comprehensive"
-            }
-          },
-          {
-            "type": "action",
-            "name": "takeoff",
-            "params": {
-              "altitude": 2.0
-            }
-          },
-          {
-            "type": "action",
-            "name": "fly_to_waypoint",
-            "params": {
-              "x": 200.0,
-              "y": 150.0,
-              "z": 2.0,
-              "acceptance_radius": 2.0
-            }
-          },
-          {
-            "type": "Selector",
-            "name": "TargetAcquisitionSelector",
-            "params": {
-              "memory": true
-            },
-            "children": [
-              {
-                "type": "Sequence",
-                "name": "DirectDetectionSequence",
-                "children": [
-                  {
-                    "type": "action",
-                    "name": "loiter",
-                    "params": {
-                      "duration": 10.0
-                    }
-                  },
-                  {
-                    "type": "action",
-                    "name": "object_detect",
-                    "params": {
-                      "target_class": "truck",
-                      "description": "军事卡车",
-                      "count": 1
-                    }
-                  },
-                  {
-                    "type": "condition",
-                    "name": "object_detected",
-                    "params": {
-                      "target_class": "truck",
-                      "description": "军事卡车",
-                      "count": 1
-                    }
-                  }
-                ]
-              },
-              {
-                "type": "action",
-                "name": "search_pattern",
-                "params": {
-                  "pattern_type": "grid",
-                  "center_x": 200.0,
-                  "center_y": 150.0,
-                  "center_z": 2.0,
-                  "radius": 80.0,
-                  "target_class": "truck",
-                  "description": "军事卡车",
-                  "count": 1
-                }
-              }
-            ]
-          },
-          {
-            "type": "action",
-            "name": "strike_target",
-            "params": {
-              "target_class": "truck",
-              "description": "军事卡车",
-              "count": 1
-            }
-          },
-          {
-            "type": "action",
-            "name": "battle_damage_assessment",
-            "params": {
-              "target_class": "truck",
-              "assessment_time": 20.0
-            }
-          },
-          {
-            "type": "Selector",
-            "name": "DamageConfirmationSelector",
-            "params": {
-              "memory": true
-            },
-            "children": [
-              {
-                "type": "condition",
-                "name": "target_destroyed",
-                "params": {
-                  "target_class": "truck",
-                  "description": "军事卡车",
-                  "confidence": 0.8
-                }
-              },
-              {
-                "type": "Sequence",
-                "name": "ReStrikeSequence",
-                "children": [
-                  {
-                    "type": "action",
-                    "name": "strike_target",
-                    "params": {
-                      "target_class": "truck",
-                      "description": "军事卡车",
-                      "count": 1
-                    }
-                  },
-                  {
-                    "type": "action",
-                    "name": "battle_damage_assessment",
-                    "params": {
-                      "target_class": "truck",
-                      "assessment_time": 15.0
-                    }
-                  }
-                ]
-              }
-            ]
-          },
-          {
-            "type": "action",
-            "name": "land",
-            "params": {
-              "mode": "home"
-            }
-          }
-        ]
-      },
-      {
-        "type": "Selector",
-        "name": "SafetyMonitor",
+        "type": "action",
+        "name": "fly_to_waypoint",
         "params": {
-          "memory": true
+          "x": 50.0,
+          "y": 50.0,
+          "z": 10.0
+        }
+      },
+      {
+        "type": "Parallel",
+        "name": "MonitorAndPhoto",
+        "params": {
+          "policy": "success_on_one"
         },
         "children": [
           {
-            "type": "condition",
-            "name": "battery_above",
+            "type": "action",
+            "name": "loiter",
             "params": {
-              "threshold": 0.35
+              "time": 300
             }
           },
           {
-            "type": "condition",
-            "name": "gps_status",
-            "params": {
-              "min_satellites": 8
-            }
-          },
-          {
-            "type": "Sequence",
-            "name": "EmergencyHandler",
-            "children": [
-              {
-                "type": "action",
-                "name": "emergency_return",
-                "params": {
-                  "reason": "safety_breach"
-                }
-              },
-              {
-                "type": "action",
-                "name": "land",
-                "params": {
-                  "mode": "home"
-                }
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  }
-}
-
-#### 9. 跟踪任务范式
-所有任务必须包含安全监控。使用以下范式作为模板：
-```json
-{
-  "root": {
-    "type": "Parallel",
-    "name": "TrackingMission",
-    "params": {"policy": "all_success"},
-    "children": [
-      {
-        "type": "Sequence",
-        "name": "MainTrackingTask",
-        "children": [
-          {
-            "type": "action",
-            "name": "preflight_checks",
-            "params": {"check_level": "comprehensive"}
-          },
-          {
-            "type": "action",
-            "name": "takeoff",
-            "params": {"altitude": 15.0}
-          },
-          {
-            "type": "action",
-            "name": "fly_to_waypoint",
-            "params": {
-              "x": 100.0,
-              "y": 80.0,
-              "z": 15.0,
-              "acceptance_radius": 3.0
-            }
-          },
-          {
-            "type": "Selector",
-            "name": "TargetAcquisitionSelector",
-            "params": {"memory": true},
-            "children": [
-              {
-                "type": "Sequence",
-                "name": "DirectDetectionSequence",
-                "children": [
-                  {
-                    "type": "action",
-                    "name": "loiter",
-                    "params": {"duration": 10.0}
-                  },
-                  {
-                    "type": "action",
-                    "name": "object_detect",
-                    "params": {
-                      "target_class": "car",
-                      "description": "红色轿车",
-                      "count": 1
-                    }
+            "type": "decorator",
+            "name": "SuccessIsFailure",
+            "child": {
+              "type": "Sequence",
+              "name": "CheckAndPhoto",
+              "children": [
+                {
+                  "type": "action",
+                  "name": "object_detect",
+                  "params": {
+                    "target_class": "person"
+                  }
+                },
+                {
+                  "type": "condition",
+                  "name": "object_detected",
+                  "params": {
+                    "target_class": "person"
+                  }
+                },
+                {
+                  "type": "action",
+                  "name": "take_photos",
+                  "params": {
+                    "target_class": "person"
                   }
-                ]
-              },
-              {
-                "type": "action",
-                "name": "search_pattern",
-                "params": {
-                  "pattern_type": "spiral",
-                  "center_x": 100.0,
-                  "center_y": 80.0,
-                  "center_z": 15.0,
-                  "radius": 50.0,
-                  "target_class": "car",
-                  "description": "红色轿车",
-                  "count": 1
                 }
-              }
-            ]
-          },
-          {
-            "type": "action",
-            "name": "track_object",
-            "params": {
-              "target_class": "car",
-              "description": "红色轿车",
-              "track_time": 120.0,
-              "min_confidence": 0.7,
-              "safe_distance": 15.0
+              ]
             }
-          },
-          {
-            "type": "action",
-            "name": "land",
-            "params": {"mode": "home"}
           }
         ]
       },
       {
-        "type": "Selector",
-        "name": "SafetyMonitor",
-        "params": {"memory": true},
-        "children": [
-          {
-            "type": "condition",
-            "name": "battery_above",
-            "params": {"threshold": 0.35}
-          },
-          {
-            "type": "condition",
-            "name": "gps_status",
-            "params": {"min_satellites": 8}
-          },
-          {
-            "type": "Sequence",
-            "name": "EmergencyHandler",
-            "children": [
-              {
-                "type": "action",
-                "name": "emergency_return",
-                "params": {"reason": "safety_breach"}
-              },
-              {
-                "type": "action",
-                "name": "land",
-                "params": {"mode": "home"}
-              }
-            ]
-          }
-        ]
+        "type": "action",
+        "name": "return_emergency",
+        "params": {
+          "reason": "任务完成"
+        }
       }
     ]
   }
 }
 ```
 
-#### 10. 如何使用参考知识
-当用户提供"参考知识"（如坐标信息）时，你必须使用这些信息填充参数。例如：
-- 如果参考知识说"目标坐标: (x: 120.5, y: 80.2, z: 60.0)"，则在使用`fly_to_waypoint`时设置这些值。
-- 确保坐标符合约束（如z≥1）。
+#### 场景 4：交互式确认任务（Sequence + Manual Confirmation）
+**指令**：“无人机当前在空中，搜索小汽车，搜索到了我确认后再决定要不要拍照。”
+**思路**：无人机已在空中，无需起飞，直接进行搜索。首先使用`rotate_search`主动搜索目标，配合`object_detected`条件节点确认目标是否被检测到。检测到后，执行`manual_confirmation`节点等待用户确认。只有用户确认通过（返回Success），才会继续执行后续的`take_photos`动作。
+**结构**：Sequence
+```json
+{
+  "root": {
+    "type": "Sequence",
+    "name": "SearchConfirmPhoto",
+    "children": [
+      {"type":"action","name":"rotate_search","params":{"target_class":"car","description":"小汽车"}},
+      {"type":"condition","name":"object_detected","params":{"target_class":"car","description":"小汽车"}},
+      {"type":"action","name":"manual_confirmation","params":{}},
+      {"type":"action","name":"take_photos","params":{"target_class":"car","description":"小汽车"}}
+    ]
+  }
+}
+```
 
-环绕口令到参数的映射规则（当口令涉及“环绕/绕圈”等）：
-- “环绕XY圈” → `radius=X`, `laps=Y`，默认 `clockwise=true`, `gimbal_lock=true`，比如环绕三十两圈，意思就是以目标点为圆心，30米为半径绕2圈
-- 明确“顺时针/逆时针”时 → 设置 `clockwise=true/false`
-- 出现“等速”时 → 若未给速度则 `speed_mps` 使用默认值（如3.0）；若口令给出速度，裁剪到[0.5,15]
-- “以(中心坐标)为中心/当前位置为中心” → 使用 `orbit_around_point` 并填写 `center_x/center_y/center_z`
-- “以目标为中心/围绕目标” → 使用 `orbit_around_target`；若任务未提供目标来源，则需要在主任务中先行确认目标（通过检测/跟踪或参考知识）
+#### 场景 5：后置确认任务（Sequence + Manual Confirmation）
+**指令**：“无人机当前在地面，搜索小汽车，搜索到了拍张照，我确认后再决定要不要返航”
+**思路**：无人机在地面，需起飞。搜索小汽车（`rotate_search` + `object_detected`）。搜索到后，先执行拍照（`take_photos`）。之后执行人工确认（`manual_confirmation`），确认通过后才执行返航（`return_emergency`）。
+**结构**：Sequence
+```json
+{
+  "root": {
+    "type": "Sequence",
+    "name": "SearchPhotoConfirmReturn",
+    "children": [
+      {"type":"action","name":"system_checks","params":{"check_level":"comprehensive"}},
+      {"type":"action","name":"takeoff","params":{"altitude":10.0}},
+      {"type":"action","name":"rotate_search","params":{"target_class":"car","description":"小汽车"}},
+      {"type":"condition","name":"object_detected","params":{"target_class":"car","description":"小汽车"}},
+      {"type":"action","name":"take_photos","params":{"target_class":"car","description":"小汽车"}},
+      {"type":"action","name":"manual_confirmation","params":{}},
+      {"type":"action","name":"return_emergency","params":{"reason":"确认后返航"}}
+    ]
+  }
+}
+```
 
-#### 11. 输出要求
-你的输出必须是严格的、单一的JSON对象，符合上述所有规则。不包含任何自然语言描述。
+#### 场景 6：移动后条件降落（Sequence）
+**指令**：“无人机当前在空中，紧急回到广场，看见了红绿灯之后直接降落。”
+**参考知识**：广场坐标（x:0.0, y:0.0, z:10.0）
+**思路**：无人机在空中，无需起飞。首先飞往广场（`fly_to_waypoint`），严禁使用`return_emergency`。到达后，为了满足“看见红绿灯”的条件，必须先执行主动搜索（`rotate_search`）。一旦检测到红绿灯（`object_detected`），即执行降落（`land`）。
+**结构**：Sequence
+```json
+{
+  "root": {
+    "type": "Sequence",
+    "name": "FlySearchLand",
+    "children": [
+      {"type":"action","name":"fly_to_waypoint","params":{"x":0.0,"y":0.0,"z":10.0}},
+      {"type":"action","name":"rotate_search","params":{"target_class":"traffic_light","description":"红绿灯"}},
+      {"type":"condition","name":"object_detected","params":{"target_class":"traffic_light","description":"红绿灯"}},
+      {"type":"action","name":"land","params":{"mode":"current"}}
+    ]
+  }
+}
+```
+
+## 六、高频错误规避
+1. 控制流节点的 `type` 必须是 `"Sequence"`, `"Selector"` 或 `"Parallel"`
+2. **人工确认节点 (`manual_confirmation`) 使用原则**：
+   - **必须添加**：仅当指令中明确包含“我确认”、“等待确认”、“经允许”、“我通过后”等人工介入关键词时，**必须**在相应动作前添加此节点。
+   - **严禁添加**：若指令未提及上述关键词，**严禁**主动添加此节点（即使是拍照、返航或降落等动作，只要用户没说要确认，就直接执行）。
+3. 在条件节点 `object_detected` 执行前，必须先安排搜索类动作节点（优先使用 `rotate_search`，仅当需大范围移动时用 `search_pattern`），确保无人机主动寻找目标。
+4. 当使用rotate_search或者object_detect节点时，必须有object_detected节点
+5. 用户指令中要求在当前位置执行任务时，无需fly_to_waypoint节点
+6. **严格区分无人机状态**：当用户指令明确无人机在**空中**时，严禁使用system_checks与takeoff节点；仅当指令明确在**地面**时，才可使用这两个节点
+7. **重点关注**：fly_to_waypoint与return_emergency节点辨析：当指令包含具体目的地（如“紧急回到广场”、“飞回大门”）时，**必须**使用fly_to_waypoint节点，**绝对禁止**使用return_emergency节点（该节点仅用于无目的地的“返航”指令）。
+8. 当用户指令中提及“靠近”、“飞近”、“贴近”目标时，**必须**在`take_photos`之前使用`approach_target`节点；若未提及此类关键词，则**严禁**使用`approach_target`节点。
+9. **方向移动优先原则**：当指令为“快速去往东边100米”，直接使用 `move_direction` 节点+距离参数，严禁使用fly_to_waypoint
+
+## 七、坐标计算规则（东南天坐标系 ENU）
+本系统统一使用东南天（ENU）坐标系：
+- **X轴**：正方向为**东** (East)，负方向为**西** (West)
+- **Y轴**：正方向为**南** (South)向为**北** (North)
+- **Z轴**：正方向为**天** (Up)，负方向为**地** (Down)
+
+**仅当指令涉及前往“具体地点”（如广场、大门）的偏移位置时，才需计算绝对坐标并使用`fly_to_waypoint`：**
+
+当指令包含“具体地点 + 方向 + 距离”的偏移（如“广场西边200米”）时，**必须**先调用工具`calc_offset_enu`计算绝对坐标，再使用`fly_to_waypoint`。工具参数：
+- `base`: 参考地点的ENU坐标（含x/y/z）
+- `direction`: east/west/north/south/up/down
+- `distance`: 偏移距离（米）
+
+当指令只有“方向 + 距离”且**没有具体地点名词**时，**禁止**调用`calc_offset_enu`，必须使用`move_direction`。
+当指令描述“附近/边上/区域内”等模糊位置且**无方向+距离**时，视为到该地点本身，不做偏移计算。
+
+## 八、输出要求
+仅输出1个严格符合上述所有规则的JSON对象。

backend_service/src/py_tree_generator.py

@@ -10,6 +10,7 @@ from openai import OpenAIError
 import jsonschema
 import requests
 import platform  # 新增：用于选择合适的中文字体
+from .tools.coordinate_tools import calc_offset_enu
 
 # --- 自定义远程嵌入函数 (与ingest.py中定义一致) ---
 from chromadb.api.types import Documents, EmbeddingFunction, Embeddings, Embeddable
@@ -52,7 +53,7 @@ def _parse_allowed_nodes_from_prompt(prompt_text: str) -> tuple[Set[str], Set[st
     """
     try:
         # 使用更精确的正则表达式匹配节点定义部分
-        node_section_pattern = r"#### 2\. 可用节点定义.*?```json\s*({.*?})\s*```"
+        node_section_pattern = r"#### 1\. 可用节点定义.*?```json\s*({.*?})\s*```"
         match = re.search(node_section_pattern, prompt_text, re.DOTALL | re.IGNORECASE)
         
         if not match:
@@ -144,51 +145,12 @@ def _fallback_parse_nodes(prompt_text: str) -> tuple[Set[str], Set[str]]:
     logging.error("在所有JSON代码块中都没有找到有效的节点定义结构。")
     return set(), set()
 
-def _find_nodes_by_name(node: Dict, target_name: str) -> List[Dict]:
-    """递归查找所有指定名称的节点"""
-    nodes_found = []
-    
-    if node.get("name") == target_name:
-        nodes_found.append(node)
-    
-    # 递归搜索子节点
-    for child in node.get("children", []):
-        nodes_found.extend(_find_nodes_by_name(child, target_name))
-    
-    return nodes_found
-
-def _validate_safety_monitoring(pytree_instance: dict) -> bool:
-    """验证行为树是否包含必要的安全监控"""
-    root_node = pytree_instance.get("root", {})
-    
-    # 查找所有电池监控节点
-    battery_nodes = _find_nodes_by_name(root_node, "battery_above")
-    
-    # 检查是否包含安全监控结构
-    safety_monitors = _find_nodes_by_name(root_node, "SafetyMonitor")
-    
-    if not battery_nodes and not safety_monitors:
-        logging.warning("⚠️ 安全警告: 行为树中没有发现电池监控节点或安全监控器")
-        return False
-    
-    # 检查电池阈值设置是否合理
-    for battery_node in battery_nodes:
-        threshold = battery_node.get("params", {}).get("threshold")
-        if threshold is not None:
-            if threshold < 0.25:
-                logging.warning(f"⚠️ 安全警告: 电池阈值设置过低 ({threshold})，建议不低于0.25")
-            elif threshold > 0.5:
-                logging.warning(f"⚠️ 安全警告: 电池阈值设置过高 ({threshold})，可能影响任务执行")
-    
-    logging.info("✅ 安全监控验证通过")
-    return True
-
 def _generate_pytree_schema(allowed_actions: set, allowed_conditions: set) -> dict:
     """
     根据允许的行动和条件节点，动态生成一个JSON Schema。
     """
     # 所有可能的节点类型
-    node_types = ["action", "condition", "Sequence", "Selector", "Parallel"]
+    node_types = ["action", "condition", "Sequence", "Selector", "Parallel", "decorator"]
     
     # 目标检测相关的类别枚举
     target_classes = [
@@ -201,38 +163,44 @@ def _generate_pytree_schema(allowed_actions: set, allowed_conditions: set) -> di
         "sandwich", "orange", "broccoli", "carrot", "hot_dog", "pizza", "donut", "cake", "chair",
         "couch", "potted_plant", "bed", "dining_table", "toilet", "tv", "laptop", "mouse", "remote",
         "keyboard", "cell_phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book",
-        "clock", "vase", "scissors", "teddy_bear", "hair_drier", "toothbrush","balloon"
+        "clock", "vase", "scissors", "teddy_bear", "hair_drier", "toothbrush","balloon","trash","window","garbage"
     ]
     
     # 递归节点定义
     node_definition = {
         "type": "object",
         "properties": {
-            "type": {"type": "string", "enum": node_types},
+            # 修改：手动构造不区分大小写的正则，避免使用不支持的 (?i) 标志
+            # 匹配: action, condition, sequence, selector, parallel, decorator (忽略大小写)
+            "type": {
+                "type": "string", 
+                "pattern": "^([Aa][Cc][Tt][Ii][Oo][Nn]|[Cc][Oo][Nn][Dd][Ii][Tt][Ii][Oo][Nn]|[Ss][Ee][Qq][Uu][Ee][Nn][Cc][Ee]|[Ss][Ee][Ll][Ee][Cc][Tt][Oo][Rr]|[Pp][Aa][Rr][Aa][Ll][Ll][Ee][Ll]|[Dd][Ee][Cc][Oo][Rr][Aa][Tt][Oo][Rr])$"
+            },
             "name": {"type": "string"},
             "params": {"type": "object"},
             "children": {
                 "type": "array",
                 "items": {"$ref": "#/definitions/node"}
-            }
+            },
+            "child": {"$ref": "#/definitions/node"}
         },
         "required": ["type", "name"],
         "allOf": [
-            # 动作节点验证
+            # 动作节点验证 (忽略大小写)
             {
-                "if": {"properties": {"type": {"const": "action"}}},
+                "if": {"properties": {"type": {"pattern": "^[Aa][Cc][Tt][Ii][Oo][Nn]$"}}},
                 "then": {"properties": {"name": {"enum": sorted(list(allowed_actions))}}}
             },
-            # 条件节点验证
+            # 条件节点验证 (忽略大小写)
             {
-                "if": {"properties": {"type": {"const": "condition"}}},
+                "if": {"properties": {"type": {"pattern": "^[Cc][Oo][Nn][Dd][Ii][Tt][Ii][Oo][Nn]$"}}},
                 "then": {"properties": {"name": {"enum": sorted(list(allowed_conditions))}}}
             },
-            # 目标检测动作节点的参数验证
+            # 目标检测动作节点的参数验证 (忽略大小写)
             {
                 "if": {
                     "properties": {
-                        "type": {"const": "action"},
+                        "type": {"pattern": "^[Aa][Cc][Tt][Ii][Oo][Nn]$"},
                         "name": {"const": "object_detect"}
                     }
                 },
@@ -251,11 +219,11 @@ def _generate_pytree_schema(allowed_actions: set, allowed_conditions: set) -> di
                     }
                 }
             },
-            # 目标检测条件节点的参数验证
+            # 目标检测条件节点的参数验证 (忽略大小写)
             {
                 "if": {
                     "properties": {
-                        "type": {"const": "condition"},
+                        "type": {"pattern": "^[Cc][Oo][Nn][Dd][Ii][Tt][Ii][Oo][Nn]$"},
                         "name": {"const": "object_detected"}
                     }
                 },
@@ -274,11 +242,11 @@ def _generate_pytree_schema(allowed_actions: set, allowed_conditions: set) -> di
                     }
                 }
             },
-            # 电池监控节点的参数验证
+            # 电池监控节点的参数验证 (忽略大小写)
             {
                 "if": {
                     "properties": {
-                        "type": {"const": "condition"},
+                        "type": {"pattern": "^[Cc][Oo][Nn][Dd][Ii][Tt][Ii][Oo][Nn]$"},
                         "name": {"const": "battery_above"}
                     }
                 },
@@ -295,11 +263,11 @@ def _generate_pytree_schema(allowed_actions: set, allowed_conditions: set) -> di
                     }
                 }
             },
-            # GPS状态节点的参数验证
+            # GPS状态节点的参数验证 (忽略大小写)
             {
                 "if": {
                     "properties": {
-                        "type": {"const": "condition"},
+                        "type": {"pattern": "^[Cc][Oo][Nn][Dd][Ii][Tt][Ii][Oo][Nn]$"},
                         "name": {"const": "gps_status"}
                     }
                 },
@@ -315,6 +283,65 @@ def _generate_pytree_schema(allowed_actions: set, allowed_conditions: set) -> di
                         }
                     }
                 }
+            },
+            # 飞行序列节点的参数验证
+            {
+                "if": {
+                    "properties": {
+                        "type": {"pattern": "^[Aa][Cc][Tt][Ii][Oo][Nn]$"},
+                        "name": {"const": "fly_sequence"}
+                    }
+                },
+                "then": {
+                    "properties": {
+                        "params": {
+                            "type": "object",
+                            "properties": {
+                                "waypoints": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "x": {"type": "number"},
+                                            "y": {"type": "number"},
+                                            "z": {"type": "number"}
+                                        },
+                                        "required": ["x", "y", "z"]
+                                    },
+                                    "minItems": 1
+                                },
+                                "coordinate_frame": {"type": "string", "enum": ["global", "local_enu"]},
+                                "speed": {"type": "number"}
+                            },
+                            "required": ["waypoints", "coordinate_frame"],
+                            "additionalProperties": False
+                        }
+                    }
+                }
+            },
+            # 抵近目标节点的参数验证
+            {
+                "if": {
+                    "properties": {
+                        "type": {"pattern": "^[Aa][Cc][Tt][Ii][Oo][Nn]$"},
+                        "name": {"const": "approach_target"}
+                    }
+                },
+                "then": {
+                    "properties": {
+                        "params": {
+                            "type": "object",
+                            "properties": {
+                                "target_class": {"type": "string"},
+                                "description": {"type": "string"},
+                                "stop_distance": {"type": "number"},
+                                "speed": {"type": "number"}
+                            },
+                            "required": ["target_class", "stop_distance"],
+                            "additionalProperties": False
+                        }
+                    }
+                }
             }
         ]
     }
@@ -337,7 +364,9 @@ def _generate_pytree_schema(allowed_actions: set, allowed_conditions: set) -> di
 
 def _generate_simple_mode_schema(allowed_actions: set) -> dict:
     """
-    生成简单模式JSON Schema：{"mode":"simple","action":{...}}
+    生成简单模式JSON Schema：{"root":{"type":"action","name":"...","params":{...}}}
+    简单模式与复杂模式使用相同的格式（root字段），但要求root必须是action类型且没有children。
+    严格按照提示词要求：root节点必须是action类型节点，不能是控制流节点（即不能有children）。
     仅校验动作名称在允许集合内，以及基本结构完整性；参数按对象形状放宽，由上游提示词与运行时再约束。
     """
     schema = {
@@ -345,19 +374,20 @@ def _generate_simple_mode_schema(allowed_actions: set) -> dict:
         "title": "SimpleMode",
         "type": "object",
         "properties": {
-            "mode": {"type": "string", "const": "simple"},
-            "action": {
+            "root": {
                 "type": "object",
                 "properties": {
-                    "name": {"type": "string", "enum": sorted(list(allowed_actions))},
-                    "params": {"type": "object"}
+                    "type": {"type": "string", "const": "action"},  # 必须是action类型，不能是控制流节点（Sequence/Selector/Parallel）
+                    "name": {"type": "string", "enum": sorted(list(allowed_actions))},  # 动作名称必须在允许列表中
+                    "params": {"type": "object"}  # params是对象，具体参数由提示词和运行时约束
                 },
-                "required": ["name"],
-                "additionalProperties": True
+                "required": ["type", "name"],  # type和name是必需的，params可选
+                "additionalProperties": True  # 允许root节点有其他属性（如额外的元数据）
+                # 注意：children字段的检查在验证后手动进行，因为JSON Schema的not/allOf在检查不存在字段时可能有问题
             }
         },
-        "required": ["mode", "action"],
-        "additionalProperties": False
+        "required": ["root"],  # 顶层必须有root字段
+        "additionalProperties": False  # 顶层只能有root字段，不能有其他字段（如mode等）
     }
     return schema
 
@@ -369,10 +399,7 @@ def _validate_pytree_with_schema(pytree_instance: dict, schema: dict) -> bool:
         jsonschema.validate(instance=pytree_instance, schema=schema)
         logging.info("✅ JSON Schema验证成功")
         
-        # 额外验证安全监控
-        safety_valid = _validate_safety_monitoring(pytree_instance)
-        
-        return True and safety_valid
+        return True
     except jsonschema.ValidationError as e:
         logging.warning("❌ Pytree验证失败")
         logging.warning(f"错误信息: {e.message}")
@@ -500,6 +527,10 @@ def _add_nodes_and_edges(node: dict, dot, parent_id: str | None = None) -> str:
         shape = 'ellipse'
         style = 'filled'
         fillcolor = '#e1d5e7'  # 紫色
+    elif node_type == 'decorator':
+        shape = 'doubleoctagon'
+        style = 'filled'
+        fillcolor = '#f8cecc'  # 浅红
     
     # 特别标记安全相关节点
     if node.get('name') in ['battery_above', 'gps_status', 'SafetyMonitor']:
@@ -512,28 +543,33 @@ def _add_nodes_and_edges(node: dict, dot, parent_id: str | None = None) -> str:
     if parent_id:
         dot.edge(parent_id, current_id)
     
-    # 递归处理子节点
+    # 递归处理子节点 (Sequence, Selector, Parallel 等)
     children = node.get("children", [])
-    if not children:
-        return current_id
     
-    # 记录所有子节点的ID
-    child_ids = []
-    
-    # 正确的递归连接：每个子节点都连接到当前节点
-    for child in children:
-        child_id = _add_nodes_and_edges(child, dot, current_id)
-        child_ids.append(child_id)
-    
-    # 子节点同级排列（横向排布，更直观地表现同层）
-    if len(child_ids) > 1:
-        with dot.subgraph(name=f"rank_{current_id}") as s:
-            s.attr(rank='same')
-            for cid in child_ids:
-                s.node(cid)
-    
-    # 行为树中，所有类型的节点都只是父连子，不需要子节点间的额外连接
-    # Sequence、Selector、Parallel 的执行逻辑由行为树引擎处理，不需要在可视化中体现
+    # 兼容 decorator 类型的 child 字段 (处理为单元素列表以便统一逻辑)
+    if node_type == 'decorator' and 'child' in node:
+        children = [node['child']]
+        
+    if children:
+        # 记录所有子节点的ID
+        child_ids = []
+        
+        # 正确的递归连接：每个子节点都连接到当前节点
+        for child in children:
+            child_id = _add_nodes_and_edges(child, dot, current_id)
+            child_ids.append(child_id)
+        
+        # 子节点同级排列（横向排布，更直观地表现同层）
+        if len(child_ids) > 1:
+            with dot.subgraph(name=f"rank_{current_id}") as s:
+                s.attr(rank='same')
+                for cid in child_ids:
+                    s.node(cid)
+
+    # 递归处理单子节点 (Decorator) - 已合并到 children 处理逻辑中，此处删除旧逻辑
+    # child = node.get("child")
+    # if child:
+    #     _add_nodes_and_edges(child, dot, current_id)
     
     return current_id
 
@@ -585,7 +621,7 @@ class PyTreeGenerator:
         self.complex_llm_client = openai.OpenAI(api_key=self.api_key, base_url=self.complex_base_url)
         
         # --- ChromaDB Client Setup ---
-        vector_store_path = os.path.abspath(os.path.join(self.base_dir, '..', '..', 'tools', 'vector_store'))
+        vector_store_path = os.path.abspath(os.path.join(self.base_dir, '..', '..', 'tools', 'rag','vector_store'))
         self.chroma_client = chromadb.PersistentClient(path=vector_store_path)
         
         # Explicitly use the remote embedding function for queries
@@ -609,6 +645,99 @@ class PyTreeGenerator:
             logging.error(f"提示词文件未找到 -> {file_name}")
             return ""
 
+    def _get_tool_definitions(self) -> list[dict]:
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": "calc_offset_enu",
+                    "description": "根据ENU坐标系基准点、方向和距离计算偏移后的坐标。",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "base": {
+                                "type": "object",
+                                "properties": {
+                                    "x": {"type": "number"},
+                                    "y": {"type": "number"},
+                                    "z": {"type": "number"}
+                                },
+                                "required": ["x", "y", "z"]
+                            },
+                            "direction": {
+                                "type": "string",
+                                "enum": [
+                                    "east", "west", "north", "south",
+                                    "up", "down"
+                                ]
+                            },
+                            "distance": {"type": "number", "minimum": 0}
+                        },
+                        "required": ["base", "direction", "distance"]
+                    }
+                }
+            }
+        ]
+
+    def _normalize_tool_calls(self, tool_calls: list) -> list[dict]:
+        normalized = []
+        for call in tool_calls:
+            if hasattr(call, "function"):
+                normalized.append(
+                    {
+                        "id": getattr(call, "id", None),
+                        "name": call.function.name,
+                        "arguments": call.function.arguments,
+                    }
+                )
+            elif isinstance(call, dict):
+                normalized.append(
+                    {
+                        "id": call.get("id"),
+                        "name": (call.get("function") or {}).get("name"),
+                        "arguments": (call.get("function") or {}).get("arguments"),
+                    }
+                )
+        return normalized
+
+    def _execute_tool_calls(self, tool_calls: list) -> list[dict]:
+        tool_messages = []
+        normalized = self._normalize_tool_calls(tool_calls)
+        for call in normalized:
+            tool_name = call.get("name")
+            tool_args = call.get("arguments")
+            tool_id = call.get("id")
+            if not tool_name:
+                logging.warning("工具调用缺少名称，已忽略。")
+                continue
+            try:
+                args = json.loads(tool_args or "{}")
+            except json.JSONDecodeError:
+                logging.warning(f"工具调用参数解析失败: {tool_args}")
+                continue
+            try:
+                if tool_name == "calc_offset_enu":
+                    result = calc_offset_enu(**args)
+                else:
+                    result = {"error": f"unsupported tool: {tool_name}"}
+                tool_messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tool_id,
+                        "content": json.dumps(result, ensure_ascii=False)
+                    }
+                )
+            except Exception as exc:
+                logging.warning(f"工具调用执行失败({tool_name}): {exc}")
+                tool_messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tool_id,
+                        "content": json.dumps({"error": str(exc)}, ensure_ascii=False)
+                    }
+                )
+        return tool_messages
+
     def _retrieve_context(self, query: str) -> Optional[str]:
         logging.info("--- 开始从向量数据库检索上下文 ---")
         try:
@@ -619,11 +748,64 @@ class PyTreeGenerator:
                 return None
             context_str = "\n\n".join(retrieved_docs)
             logging.info("--- 成功检索到上下文信息 ---")
+            # 打印检索到的上下文内容
+            logging.info(f"📚 检索到的上下文内容:\n{context_str}")
             return context_str
         except Exception as e:
             logging.error(f"从向量数据库检索时发生错误: {e}")
             return None
 
+    def _should_enable_tools(self, user_prompt: str, retrieved_context: Optional[str]) -> bool:
+        if not user_prompt:
+            return False
+
+        direction_patterns = [
+            "东边", "西边", "南边", "北边",
+            "东侧", "西侧", "南侧", "北侧",
+            "往东", "往西", "往南", "往北",
+            "向东", "向西", "向南", "向北",
+        ]
+        has_direction = any(pat in user_prompt for pat in direction_patterns)
+        has_distance = re.search(r"\d+(\.\d+)?\s*(米|m)", user_prompt) is not None
+        if not (has_direction and has_distance):
+            return False
+
+        if not retrieved_context:
+            return False
+
+        place_candidates: list[str] = []
+        for line in retrieved_context.splitlines():
+            if "地点：" in line or "别名：" in line:
+                place_candidates.extend(re.findall(r"'([^']+)'", line))
+        if not place_candidates:
+            return False
+
+        return any(place in user_prompt for place in place_candidates)
+
+    def _save_history(self, prompt: str, result_dict: dict):
+        """保存请求和响应历史记录"""
+        import datetime
+        try:
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            # 确保history目录存在
+            history_dir = os.path.join(self.base_dir, '..', 'history')
+            os.makedirs(history_dir, exist_ok=True)
+            
+            history_file = os.path.join(history_dir, f"{timestamp}_plan.json")
+            
+            record = {
+                "timestamp": datetime.datetime.now().isoformat(),
+                "request": prompt,
+                "response": result_dict
+            }
+            
+            with open(history_file, 'w', encoding='utf-8') as f:
+                json.dump(record, f, ensure_ascii=False, indent=2)
+                
+            logging.info(f"💾 历史记录已保存: {history_file}")
+        except Exception as e:
+            logging.error(f"保存历史记录失败: {e}")
+
     async def generate(self, user_prompt: str) -> Dict[str, Any]:
         """
         Generates a py_tree.json structure based on the user's prompt.
@@ -640,8 +822,11 @@ class PyTreeGenerator:
                     {"role": "user", "content": user_prompt}
                 ],
                 temperature=0.0,
-                response_format={"type": "json_object"},
-                max_tokens=self.classifier_max_tokens
+                response_format={"type": "json_object"},  # 强制JSON输出，禁用思考功能
+                max_tokens=self.classifier_max_tokens,
+                # 禁用 Qwen3 模型的思考功能（通过 extra_body 传递）
+                # 注意：如果 API 服务器不支持此参数，会忽略
+                extra_body={"chat_template_kwargs": {"enable_thinking": False}}
             )
             class_str = classifier_resp.choices[0].message.content
             class_obj = json.loads(class_str)
@@ -670,35 +855,97 @@ class PyTreeGenerator:
             final_user_prompt += augmentation
         else:
             logging.warning("未检索到上下文或检索失败，将使用原始用户提示词。")
+        
+        # 构建完整的 final_prompt（准确反映实际发送给大模型的内容结构）
+        # 注意：RAG检索结果被添加到 user prompt 中，而不是 system prompt
+        # System Prompt: use_prompt（不包含RAG结果）
+        # User Prompt: final_user_prompt（包含原始user_prompt + RAG检索结果）
+        final_prompt = f"=== System Prompt ===\n{use_prompt}\n\n=== User Prompt ===\n{final_user_prompt}"
+        tool_enabled = self._should_enable_tools(user_prompt, retrieved_context)
         for attempt in range(3):
             logging.info(f"--- 第 {attempt + 1}/3 次尝试生成Pytree ---")
             try:
                 # 简单/复杂分流到不同模型与提示词
                 client = self.simple_llm_client if mode == "simple" else self.complex_llm_client
                 model_name = self.simple_model if mode == "simple" else self.complex_model
-                # 根据是否捕获推理链来决定是否强制JSON响应
+                messages = [
+                    {"role": "system", "content": use_prompt},
+                    {"role": "user", "content": final_user_prompt}
+                ]
+                # 始终强制JSON响应并禁用思考功能
                 response_kwargs = {
                     "model": model_name,
-                    "messages": [
-                        {"role": "system", "content": use_prompt},
-                        {"role": "user", "content": final_user_prompt}
-                    ],
+                    "messages": messages,
                     "temperature": 0.1 if mode == "complex" else 0.0,
+                    "response_format": {"type": "json_object"},  # 始终强制JSON输出，禁用思考功能
+                    "extra_body": {"chat_template_kwargs": {"enable_thinking": False}}
                 }
-                if not self.enable_reasoning_capture:
-                    response_kwargs["response_format"] = {"type": "json_object"}
+                if tool_enabled:
+                    response_kwargs["tools"] = self._get_tool_definitions()
+                    response_kwargs["tool_choice"] = "auto"
                 # 基于模式设定最大输出token数（直接在代码中配置）
                 response_kwargs["max_tokens"] = self.simple_max_tokens if mode == "simple" else self.complex_max_tokens
                 response = client.chat.completions.create(**response_kwargs)
+
+                # 工具调用处理：执行工具并回填后，强制模型输出JSON
+                for tool_round in range(3):
+                    try:
+                        first_msg = response.choices[0].message
+                        tool_calls = getattr(first_msg, "tool_calls", None)
+                    except Exception:
+                        first_msg = response.choices[0].get("message") if isinstance(response.choices[0], dict) else None
+                        tool_calls = (first_msg or {}).get("tool_calls")
+
+                    if not tool_calls:
+                        break
+
+                    logging.info("检测到工具调用，执行第 %d 轮工具回填。", tool_round + 1)
+                    tool_messages = self._execute_tool_calls(tool_calls)
+                    if not tool_messages:
+                        break
+
+                    tool_calls_for_messages = []
+                    for call in self._normalize_tool_calls(tool_calls):
+                        if not call.get("id") or not call.get("name"):
+                            continue
+                        tool_calls_for_messages.append(
+                            {
+                                "id": call["id"],
+                                "type": "function",
+                                "function": {
+                                    "name": call["name"],
+                                    "arguments": call.get("arguments", "")
+                                }
+                            }
+                        )
+                    messages = messages + [
+                        {
+                            "role": "assistant",
+                            "content": getattr(first_msg, "content", "") if first_msg else "",
+                            "tool_calls": tool_calls_for_messages
+                        }
+                    ] + tool_messages
+                    followup_kwargs = dict(response_kwargs)
+                    followup_kwargs["messages"] = messages
+                    followup_kwargs.pop("tools", None)
+                    followup_kwargs.pop("tool_choice", None)
+                    response = client.chat.completions.create(**followup_kwargs)
+                    break
                 # 兼容可能存在的 reasoning_content 字段
                 try:
                     msg = response.choices[0].message
                     msg_content = getattr(msg, "content", None)
                     msg_reasoning = getattr(msg, "reasoning_content", None)
+                    remaining_tool_calls = getattr(msg, "tool_calls", None)
                 except Exception:
                     msg = response.choices[0]["message"] if isinstance(response.choices[0], dict) else None
                     msg_content = (msg or {}).get("content") if isinstance(msg, dict) else None
                     msg_reasoning = (msg or {}).get("reasoning_content") if isinstance(msg, dict) else None
+                    remaining_tool_calls = (msg or {}).get("tool_calls") if isinstance(msg, dict) else None
+
+                if (msg_content is None or str(msg_content).strip() == "") and remaining_tool_calls:
+                    logging.warning("模型仍在请求工具调用，未返回JSON内容，重试下一次。")
+                    continue
 
                 combined_text = ""
                 if isinstance(msg_reasoning, str) and msg_reasoning.strip():
@@ -709,7 +956,7 @@ class PyTreeGenerator:
                 pytree_str = combined_text if combined_text else (msg_content or "")
                 raw_full_text_for_logging = pytree_str  # 保存完整原文（含 <think>）以便失败时完整打印
 
-                # 提取 <think> 推理链内容（若存在）
+                # 提取 <think> 推理链内容（若有）
                 reasoning_text = None
                 try:
                     think_match = re.search(r"<think>([\s\S]*?)</think>", pytree_str)
@@ -764,6 +1011,13 @@ class PyTreeGenerator:
                 if mode == "simple":
                     try:
                         jsonschema.validate(instance=pytree_dict, schema=self.simple_schema)
+                        # 手动检查：简单模式的root节点不能有children（或children必须是空数组）
+                        root_node = pytree_dict.get('root', {})
+                        if 'children' in root_node:
+                            children = root_node.get('children', [])
+                            if isinstance(children, list) and len(children) > 0:
+                                logging.warning(f"❌ 简单模式验证失败: root节点不能有children，但发现 {len(children)} 个子节点")
+                                continue
                         logging.info("✅ 简单模式JSON Schema验证成功")
                     except jsonschema.ValidationError as e:
                         logging.warning(f"❌ 简单模式验证失败: {e.message}")
@@ -771,16 +1025,13 @@ class PyTreeGenerator:
                     # 附加元信息并生成简单可视化（单动作）
                     plan_id = str(uuid.uuid4())
                     pytree_dict['plan_id'] = plan_id
-                    # 简单模式可视化：构造一个简化节点图
+                    # 简单模式可视化：使用root节点（已经是action类型）
                     try:
                         vis_filename = "py_tree.png"
                         vis_path = os.path.join(self.vis_dir, vis_filename)
-                        simple_node = {
-                            "type": "action",
-                            "name": pytree_dict.get('action', {}).get('name', 'action'),
-                            "params": pytree_dict.get('action', {}).get('params', {})
-                        }
-                        _visualize_pytree(simple_node, os.path.splitext(vis_path)[0])
+                        # 简单模式的root节点就是action节点，直接使用
+                        root_node = pytree_dict.get('root', {})
+                        _visualize_pytree(root_node, os.path.splitext(vis_path)[0])
                         pytree_dict['visualization_url'] = f"/static/{vis_filename}"
                     except Exception as e:
                         logging.warning(f"简单模式可视化失败: {e}")
@@ -803,48 +1054,15 @@ class PyTreeGenerator:
                             logging.info("未在模型输出中发现 <think> 推理链片段。若需捕获，请设置 ENABLE_REASONING_CAPTURE=true 以放宽JSON强制格式。")
                     except Exception as e:
                         logging.warning(f"保存推理链Markdown失败: {e}")
+                    # 添加 final_prompt 到返回结果
+                    pytree_dict['final_prompt'] = final_prompt
+                    
+                    # 保存历史记录
+                    self._save_history(user_prompt, pytree_dict)
+                    
                     return pytree_dict
 
-                # 复杂模式回退：若模型误返回简单结构，则自动包装为含安全监控的行为树
-                if mode == "complex" and isinstance(pytree_dict, dict) and 'root' not in pytree_dict:
-                    try:
-                        jsonschema.validate(instance=pytree_dict, schema=self.simple_schema)
-                        logging.warning("⚠️ 复杂模式生成了简单结构，触发自动包装为完整行为树的回退逻辑。")
-                        simple_action_obj = pytree_dict.get('action') or {}
-                        action_name = simple_action_obj.get('name')
-                        action_params = simple_action_obj.get('params') if isinstance(simple_action_obj.get('params'), dict) else {}
-
-                        safety_selector = {
-                            "type": "Selector",
-                            "name": "SafetyMonitor",
-                            "params": {"memory": True},
-                            "children": [
-                                {"type": "condition", "name": "battery_above", "params": {"threshold": 0.3}},
-                                {"type": "condition", "name": "gps_status", "params": {"min_satellites": 8}},
-                                {"type": "Sequence", "name": "EmergencyHandler", "children": [
-                                    {"type": "action", "name": "emergency_return", "params": {"reason": "safety_breach"}},
-                                    {"type": "action", "name": "land", "params": {"mode": "home"}}
-                                ]}
-                            ]
-                        }
-
-                        main_children = [{"type": "action", "name": action_name, "params": action_params}]
-                        if action_name != "land":
-                            main_children.append({"type": "action", "name": "land", "params": {"mode": "home"}})
-
-                        root_parallel = {
-                            "type": "Parallel",
-                            "name": "MissionWithSafety",
-                            "params": {"policy": "all_success"},
-                            "children": [
-                                {"type": "Sequence", "name": "MainTask", "children": main_children},
-                                safety_selector
-                            ]
-                        }
-                        pytree_dict = {"root": root_parallel}
-                    except jsonschema.ValidationError:
-                        # 不符合简单结构，按正常复杂验证继续
-                        pass
+                # 验证生成的复杂行为树
                 if _validate_pytree_with_schema(pytree_dict, self.schema):
                     logging.info("✅ 成功生成并验证了Pytree")
                     plan_id = str(uuid.uuid4())
@@ -874,6 +1092,12 @@ class PyTreeGenerator:
                             logging.info("未在模型输出中发现 <think> 推理链片段。若需捕获，请设置 ENABLE_REASONING_CAPTURE=true 以放宽JSON强制格式。")
                     except Exception as e:
                         logging.warning(f"保存推理链Markdown失败: {e}")
+                    # 添加 final_prompt 到返回结果
+                    pytree_dict['final_prompt'] = final_prompt
+                    
+                    # 保存历史记录
+                    self._save_history(user_prompt, pytree_dict)
+                    
                     return pytree_dict
                 else:
                     # 打印未通过验证的Pytree以便排查

backend_service/src/ros2_client.py

@@ -1,67 +0,0 @@
-import rclpy
-from rclpy.action import ActionClient
-from rclpy.node import Node
-import json
-from typing import Dict, Any
-import logging
-
-from drone_interfaces.action import ExecuteMission
-from .websocket_manager import websocket_manager
-
-class MissionActionClient(Node):
-    """
-    Interfaces with the drone's `ExecuteMission` ROS2 Action Server.
-    """
-    def __init__(self):
-        super().__init__('mission_action_client')
-        self._action_client = ActionClient(self, ExecuteMission, 'execute_mission')
-        self.get_logger().info("MissionActionClient initialized.")
-
-    def send_goal(self, py_tree: Dict[str, Any]):
-        """
-        Sends the mission (py_tree) to the action server.
-        """
-        if not self._action_client.server_is_ready():
-            self.get_logger().error("Action server not available, goal not sent.")
-            # Optionally, you could broadcast a status update to the frontend here
-            return
-
-        self.get_logger().info("Received request to send goal to drone.")
-        goal_msg = ExecuteMission.Goal()
-        goal_msg.py_tree_json = json.dumps(py_tree)
-
-        self.get_logger().info(f"Sending goal to action server...")
-        send_goal_future = self._action_client.send_goal_async(
-            goal_msg,
-            feedback_callback=self.feedback_callback
-        )
-
-        send_goal_future.add_done_callback(self.goal_response_callback)
-
-    def goal_response_callback(self, future):
-        goal_handle = future.result()
-        if not goal_handle.accepted:
-            self.get_logger().info('Goal rejected :(')
-            return
-
-        self.get_logger().info('Goal accepted :)')
-
-        self._get_result_future = goal_handle.get_result_async()
-        self._get_result_future.add_done_callback(self.get_result_callback)
-
-    def get_result_callback(self, future):
-        result = future.result().result
-        self.get_logger().info(f'Result: {{success: {result.success}, message: {result.message}}}')
-        # Optionally, you can broadcast the final result via WebSocket here
-
-    def feedback_callback(self, feedback_msg):
-        """
-        This callback is triggered by the action server.
-        It forwards the status to the QGC plugin via the WebSocket manager in a thread-safe manner.
-        """
-        feedback = feedback_msg.feedback
-        feedback_payload = json.dumps({"node_id": feedback.node_id, "status": feedback.status})
-        self.get_logger().info(f"Received feedback: {feedback_payload}")
-        websocket_manager.broadcast(feedback_payload)
-
-# Note: The rclpy.init() and spinning of the node will be handled in main.py

backend_service/src/tools/__init__.py

@@ -0,0 +1 @@
+"""工具模块包。"""

backend_service/src/tools/coordinate_tools.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Dict, Tuple
+
+
+_DIRECTION_DELTAS: Dict[str, Tuple[int, int, int]] = {
+    "east": (1, 0, 0),
+    "west": (-1, 0, 0),
+    "north": (0, -1, 0),
+    "south": (0, 1, 0),
+    "up": (0, 0, 1),
+    "down": (0, 0, -1),
+}
+
+
+def calc_offset_enu(base: Dict[str, float], direction: str, distance: float) -> Dict[str, float]:
+    """在ENU坐标系下按方向偏移固定距离。"""
+    if distance < 0:
+        raise ValueError("distance must be non-negative")
+    if not isinstance(base, dict):
+        raise ValueError("base must be an object with x/y/z")
+
+    direction_key = (direction or "").strip().lower()
+    if direction_key not in _DIRECTION_DELTAS:
+        raise ValueError(f"unsupported direction: {direction}")
+
+    try:
+        x = float(base["x"])
+        y = float(base["y"])
+        z = float(base["z"])
+    except Exception as exc:
+        raise ValueError("base must contain numeric x/y/z") from exc
+
+    dx, dy, dz = _DIRECTION_DELTAS[direction_key]
+    offset_x = x + dx * distance
+    offset_y = y + dy * distance
+    offset_z = z + dz * distance
+
+    return {"x": offset_x, "y": offset_y, "z": offset_z}

backend_service/src/websocket_manager.py

@@ -22,7 +22,8 @@ class ConnectionManager:
     def broadcast(self, message: str):
         """
         Thread-safely broadcasts a message to all active WebSocket connections.
-        This method is designed to be called from a different thread (e.g., a ROS2 callback).
+        This method is designed to be called from a different thread.
+        (Note: ROS2 callback support has been removed as the project is decoupled from ROS2)
         """
         if not self.loop:
             logging.error("Event loop not set in ConnectionManager. Cannot broadcast.")

backend_service/venv/bin/Activate.ps1

@@ -0,0 +1,248 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+$env:VIRTUAL_ENV_PROMPT = $Prompt
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

backend_service/venv/bin/activate

@@ -0,0 +1,76 @@
+# This file must be used with "source bin/activate" *from bash*
+# You cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # Call hash to forget past locations. Without forgetting
+    # past locations the $PATH changes we made may not be respected.
+    # See "man bash" for more details. hash is usually a builtin of your shell
+    hash -r 2> /dev/null
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+# on Windows, a path can contain colons and backslashes and has to be converted:
+case "$(uname)" in
+    CYGWIN*|MSYS*|MINGW*)
+        # transform D:\path\to\venv to /d/path/to/venv on MSYS and MINGW
+        # and to /cygdrive/d/path/to/venv on Cygwin
+        VIRTUAL_ENV=$(cygpath /home/a/DronePlanning/backend_service/venv)
+        export VIRTUAL_ENV
+        ;;
+    *)
+        # use the path as-is
+        export VIRTUAL_ENV=/home/a/DronePlanning/backend_service/venv
+        ;;
+esac
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/"bin":$PATH"
+export PATH
+
+VIRTUAL_ENV_PROMPT=venv
+export VIRTUAL_ENV_PROMPT
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1="("venv") ${PS1:-}"
+    export PS1
+fi
+
+# Call hash to forget past commands. Without forgetting
+# past commands the $PATH changes we made may not be respected
+hash -r 2> /dev/null

backend_service/venv/bin/activate.csh

@@ -0,0 +1,27 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV /home/a/DronePlanning/backend_service/venv
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/"bin":$PATH"
+setenv VIRTUAL_ENV_PROMPT venv
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = "("venv") $prompt:q"
+endif
+
+alias pydoc python -m pydoc
+
+rehash

backend_service/venv/bin/activate.fish

@@ -0,0 +1,69 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/). You cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV /home/a/DronePlanning/backend_service/venv
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/"bin $PATH
+set -gx VIRTUAL_ENV_PROMPT venv
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s(%s)%s " (set_color 4B8BBE) venv (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+end

backend_service/venv/bin/chroma

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from chromadb.cli.cli import app
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(app())

backend_service/venv/bin/coloredlogs

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from coloredlogs.cli import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/distro

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from distro.distro import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/dotenv

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from dotenv.__main__ import cli
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(cli())

backend_service/venv/bin/f2py

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/fastapi

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from fastapi.cli import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/filetype

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from filetype.__main__ import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/hf

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from huggingface_hub.cli.hf import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/httpx

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from httpx import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/humanfriendly

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from humanfriendly.cli import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/isympy

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from isympy import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/jsonschema

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from jsonschema.cli import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/markdown-it

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from markdown_it.cli.parse import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/nltk

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from nltk.cli import cli
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(cli())

backend_service/venv/bin/normalizer

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from charset_normalizer.cli import cli_detect
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(cli_detect())

backend_service/venv/bin/numpy-config

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from numpy._configtool import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/onnxruntime_test

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from onnxruntime.tools.onnxruntime_test import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/openai

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from openai.cli import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/oxmsg

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from oxmsg.cli import oxmsg
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(oxmsg())

backend_service/venv/bin/pip

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/pip3

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/pip3.13

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/pybase64

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from pybase64.__main__ import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/pygmentize

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from pygments.cmdline import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/pyproject-build

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from build.__main__ import entrypoint
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(entrypoint())

backend_service/venv/bin/pyrsa-decrypt

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from rsa.cli import decrypt
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(decrypt())

backend_service/venv/bin/pyrsa-encrypt

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from rsa.cli import encrypt
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(encrypt())

backend_service/venv/bin/pyrsa-keygen

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from rsa.cli import keygen
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(keygen())

backend_service/venv/bin/pyrsa-priv2pub

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from rsa.util import private_to_public
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(private_to_public())

backend_service/venv/bin/pyrsa-sign

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from rsa.cli import sign
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(sign())

backend_service/venv/bin/pyrsa-verify

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from rsa.cli import verify
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(verify())

backend_service/venv/bin/python

@@ -0,0 +1 @@
+python3

backend_service/venv/bin/python3

@@ -0,0 +1 @@
+/home/huangfukk/miniconda3/bin/python3

backend_service/venv/bin/python3.13

@@ -0,0 +1 @@
+python3

backend_service/venv/bin/tiny-agents

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from huggingface_hub.inference._mcp.cli import app
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(app())

backend_service/venv/bin/tqdm

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from tqdm.cli import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/typer

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from typer.cli import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/uvicorn

@@ -0,0 +1,7 @@
+#!/home/huangfukk/DronePlanning/backend_service/venv/bin/python3
+import sys
+from uvicorn.main import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/watchfiles

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from watchfiles.cli import cli
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(cli())

backend_service/venv/bin/websockets

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from websockets.cli import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/bin/wsdump

@@ -0,0 +1,7 @@
+#!/home/a/DronePlanning/backend_service/venv/bin/python3
+import sys
+from websocket._wsdump import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())

backend_service/venv/lib/python3.13/site-packages/OleFileIO_PL.py

@@ -0,0 +1,37 @@
+#!/usr/local/bin/python
+# -*- coding: latin-1 -*-
+"""
+olefile (formerly OleFileIO_PL)
+
+Module to read/write Microsoft OLE2 files (also called Structured Storage or
+Microsoft Compound Document File Format), such as Microsoft Office 97-2003
+documents, Image Composer and FlashPix files, Outlook messages, ...
+This version is compatible with Python 2.6+ and 3.x
+
+Project website: http://www.decalage.info/olefile
+
+olefile is copyright (c) 2005-2015 Philippe Lagadec (http://www.decalage.info)
+
+olefile is based on the OleFileIO module from the PIL library v1.1.6
+See: http://www.pythonware.com/products/pil/index.htm
+
+The Python Imaging Library (PIL) is
+    Copyright (c) 1997-2005 by Secret Labs AB
+    Copyright (c) 1995-2005 by Fredrik Lundh
+
+See source code and LICENSE.txt for information on usage and redistribution.
+"""
+
+# The OleFileIO_PL module is for backward compatibility
+
+try:
+    # first try to import olefile for Python 2.6+/3.x
+    from olefile.olefile import *
+    # import metadata not covered by *:
+    from olefile.olefile import __version__, __author__, __date__
+
+except:
+    # if it fails, fallback to the old version olefile2 for Python 2.x:
+    from olefile.olefile2 import *
+    # import metadata not covered by *:
+    from olefile.olefile2 import __doc__, __version__, __author__, __date__

backend_service/venv/lib/python3.13/site-packages/_yaml/__init__.py

@@ -0,0 +1,33 @@
+# This is a stub package designed to roughly emulate the _yaml
+# extension module, which previously existed as a standalone module
+# and has been moved into the `yaml` package namespace.
+# It does not perfectly mimic its old counterpart, but should get
+# close enough for anyone who's relying on it even when they shouldn't.
+import yaml
+
+# in some circumstances, the yaml module we imoprted may be from a different version, so we need
+# to tread carefully when poking at it here (it may not have the attributes we expect)
+if not getattr(yaml, '__with_libyaml__', False):
+    from sys import version_info
+
+    exc = ModuleNotFoundError if version_info >= (3, 6) else ImportError
+    raise exc("No module named '_yaml'")
+else:
+    from yaml._yaml import *
+    import warnings
+    warnings.warn(
+        'The _yaml extension module is now located at yaml._yaml'
+        ' and its location is subject to change.  To use the'
+        ' LibYAML-based parser and emitter, import from `yaml`:'
+        ' `from yaml import CLoader as Loader, CDumper as Dumper`.',
+        DeprecationWarning
+    )
+    del warnings
+    # Don't `del yaml` here because yaml is actually an existing
+    # namespace member of _yaml.
+
+__name__ = '_yaml'
+# If the module is top-level (i.e. not a part of any specific package)
+# then the attribute should be set to ''.
+# https://docs.python.org/3.8/library/types.html
+__package__ = ''

backend_service/venv/lib/python3.13/site-packages/aiofiles-25.1.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

backend_service/venv/lib/python3.13/site-packages/aiofiles-25.1.0.dist-info/METADATA

@@ -0,0 +1,209 @@
+Metadata-Version: 2.4
+Name: aiofiles
+Version: 25.1.0
+Summary: File support for asyncio.
+Project-URL: Changelog, https://github.com/Tinche/aiofiles#history
+Project-URL: Bug Tracker, https://github.com/Tinche/aiofiles/issues
+Project-URL: Repository, https://github.com/Tinche/aiofiles
+Author-email: Tin Tvrtkovic <tinchester@gmail.com>
+License: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# aiofiles: file support for asyncio
+
+[![PyPI](https://img.shields.io/pypi/v/aiofiles.svg)](https://pypi.python.org/pypi/aiofiles)
+[![Build](https://github.com/Tinche/aiofiles/workflows/CI/badge.svg)](https://github.com/Tinche/aiofiles/actions)
+[![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/Tinche/882f02e3df32136c847ba90d2688f06e/raw/covbadge.json)](https://github.com/Tinche/aiofiles/actions/workflows/main.yml)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/aiofiles.svg)](https://github.com/Tinche/aiofiles)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+**aiofiles** is an Apache2 licensed library, written in Python, for handling local
+disk files in asyncio applications.
+
+Ordinary local file IO is blocking, and cannot easily and portably be made
+asynchronous. This means doing file IO may interfere with asyncio applications,
+which shouldn't block the executing thread. aiofiles helps with this by
+introducing asynchronous versions of files that support delegating operations to
+a separate thread pool.
+
+```python
+async with aiofiles.open('filename', mode='r') as f:
+    contents = await f.read()
+print(contents)
+'My file contents'
+```
+
+Asynchronous iteration is also supported.
+
+```python
+async with aiofiles.open('filename') as f:
+    async for line in f:
+        ...
+```
+
+Asynchronous interface to tempfile module.
+
+```python
+async with aiofiles.tempfile.TemporaryFile('wb') as f:
+    await f.write(b'Hello, World!')
+```
+
+## Features
+
+- a file API very similar to Python's standard, blocking API
+- support for buffered and unbuffered binary files, and buffered text files
+- support for `async`/`await` ([PEP 492](https://peps.python.org/pep-0492/)) constructs
+- async interface to tempfile module
+
+## Installation
+
+To install aiofiles, simply:
+
+```shell
+pip install aiofiles
+```
+
+## Usage
+
+Files are opened using the `aiofiles.open()` coroutine, which in addition to
+mirroring the builtin `open` accepts optional `loop` and `executor`
+arguments. If `loop` is absent, the default loop will be used, as per the
+set asyncio policy. If `executor` is not specified, the default event loop
+executor will be used.
+
+In case of success, an asynchronous file object is returned with an
+API identical to an ordinary file, except the following methods are coroutines
+and delegate to an executor:
+
+- `close`
+- `flush`
+- `isatty`
+- `read`
+- `readall`
+- `read1`
+- `readinto`
+- `readline`
+- `readlines`
+- `seek`
+- `seekable`
+- `tell`
+- `truncate`
+- `writable`
+- `write`
+- `writelines`
+
+In case of failure, one of the usual exceptions will be raised.
+
+`aiofiles.stdin`, `aiofiles.stdout`, `aiofiles.stderr`,
+`aiofiles.stdin_bytes`, `aiofiles.stdout_bytes`, and
+`aiofiles.stderr_bytes` provide async access to `sys.stdin`,
+`sys.stdout`, `sys.stderr`, and their corresponding `.buffer` properties.
+
+The `aiofiles.os` module contains executor-enabled coroutine versions of
+several useful `os` functions that deal with files:
+
+- `stat`
+- `statvfs`
+- `sendfile`
+- `rename`
+- `renames`
+- `replace`
+- `remove`
+- `unlink`
+- `mkdir`
+- `makedirs`
+- `rmdir`
+- `removedirs`
+- `link`
+- `symlink`
+- `readlink`
+- `listdir`
+- `scandir`
+- `access`
+- `getcwd`
+- `path.abspath`
+- `path.exists`
+- `path.isfile`
+- `path.isdir`
+- `path.islink`
+- `path.ismount`
+- `path.getsize`
+- `path.getatime`
+- `path.getctime`
+- `path.samefile`
+- `path.sameopenfile`
+
+### Tempfile
+
+**aiofiles.tempfile** implements the following interfaces:
+
+- TemporaryFile
+- NamedTemporaryFile
+- SpooledTemporaryFile
+- TemporaryDirectory
+
+Results return wrapped with a context manager allowing use with async with and async for.
+
+```python
+async with aiofiles.tempfile.NamedTemporaryFile('wb+') as f:
+    await f.write(b'Line1\n Line2')
+    await f.seek(0)
+    async for line in f:
+        print(line)
+
+async with aiofiles.tempfile.TemporaryDirectory() as d:
+    filename = os.path.join(d, "file.ext")
+```
+
+### Writing tests for aiofiles
+
+Real file IO can be mocked by patching `aiofiles.threadpool.sync_open`
+as desired. The return type also needs to be registered with the
+`aiofiles.threadpool.wrap` dispatcher:
+
+```python
+aiofiles.threadpool.wrap.register(mock.MagicMock)(
+    lambda *args, **kwargs: aiofiles.threadpool.AsyncBufferedIOBase(*args, **kwargs)
+)
+
+async def test_stuff():
+    write_data = 'data'
+    read_file_chunks = [
+        b'file chunks 1',
+        b'file chunks 2',
+        b'file chunks 3',
+        b'',
+    ]
+    file_chunks_iter = iter(read_file_chunks)
+
+    mock_file_stream = mock.MagicMock(
+        read=lambda *args, **kwargs: next(file_chunks_iter)
+    )
+
+    with mock.patch('aiofiles.threadpool.sync_open', return_value=mock_file_stream) as mock_open:
+        async with aiofiles.open('filename', 'w') as f:
+            await f.write(write_data)
+            assert await f.read() == b'file chunks 1'
+
+        mock_file_stream.write.assert_called_once_with(write_data)
+```
+
+### Contributing
+
+Contributions are very welcome. Tests can be run with `tox`, please ensure
+the coverage at least stays the same before you submit a pull request.

backend_service/venv/lib/python3.13/site-packages/aiofiles-25.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+aiofiles-25.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+aiofiles-25.1.0.dist-info/METADATA,sha256=a5a5kHMVigDdsBKlFINLSMPsX3Ms4Fn_zecASBdZqLU,6291
+aiofiles-25.1.0.dist-info/RECORD,,
+aiofiles-25.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aiofiles-25.1.0.dist-info/licenses/LICENSE,sha256=y16Ofl9KOYjhBjwULGDcLfdWBfTEZRXnduOspt-XbhQ,11325
+aiofiles-25.1.0.dist-info/licenses/NOTICE,sha256=EExY0dRQvWR0wJ2LZLwBgnM6YKw9jCU-M0zegpRSD_E,55
+aiofiles/__init__.py,sha256=DYqUwak6MVosBjbAsgyEnFFP-HUZCG5h7X4owoeyYHw,345
+aiofiles/__pycache__/__init__.cpython-313.pyc,,
+aiofiles/__pycache__/base.cpython-313.pyc,,
+aiofiles/__pycache__/os.cpython-313.pyc,,
+aiofiles/__pycache__/ospath.cpython-313.pyc,,
+aiofiles/base.py,sha256=-fvh41PnictTZL3cg98HoN4h6jdebi5d7Mfh81zOBOc,2046
+aiofiles/os.py,sha256=slJ5oUNHVW1xWVuuIWQiYjw30n3L48H7oX4CJvD_1d4,1078
+aiofiles/ospath.py,sha256=c-Kqw4wMCZ-YRt8Jleb697cANwJQM9qux6lq97949C8,678
+aiofiles/tempfile/__init__.py,sha256=twoC7vaQ-JjFzh2Bbd-3-o0hmExH3CYJUmQcuiVwZfg,10207
+aiofiles/tempfile/__pycache__/__init__.cpython-313.pyc,,
+aiofiles/tempfile/__pycache__/temptypes.cpython-313.pyc,,
+aiofiles/tempfile/temptypes.py,sha256=3_hlc6l9r5wmino1fDrt4TpFlX4IKoR5IP_bBYVVuHg,2037
+aiofiles/threadpool/__init__.py,sha256=-65UURmzUHsGTXUz0TARdSzyXIfkCFtbczAQLEPpEcU,3140
+aiofiles/threadpool/__pycache__/__init__.cpython-313.pyc,,
+aiofiles/threadpool/__pycache__/binary.cpython-313.pyc,,
+aiofiles/threadpool/__pycache__/text.cpython-313.pyc,,
+aiofiles/threadpool/__pycache__/utils.cpython-313.pyc,,
+aiofiles/threadpool/binary.py,sha256=hp-km9VCRu0MLz_wAEUfbCz7OL7xtn9iGAawabpnp5U,2315
+aiofiles/threadpool/text.py,sha256=fNmpw2PEkj0BZSldipJXAgZqVGLxALcfOMiuDQ54Eas,1223
+aiofiles/threadpool/utils.py,sha256=VtIJ9KErbcIT9_Yz4V4rZgNEUjBH3cAYxzKQBMpEzik,1850

backend_service/venv/lib/python3.13/site-packages/aiofiles-25.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

backend_service/venv/lib/python3.13/site-packages/aiofiles-25.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

backend_service/venv/lib/python3.13/site-packages/aiofiles-25.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,2 @@
+Asyncio support for files
+Copyright 2016 Tin Tvrtkovic

backend_service/venv/lib/python3.13/site-packages/aiofiles/__init__.py

@@ -0,0 +1,23 @@
+"""Utilities for asyncio-friendly file handling."""
+
+from . import tempfile
+from .threadpool import (
+    open,
+    stderr,
+    stderr_bytes,
+    stdin,
+    stdin_bytes,
+    stdout,
+    stdout_bytes,
+)
+
+__all__ = [
+    "open",
+    "tempfile",
+    "stdin",
+    "stdout",
+    "stderr",
+    "stdin_bytes",
+    "stdout_bytes",
+    "stderr_bytes",
+]

backend_service/venv/lib/python3.13/site-packages/aiofiles/base.py

@@ -0,0 +1,79 @@
+from asyncio import get_running_loop
+from collections.abc import Awaitable
+from contextlib import AbstractAsyncContextManager
+from functools import partial, wraps
+
+
+def wrap(func):
+    @wraps(func)
+    async def run(*args, loop=None, executor=None, **kwargs):
+        if loop is None:
+            loop = get_running_loop()
+        pfunc = partial(func, *args, **kwargs)
+        return await loop.run_in_executor(executor, pfunc)
+
+    return run
+
+
+class AsyncBase:
+    def __init__(self, file, loop, executor):
+        self._file = file
+        self._executor = executor
+        self._ref_loop = loop
+
+    @property
+    def _loop(self):
+        return self._ref_loop or get_running_loop()
+
+    def __aiter__(self):
+        """We are our own iterator."""
+        return self
+
+    def __repr__(self):
+        return super().__repr__() + " wrapping " + repr(self._file)
+
+    async def __anext__(self):
+        """Simulate normal file iteration."""
+
+        if line := await self.readline():
+            return line
+        raise StopAsyncIteration
+
+
+class AsyncIndirectBase(AsyncBase):
+    def __init__(self, name, loop, executor, indirect):
+        self._indirect = indirect
+        self._name = name
+        super().__init__(None, loop, executor)
+
+    @property
+    def _file(self):
+        return self._indirect()
+
+    @_file.setter
+    def _file(self, v):
+        pass  # discard writes
+
+
+class AiofilesContextManager(Awaitable, AbstractAsyncContextManager):
+    """An adjusted async context manager for aiofiles."""
+
+    __slots__ = ("_coro", "_obj")
+
+    def __init__(self, coro):
+        self._coro = coro
+        self._obj = None
+
+    def __await__(self):
+        if self._obj is None:
+            self._obj = yield from self._coro.__await__()
+        return self._obj
+
+    async def __aenter__(self):
+        return await self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await get_running_loop().run_in_executor(
+            None, self._obj._file.__exit__, exc_type, exc_val, exc_tb
+        )
+        self._obj = None

backend_service/venv/lib/python3.13/site-packages/aiofiles/os.py

@@ -0,0 +1,61 @@
+"""Async executor versions of file functions from the os module."""
+
+import os
+
+from . import ospath as path
+from .base import wrap
+
+__all__ = [
+    "path",
+    "stat",
+    "rename",
+    "renames",
+    "replace",
+    "remove",
+    "unlink",
+    "mkdir",
+    "makedirs",
+    "rmdir",
+    "removedirs",
+    "symlink",
+    "readlink",
+    "listdir",
+    "scandir",
+    "access",
+    "wrap",
+    "getcwd",
+]
+
+access = wrap(os.access)
+
+getcwd = wrap(os.getcwd)
+
+listdir = wrap(os.listdir)
+
+makedirs = wrap(os.makedirs)
+mkdir = wrap(os.mkdir)
+
+readlink = wrap(os.readlink)
+remove = wrap(os.remove)
+removedirs = wrap(os.removedirs)
+rename = wrap(os.rename)
+renames = wrap(os.renames)
+replace = wrap(os.replace)
+rmdir = wrap(os.rmdir)
+
+scandir = wrap(os.scandir)
+stat = wrap(os.stat)
+symlink = wrap(os.symlink)
+
+unlink = wrap(os.unlink)
+
+
+if hasattr(os, "link"):
+    __all__ += ["link"]
+    link = wrap(os.link)
+if hasattr(os, "sendfile"):
+    __all__ += ["sendfile"]
+    sendfile = wrap(os.sendfile)
+if hasattr(os, "statvfs"):
+    __all__ += ["statvfs"]
+    statvfs = wrap(os.statvfs)

backend_service/venv/lib/python3.13/site-packages/aiofiles/ospath.py

@@ -0,0 +1,37 @@
+"""Async executor versions of file functions from the os.path module."""
+
+from os import path
+
+from .base import wrap
+
+__all__ = [
+    "abspath",
+    "getatime",
+    "getctime",
+    "getmtime",
+    "getsize",
+    "exists",
+    "isdir",
+    "isfile",
+    "islink",
+    "ismount",
+    "samefile",
+    "sameopenfile",
+]
+
+abspath = wrap(path.abspath)
+
+getatime = wrap(path.getatime)
+getctime = wrap(path.getctime)
+getmtime = wrap(path.getmtime)
+getsize = wrap(path.getsize)
+
+exists = wrap(path.exists)
+
+isdir = wrap(path.isdir)
+isfile = wrap(path.isfile)
+islink = wrap(path.islink)
+ismount = wrap(path.ismount)
+
+samefile = wrap(path.samefile)
+sameopenfile = wrap(path.sameopenfile)

backend_service/venv/lib/python3.13/site-packages/aiofiles/tempfile/__init__.py

@@ -0,0 +1,357 @@
+import asyncio
+import sys
+from functools import partial, singledispatch
+from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOBase
+from tempfile import NamedTemporaryFile as syncNamedTemporaryFile
+from tempfile import SpooledTemporaryFile as syncSpooledTemporaryFile
+from tempfile import TemporaryDirectory as syncTemporaryDirectory
+from tempfile import TemporaryFile as syncTemporaryFile
+from tempfile import _TemporaryFileWrapper as syncTemporaryFileWrapper
+
+from ..base import AiofilesContextManager
+from ..threadpool.binary import AsyncBufferedIOBase, AsyncBufferedReader, AsyncFileIO
+from ..threadpool.text import AsyncTextIOWrapper
+from .temptypes import AsyncSpooledTemporaryFile, AsyncTemporaryDirectory
+
+__all__ = [
+    "NamedTemporaryFile",
+    "TemporaryFile",
+    "SpooledTemporaryFile",
+    "TemporaryDirectory",
+]
+
+
+# ================================================================
+# Public methods for async open and return of temp file/directory
+# objects with async interface
+# ================================================================
+if sys.version_info >= (3, 12):
+
+    def NamedTemporaryFile(
+        mode="w+b",
+        buffering=-1,
+        encoding=None,
+        newline=None,
+        suffix=None,
+        prefix=None,
+        dir=None,
+        delete=True,
+        delete_on_close=True,
+        loop=None,
+        executor=None,
+    ):
+        """Async open a named temporary file"""
+        return AiofilesContextManager(
+            _temporary_file(
+                named=True,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+                delete=delete,
+                delete_on_close=delete_on_close,
+                loop=loop,
+                executor=executor,
+            )
+        )
+
+else:
+
+    def NamedTemporaryFile(
+        mode="w+b",
+        buffering=-1,
+        encoding=None,
+        newline=None,
+        suffix=None,
+        prefix=None,
+        dir=None,
+        delete=True,
+        loop=None,
+        executor=None,
+    ):
+        """Async open a named temporary file"""
+        return AiofilesContextManager(
+            _temporary_file(
+                named=True,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+                delete=delete,
+                loop=loop,
+                executor=executor,
+            )
+        )
+
+
+def TemporaryFile(
+    mode="w+b",
+    buffering=-1,
+    encoding=None,
+    newline=None,
+    suffix=None,
+    prefix=None,
+    dir=None,
+    loop=None,
+    executor=None,
+):
+    """Async open an unnamed temporary file"""
+    return AiofilesContextManager(
+        _temporary_file(
+            named=False,
+            mode=mode,
+            buffering=buffering,
+            encoding=encoding,
+            newline=newline,
+            suffix=suffix,
+            prefix=prefix,
+            dir=dir,
+            loop=loop,
+            executor=executor,
+        )
+    )
+
+
+def SpooledTemporaryFile(
+    max_size=0,
+    mode="w+b",
+    buffering=-1,
+    encoding=None,
+    newline=None,
+    suffix=None,
+    prefix=None,
+    dir=None,
+    loop=None,
+    executor=None,
+):
+    """Async open a spooled temporary file"""
+    return AiofilesContextManager(
+        _spooled_temporary_file(
+            max_size=max_size,
+            mode=mode,
+            buffering=buffering,
+            encoding=encoding,
+            newline=newline,
+            suffix=suffix,
+            prefix=prefix,
+            dir=dir,
+            loop=loop,
+            executor=executor,
+        )
+    )
+
+
+def TemporaryDirectory(suffix=None, prefix=None, dir=None, loop=None, executor=None):
+    """Async open a temporary directory"""
+    return AiofilesContextManagerTempDir(
+        _temporary_directory(
+            suffix=suffix, prefix=prefix, dir=dir, loop=loop, executor=executor
+        )
+    )
+
+
+# =========================================================
+# Internal coroutines to open new temp files/directories
+# =========================================================
+if sys.version_info >= (3, 12):
+
+    async def _temporary_file(
+        named=True,
+        mode="w+b",
+        buffering=-1,
+        encoding=None,
+        newline=None,
+        suffix=None,
+        prefix=None,
+        dir=None,
+        delete=True,
+        delete_on_close=True,
+        loop=None,
+        executor=None,
+        max_size=0,
+    ):
+        """Async method to open a temporary file with async interface"""
+        if loop is None:
+            loop = asyncio.get_running_loop()
+
+        if named:
+            cb = partial(
+                syncNamedTemporaryFile,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+                delete=delete,
+                delete_on_close=delete_on_close,
+            )
+        else:
+            cb = partial(
+                syncTemporaryFile,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+            )
+
+        f = await loop.run_in_executor(executor, cb)
+
+        # Wrap based on type of underlying IO object
+        if type(f) is syncTemporaryFileWrapper:
+            # _TemporaryFileWrapper was used (named files)
+            result = wrap(f.file, f, loop=loop, executor=executor)
+            result._closer = f._closer
+            return result
+        # IO object was returned directly without wrapper
+        return wrap(f, f, loop=loop, executor=executor)
+
+else:
+
+    async def _temporary_file(
+        named=True,
+        mode="w+b",
+        buffering=-1,
+        encoding=None,
+        newline=None,
+        suffix=None,
+        prefix=None,
+        dir=None,
+        delete=True,
+        loop=None,
+        executor=None,
+        max_size=0,
+    ):
+        """Async method to open a temporary file with async interface"""
+        if loop is None:
+            loop = asyncio.get_running_loop()
+
+        if named:
+            cb = partial(
+                syncNamedTemporaryFile,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+                delete=delete,
+            )
+        else:
+            cb = partial(
+                syncTemporaryFile,
+                mode=mode,
+                buffering=buffering,
+                encoding=encoding,
+                newline=newline,
+                suffix=suffix,
+                prefix=prefix,
+                dir=dir,
+            )
+
+        f = await loop.run_in_executor(executor, cb)
+
+        # Wrap based on type of underlying IO object
+        if type(f) is syncTemporaryFileWrapper:
+            # _TemporaryFileWrapper was used (named files)
+            result = wrap(f.file, f, loop=loop, executor=executor)
+            # add delete property
+            result.delete = f.delete
+            return result
+        # IO object was returned directly without wrapper
+        return wrap(f, f, loop=loop, executor=executor)
+
+
+async def _spooled_temporary_file(
+    max_size=0,
+    mode="w+b",
+    buffering=-1,
+    encoding=None,
+    newline=None,
+    suffix=None,
+    prefix=None,
+    dir=None,
+    loop=None,
+    executor=None,
+):
+    """Open a spooled temporary file with async interface"""
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    cb = partial(
+        syncSpooledTemporaryFile,
+        max_size=max_size,
+        mode=mode,
+        buffering=buffering,
+        encoding=encoding,
+        newline=newline,
+        suffix=suffix,
+        prefix=prefix,
+        dir=dir,
+    )
+
+    f = await loop.run_in_executor(executor, cb)
+
+    # Single interface provided by SpooledTemporaryFile for all modes
+    return AsyncSpooledTemporaryFile(f, loop=loop, executor=executor)
+
+
+async def _temporary_directory(
+    suffix=None, prefix=None, dir=None, loop=None, executor=None
+):
+    """Async method to open a temporary directory with async interface"""
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    cb = partial(syncTemporaryDirectory, suffix, prefix, dir)
+    f = await loop.run_in_executor(executor, cb)
+
+    return AsyncTemporaryDirectory(f, loop=loop, executor=executor)
+
+
+class AiofilesContextManagerTempDir(AiofilesContextManager):
+    """With returns the directory location, not the object (matching sync lib)"""
+
+    async def __aenter__(self):
+        self._obj = await self._coro
+        return self._obj.name
+
+
+@singledispatch
+def wrap(base_io_obj, file, *, loop=None, executor=None):
+    """Wrap the object with interface based on type of underlying IO"""
+
+    msg = f"Unsupported IO type: {base_io_obj}"
+    raise TypeError(msg)
+
+
+@wrap.register(TextIOBase)
+def _(base_io_obj, file, *, loop=None, executor=None):
+    return AsyncTextIOWrapper(file, loop=loop, executor=executor)
+
+
+@wrap.register(BufferedWriter)
+def _(base_io_obj, file, *, loop=None, executor=None):
+    return AsyncBufferedIOBase(file, loop=loop, executor=executor)
+
+
+@wrap.register(BufferedReader)
+@wrap.register(BufferedRandom)
+def _(base_io_obj, file, *, loop=None, executor=None):
+    return AsyncBufferedReader(file, loop=loop, executor=executor)
+
+
+@wrap.register(FileIO)
+def _(base_io_obj, file, *, loop=None, executor=None):
+    return AsyncFileIO(file, loop=loop, executor=executor)

backend_service/venv/lib/python3.13/site-packages/aiofiles/tempfile/temptypes.py

@@ -0,0 +1,70 @@
+"""Async wrappers for spooled temp files and temp directory objects"""
+
+from functools import partial
+
+from ..base import AsyncBase
+from ..threadpool.utils import (
+    cond_delegate_to_executor,
+    delegate_to_executor,
+    proxy_property_directly,
+)
+
+
+@delegate_to_executor("fileno", "rollover")
+@cond_delegate_to_executor(
+    "close",
+    "flush",
+    "isatty",
+    "read",
+    "readline",
+    "readlines",
+    "seek",
+    "tell",
+    "truncate",
+)
+@proxy_property_directly("closed", "encoding", "mode", "name", "newlines")
+class AsyncSpooledTemporaryFile(AsyncBase):
+    """Async wrapper for SpooledTemporaryFile class"""
+
+    async def _check(self):
+        if self._file._rolled:
+            return
+        max_size = self._file._max_size
+        if max_size and self._file.tell() > max_size:
+            await self.rollover()
+
+    async def write(self, s):
+        """Implementation to anticipate rollover"""
+        if self._file._rolled:
+            cb = partial(self._file.write, s)
+            return await self._loop.run_in_executor(self._executor, cb)
+
+        file = self._file._file  # reference underlying base IO object
+        rv = file.write(s)
+        await self._check()
+        return rv
+
+    async def writelines(self, iterable):
+        """Implementation to anticipate rollover"""
+        if self._file._rolled:
+            cb = partial(self._file.writelines, iterable)
+            return await self._loop.run_in_executor(self._executor, cb)
+
+        file = self._file._file  # reference underlying base IO object
+        rv = file.writelines(iterable)
+        await self._check()
+        return rv
+
+
+@delegate_to_executor("cleanup")
+@proxy_property_directly("name")
+class AsyncTemporaryDirectory:
+    """Async wrapper for TemporaryDirectory class"""
+
+    def __init__(self, file, loop, executor):
+        self._file = file
+        self._loop = loop
+        self._executor = executor
+
+    async def close(self):
+        await self.cleanup()

backend_service/venv/lib/python3.13/site-packages/aiofiles/threadpool/__init__.py

@@ -0,0 +1,141 @@
+"""Handle files using a thread pool executor."""
+
+import asyncio
+import sys
+from functools import partial, singledispatch
+from io import (
+    BufferedIOBase,
+    BufferedRandom,
+    BufferedReader,
+    BufferedWriter,
+    FileIO,
+    TextIOBase,
+)
+
+from ..base import AiofilesContextManager
+from .binary import (
+    AsyncBufferedIOBase,
+    AsyncBufferedReader,
+    AsyncFileIO,
+    AsyncIndirectBufferedIOBase,
+)
+from .text import AsyncTextIndirectIOWrapper, AsyncTextIOWrapper
+
+sync_open = open
+
+__all__ = (
+    "open",
+    "stdin",
+    "stdout",
+    "stderr",
+    "stdin_bytes",
+    "stdout_bytes",
+    "stderr_bytes",
+)
+
+
+def open(
+    file,
+    mode="r",
+    buffering=-1,
+    encoding=None,
+    errors=None,
+    newline=None,
+    closefd=True,
+    opener=None,
+    *,
+    loop=None,
+    executor=None,
+):
+    return AiofilesContextManager(
+        _open(
+            file,
+            mode=mode,
+            buffering=buffering,
+            encoding=encoding,
+            errors=errors,
+            newline=newline,
+            closefd=closefd,
+            opener=opener,
+            loop=loop,
+            executor=executor,
+        )
+    )
+
+
+async def _open(
+    file,
+    mode="r",
+    buffering=-1,
+    encoding=None,
+    errors=None,
+    newline=None,
+    closefd=True,
+    opener=None,
+    *,
+    loop=None,
+    executor=None,
+):
+    """Open an asyncio file."""
+    if loop is None:
+        loop = asyncio.get_running_loop()
+    cb = partial(
+        sync_open,
+        file,
+        mode=mode,
+        buffering=buffering,
+        encoding=encoding,
+        errors=errors,
+        newline=newline,
+        closefd=closefd,
+        opener=opener,
+    )
+    f = await loop.run_in_executor(executor, cb)
+
+    return wrap(f, loop=loop, executor=executor)
+
+
+@singledispatch
+def wrap(file, *, loop=None, executor=None):
+    msg = f"Unsupported io type: {file}."
+    raise TypeError(msg)
+
+
+@wrap.register(TextIOBase)
+def _(file, *, loop=None, executor=None):
+    return AsyncTextIOWrapper(file, loop=loop, executor=executor)
+
+
+@wrap.register(BufferedWriter)
+@wrap.register(BufferedIOBase)
+def _(file, *, loop=None, executor=None):
+    return AsyncBufferedIOBase(file, loop=loop, executor=executor)
+
+
+@wrap.register(BufferedReader)
+@wrap.register(BufferedRandom)
+def _(file, *, loop=None, executor=None):
+    return AsyncBufferedReader(file, loop=loop, executor=executor)
+
+
+@wrap.register(FileIO)
+def _(file, *, loop=None, executor=None):
+    return AsyncFileIO(file, loop=loop, executor=executor)
+
+
+stdin = AsyncTextIndirectIOWrapper("sys.stdin", None, None, indirect=lambda: sys.stdin)
+stdout = AsyncTextIndirectIOWrapper(
+    "sys.stdout", None, None, indirect=lambda: sys.stdout
+)
+stderr = AsyncTextIndirectIOWrapper(
+    "sys.stderr", None, None, indirect=lambda: sys.stderr
+)
+stdin_bytes = AsyncIndirectBufferedIOBase(
+    "sys.stdin.buffer", None, None, indirect=lambda: sys.stdin.buffer
+)
+stdout_bytes = AsyncIndirectBufferedIOBase(
+    "sys.stdout.buffer", None, None, indirect=lambda: sys.stdout.buffer
+)
+stderr_bytes = AsyncIndirectBufferedIOBase(
+    "sys.stderr.buffer", None, None, indirect=lambda: sys.stderr.buffer
+)