Merge branch 'camel-ai:main' into disable-coding-interactive-mode

.container/Dockerfile

@@ -1,32 +1,32 @@
-# 使用ARG定义可配置的构建参数
+# 使用ARG定义可配置的构建参数 | Using ARG to define configurable build parameters
 ARG PYTHON_VERSION=3.10
 ARG PIP_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple
 ARG PLAYWRIGHT_DOWNLOAD_HOST=https://npmmirror.com/mirrors/playwright
 
-# 第一阶段：构建依赖
+# 第一阶段：构建依赖 | Stage 1: Build dependencies
 FROM python:${PYTHON_VERSION}-slim AS builder
 
-# 设置工作目录
+# 设置工作目录 | Set working directory
 WORKDIR /build
 
-# 设置pip镜像源以加速下载
+# 设置pip镜像源以加速下载 | Set pip mirror to accelerate downloads
 ARG PIP_INDEX_URL
 RUN pip config set global.index-url ${PIP_INDEX_URL}
 
-# 安装构建依赖
+# 安装构建依赖 | Install build dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
-# 复制并安装requirements.txt
+# 复制并安装requirements.txt | Copy and install requirements.txt
 COPY requirements.txt .
 RUN pip install --no-cache-dir --prefix=/install -r requirements.txt
 
-# 第二阶段：运行时环境
+# 第二阶段：运行时环境 | Stage 2: Runtime environment
 FROM python:${PYTHON_VERSION}-slim
 
-# 添加构建信息标签
+# 添加构建信息标签 | Add build information labels
 ARG BUILD_DATE
 ARG VERSION
 LABEL org.opencontainers.image.created="${BUILD_DATE}" \
@@ -35,72 +35,72 @@ LABEL org.opencontainers.image.created="${BUILD_DATE}" \
       org.opencontainers.image.description="OWL Project Docker Image" \
       org.opencontainers.image.source="https://github.com/yourusername/owl"
 
-# 设置工作目录
+# 设置工作目录 | Set working directory
 WORKDIR /app
 
-# 设置pip镜像源以加速下载
+# 设置pip镜像源以加速下载 | Set pip mirror to accelerate downloads
 ARG PIP_INDEX_URL
 RUN pip config set global.index-url ${PIP_INDEX_URL}
 
-# 从builder阶段复制已安装的Python包
+# 从builder阶段复制已安装的Python包 | Copy installed Python packages from builder stage
 COPY --from=builder /install /usr/local
 
-# 优化apt安装，减少层数
+# 优化apt安装，减少层数 | Optimize apt installation, reduce layers
 RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
     git \
     ffmpeg \
     libsm6 \
     libxext6 \
-    # 添加xvfb和相关依赖
+    # 添加xvfb和相关依赖 | Add xvfb and related dependencies
     xvfb \
     xauth \
     x11-utils \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
-# 安装 Playwright 依赖（使用国内镜像源）
+# 安装 Playwright 依赖（使用国内镜像源） | Install Playwright dependencies (using Chinese mirror)
 ENV PLAYWRIGHT_BROWSERS_PATH=/root/.cache/ms-playwright
 ARG PLAYWRIGHT_DOWNLOAD_HOST
 ENV PLAYWRIGHT_DOWNLOAD_HOST=${PLAYWRIGHT_DOWNLOAD_HOST}
 RUN pip install --no-cache-dir playwright && \
     playwright install --with-deps chromium
 
-# 创建非root用户
+# 创建非root用户 | Create non-root user
 RUN groupadd -r owl && useradd -r -g owl -m owl
 
-# 复制项目文件
+# 复制项目文件 | Copy project files
 COPY owl/ ./owl/
 COPY licenses/ ./licenses/
 COPY assets/ ./assets/
 COPY README.md .
 COPY README_zh.md .
 
-# 设置环境变量文件
+# 设置环境变量文件 | Set environment variables file
 COPY owl/.env_template ./owl/.env
 
-# 创建启动脚本
+# 创建启动脚本 | Create startup script
 RUN echo '#!/bin/bash\nxvfb-run --auto-servernum --server-args="-screen 0 1280x960x24" python "$@"' > /usr/local/bin/xvfb-python && \
     chmod +x /usr/local/bin/xvfb-python
 
-# 创建欢迎脚本
-RUN echo '#!/bin/bash\necho "欢迎使用OWL项目Docker环境！"\necho ""\necho "可用的脚本:"\nls -1 *.py | grep -v "__" | sed "s/^/- /"\necho ""\necho "运行示例:"\necho "  xvfb-python run.py                     # 运行默认脚本"\necho "  xvfb-python run_deepseek_example.py      # 运行DeepSeek示例"\necho ""\necho "或者使用自定义查询:"\necho "  xvfb-python run.py \"你的问题\""\necho ""' > /usr/local/bin/owl-welcome && \
+# 创建欢迎脚本 | Create welcome script
+RUN echo '#!/bin/bash\necho "欢迎使用OWL项目Docker环境！"\necho "Welcome to OWL Project Docker environment!"\necho ""\necho "可用的脚本 | Available scripts:"\nls -1 *.py | grep -v "__" | sed "s/^/- /"\necho ""\necho "运行示例 | Run examples:"\necho "  xvfb-python run.py                     # 运行默认脚本 | Run default script"\necho "  xvfb-python run_deepseek_example.py      # 运行DeepSeek示例 | Run DeepSeek example"\necho ""\necho "或者使用自定义查询 | Or use custom query:"\necho "  xvfb-python run.py \"你的问题 | Your question\""\necho ""' > /usr/local/bin/owl-welcome && \
     chmod +x /usr/local/bin/owl-welcome
 
-# 设置工作目录
+# 设置工作目录 | Set working directory
 WORKDIR /app/owl
 
-# 设置适当的权限
+# 设置适当的权限 | Set appropriate permissions
 RUN chown -R owl:owl /app
 RUN mkdir -p /root/.cache && chown -R owl:owl /root/.cache
 
-# 切换到非root用户
-# 注意：如果需要访问/dev/shm，可能仍需要root用户
+# 切换到非root用户 | Switch to non-root user
+# 注意：如果需要访问/dev/shm，可能仍需要root用户 | Note: If you need to access /dev/shm, you may still need root user
 # USER owl
 
-# 添加健康检查
+# 添加健康检查 | Add health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
     CMD python -c "import sys; sys.exit(0 if __import__('os').path.exists('/app/owl') else 1)"
 
-# 容器启动命令
-CMD ["/bin/bash", "-c", "owl-welcome && /bin/bash"] 
+# 容器启动命令 | Container startup command
+CMD ["/bin/bash", "-c", "owl-welcome && /bin/bash"]

.container/build_docker.bat

@@ -1,14 +1,14 @@
 @echo off
 setlocal enabledelayedexpansion
 
-echo 在Windows上构建Docker镜像...
+echo 在Windows上构建Docker镜像... | Building Docker image on Windows...
 
-REM 设置配置变量
+REM 设置配置变量 | Set configuration variables
 set CACHE_DIR=.docker-cache\pip
 set BUILD_ARGS=--build-arg BUILDKIT_INLINE_CACHE=1
 set COMPOSE_FILE=docker-compose.yml
 
-REM 解析命令行参数
+REM 解析命令行参数 | Parse command line arguments
 set CLEAN_CACHE=0
 set REBUILD=0
 set SERVICE=
@@ -32,80 +32,80 @@ if /i "%~1"=="--service" (
     goto :parse_args
 )
 if /i "%~1"=="--help" (
-    echo 用法: build_docker.bat [选项]
-    echo 选项:
-    echo   --clean     清理缓存目录
-    echo   --rebuild   强制重新构建镜像
-    echo   --service   指定要构建的服务名称
-    echo   --help      显示此帮助信息
+    echo 用法 | Usage: build_docker.bat [选项 | options]
+    echo 选项 | Options:
+    echo   --clean     清理缓存目录 | Clean cache directory
+    echo   --rebuild   强制重新构建镜像 | Force rebuild image
+    echo   --service   指定要构建的服务名称 | Specify service name to build
+    echo   --help      显示此帮助信息 | Show this help message
     exit /b 0
 )
 shift
 goto :parse_args
 :end_parse_args
 
-REM 检查Docker是否安装
+REM 检查Docker是否安装 | Check if Docker is installed
 where docker >nul 2>nul
 if %ERRORLEVEL% NEQ 0 (
-    echo 错误: Docker未安装
-    echo 请先安装Docker Desktop: https://docs.docker.com/desktop/install/windows-install/
+    echo 错误 | Error: Docker未安装 | Docker not installed
+    echo 请先安装Docker Desktop | Please install Docker Desktop first: https://docs.docker.com/desktop/install/windows-install/
     pause
     exit /b 1
 )
 
-REM 检查Docker是否运行
+REM 检查Docker是否运行 | Check if Docker is running
 docker info >nul 2>nul
 if %ERRORLEVEL% NEQ 0 (
-    echo 错误: Docker未运行
-    echo 请启动Docker Desktop应用程序
+    echo 错误 | Error: Docker未运行 | Docker not running
+    echo 请启动Docker Desktop应用程序 | Please start Docker Desktop application
     pause
     exit /b 1
 )
 
-REM 检查docker-compose.yml文件是否存在
+REM 检查docker-compose.yml文件是否存在 | Check if docker-compose.yml file exists
 if not exist "%COMPOSE_FILE%" (
-    echo 错误: 未找到%COMPOSE_FILE%文件
-    echo 请确保在正确的目录中运行此脚本
+    echo 错误 | Error: 未找到%COMPOSE_FILE%文件 | %COMPOSE_FILE% file not found
+    echo 请确保在正确的目录中运行此脚本 | Please make sure you are running this script in the correct directory
     pause
     exit /b 1
 )
 
-REM 检查Docker Compose命令
+REM 检查Docker Compose命令 | Check Docker Compose command
 where docker-compose >nul 2>nul
 if %ERRORLEVEL% EQU 0 (
     set COMPOSE_CMD=docker-compose
 ) else (
-    echo 尝试使用新的docker compose命令...
+    echo 尝试使用新的docker compose命令... | Trying to use new docker compose command...
     docker compose version >nul 2>nul
     if %ERRORLEVEL% EQU 0 (
         set COMPOSE_CMD=docker compose
     ) else (
-        echo 错误: 未找到Docker Compose命令
-        echo 请确保Docker Desktop已正确安装
+        echo 错误 | Error: 未找到Docker Compose命令 | Docker Compose command not found
+        echo 请确保Docker Desktop已正确安装 | Please make sure Docker Desktop is properly installed
         pause
         exit /b 1
     )
 )
 
-REM 设置Docker BuildKit环境变量
+REM 设置Docker BuildKit环境变量 | Set Docker BuildKit environment variables
 set DOCKER_BUILDKIT=1
 set COMPOSE_DOCKER_CLI_BUILD=1
 
-echo 启用Docker BuildKit加速构建...
+echo 启用Docker BuildKit加速构建... | Enabling Docker BuildKit to accelerate build...
 
-REM 清理缓存（如果指定）
+REM 清理缓存（如果指定） | Clean cache (if specified)
 if %CLEAN_CACHE% EQU 1 (
-    echo 清理缓存目录...
+    echo 清理缓存目录... | Cleaning cache directory...
     if exist "%CACHE_DIR%" rmdir /s /q "%CACHE_DIR%"
 )
 
-REM 创建缓存目录
+REM 创建缓存目录 | Create cache directory
 if not exist "%CACHE_DIR%" (
-    echo 创建缓存目录...
+    echo 创建缓存目录... | Creating cache directory...
     mkdir "%CACHE_DIR%"
 )
 
-REM 添加构建时间标记
+REM 添加构建时间标记 | Add build time tag
 for /f "tokens=2 delims==" %%a in ('wmic OS Get localdatetime /value') do set "dt=%%a"
 set "YEAR=%dt:~0,4%"
 set "MONTH=%dt:~4,2%"
@@ -115,33 +115,33 @@ set "MINUTE=%dt:~10,2%"
 set "BUILD_TIME=%YEAR%%MONTH%%DAY%_%HOUR%%MINUTE%"
 set "BUILD_ARGS=%BUILD_ARGS% --build-arg BUILD_TIME=%BUILD_TIME%"
 
-REM 构建Docker镜像
-echo 开始构建Docker镜像...
+REM 构建Docker镜像 | Build Docker image
+echo 开始构建Docker镜像... | Starting to build Docker image...
 
 if "%SERVICE%"=="" (
     if %REBUILD% EQU 1 (
-        echo 强制重新构建所有服务...
+        echo 强制重新构建所有服务... | Force rebuilding all services...
         %COMPOSE_CMD% build --no-cache %BUILD_ARGS%
     ) else (
         %COMPOSE_CMD% build %BUILD_ARGS%
     )
 ) else (
     if %REBUILD% EQU 1 (
-        echo 强制重新构建服务 %SERVICE%...
+        echo 强制重新构建服务 %SERVICE%... | Force rebuilding service %SERVICE%...
         %COMPOSE_CMD% build --no-cache %BUILD_ARGS% %SERVICE%
     ) else (
-        echo 构建服务 %SERVICE%...
+        echo 构建服务 %SERVICE%... | Building service %SERVICE%...
         %COMPOSE_CMD% build %BUILD_ARGS% %SERVICE%
     )
 )
 
 if %ERRORLEVEL% EQU 0 (
-    echo Docker镜像构建成功！
-    echo 构建时间: %BUILD_TIME%
-    echo 可以使用以下命令启动容器：
+    echo Docker镜像构建成功！ | Docker image build successful!
+    echo 构建时间 | Build time: %BUILD_TIME%
+    echo 可以使用以下命令启动容器： | You can use the following command to start the container:
     echo %COMPOSE_CMD% up -d
 ) else (
-    echo Docker镜像构建失败，请检查错误信息。
+    echo Docker镜像构建失败，请检查错误信息。 | Docker image build failed, please check error messages.
 )
 
-pause 
+pause

.container/build_docker.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-# 设置配置变量
+# 设置配置变量 | Set configuration variables
 CACHE_DIR=".docker-cache/pip"
 BUILD_ARGS="--build-arg BUILDKIT_INLINE_CACHE=1"
 COMPOSE_FILE="docker-compose.yml"
@@ -8,7 +8,7 @@ CLEAN_CACHE=0
 REBUILD=0
 SERVICE=""
 
-# 解析命令行参数
+# 解析命令行参数 | Parse command line arguments
 while [[ $# -gt 0 ]]; do
     case "$1" in
         --clean)
@@ -24,127 +24,127 @@ while [[ $# -gt 0 ]]; do
             shift 2
             ;;
         --help)
-            echo "用法: ./build_docker.sh [选项]"
-            echo "选项:"
-            echo "  --clean     清理缓存目录"
-            echo "  --rebuild   强制重新构建镜像"
-            echo "  --service   指定要构建的服务名称"
-            echo "  --help      显示此帮助信息"
+            echo "用法 | Usage: ./build_docker.sh [选项 | options]"
+            echo "选项 | Options:"
+            echo "  --clean     清理缓存目录 | Clean cache directory"
+            echo "  --rebuild   强制重新构建镜像 | Force rebuild image"
+            echo "  --service   指定要构建的服务名称 | Specify service name to build"
+            echo "  --help      显示此帮助信息 | Show this help message"
             exit 0
             ;;
         *)
-            echo "未知选项: $1"
-            echo "使用 --help 查看帮助"
+            echo "未知选项 | Unknown option: $1"
+            echo "使用 --help 查看帮助 | Use --help to see help"
             exit 1
             ;;
     esac
 done
 
-# 检测操作系统类型
+# 检测操作系统类型 | Detect operating system type
 OS_TYPE=$(uname -s)
-echo "检测到操作系统: $OS_TYPE"
+echo "检测到操作系统 | Detected OS: $OS_TYPE"
 
-# 检查Docker是否安装
+# 检查Docker是否安装 | Check if Docker is installed
 if ! command -v docker &> /dev/null; then
-    echo "错误: Docker未安装"
-    echo "请先安装Docker: https://docs.docker.com/get-docker/"
+    echo "错误 | Error: Docker未安装 | Docker not installed"
+    echo "请先安装Docker | Please install Docker first: https://docs.docker.com/get-docker/"
     exit 1
 fi
 
-# 检查Docker是否运行
+# 检查Docker是否运行 | Check if Docker is running
 if ! docker info &> /dev/null; then
-    echo "错误: Docker未运行"
-    echo "请启动Docker服务"
+    echo "错误 | Error: Docker未运行 | Docker not running"
+    echo "请启动Docker服务 | Please start Docker service"
     exit 1
 fi
 
-# 检查docker-compose.yml文件是否存在
+# 检查docker-compose.yml文件是否存在 | Check if docker-compose.yml file exists
 if [ ! -f "$COMPOSE_FILE" ]; then
-    echo "错误: 未找到$COMPOSE_FILE文件"
-    echo "请确保在正确的目录中运行此脚本"
+    echo "错误 | Error: 未找到$COMPOSE_FILE文件 | $COMPOSE_FILE file not found"
+    echo "请确保在正确的目录中运行此脚本 | Please make sure you are running this script in the correct directory"
     exit 1
 fi
 
-# 设置Docker BuildKit环境变量
+# 设置Docker BuildKit环境变量 | Set Docker BuildKit environment variables
 export DOCKER_BUILDKIT=1
 export COMPOSE_DOCKER_CLI_BUILD=1
 
-echo "启用Docker BuildKit加速构建..."
+echo "启用Docker BuildKit加速构建... | Enabling Docker BuildKit to accelerate build..."
 
-# 清理缓存（如果指定）
+# 清理缓存（如果指定） | Clean cache (if specified)
 if [ $CLEAN_CACHE -eq 1 ]; then
-    echo "清理缓存目录..."
+    echo "清理缓存目录... | Cleaning cache directory..."
     rm -rf "$CACHE_DIR"
 fi
 
-# 创建缓存目录
+# 创建缓存目录 | Create cache directory
 mkdir -p "$CACHE_DIR"
 
-# 添加构建时间标记
+# 添加构建时间标记 | Add build time tag
 BUILD_TIME=$(date +"%Y%m%d_%H%M%S")
 BUILD_ARGS="$BUILD_ARGS --build-arg BUILD_TIME=$BUILD_TIME"
 
-# 获取脚本所在目录
+# 获取脚本所在目录 | Get script directory
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# 获取项目根目录（脚本所在目录的父目录）
+# 获取项目根目录（脚本所在目录的父目录） | Get project root directory (parent directory of script directory)
 PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
 
-echo "脚本目录: $SCRIPT_DIR"
-echo "项目根目录: $PROJECT_ROOT"
+echo "脚本目录 | Script directory: $SCRIPT_DIR"
+echo "项目根目录 | Project root directory: $PROJECT_ROOT"
 
-# 切换到项目根目录
+# 切换到项目根目录 | Change to project root directory
 cd "$PROJECT_ROOT"
 
-# 检查Docker Compose命令
+# 检查Docker Compose命令 | Check Docker Compose command
 if command -v docker-compose &> /dev/null; then
     COMPOSE_CMD="docker-compose"
-    echo "使用 docker-compose 命令"
+    echo "使用 docker-compose 命令 | Using docker-compose command"
 elif docker compose version &> /dev/null; then
     COMPOSE_CMD="docker compose"
-    echo "使用 docker compose 命令"
+    echo "使用 docker compose 命令 | Using docker compose command"
 else
-    echo "错误: 未找到Docker Compose命令"
-    echo "请安装Docker Compose: https://docs.docker.com/compose/install/"
+    echo "错误 | Error: 未找到Docker Compose命令 | Docker Compose command not found"
+    echo "请安装Docker Compose | Please install Docker Compose: https://docs.docker.com/compose/install/"
     exit 1
 fi
 
-# 检测CPU核心数，用于并行构建
+# 检测CPU核心数，用于并行构建 | Detect CPU cores for parallel build
 CPU_CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)
 if [ $CPU_CORES -gt 2 ]; then
     PARALLEL_FLAG="--parallel"
-    echo "检测到${CPU_CORES}个CPU核心，启用并行构建..."
+    echo "检测到${CPU_CORES}个CPU核心，启用并行构建... | Detected ${CPU_CORES} CPU cores, enabling parallel build..."
 else
     PARALLEL_FLAG=""
 fi
 
-# 构建命令基础部分
+# 构建命令基础部分 | Base part of build command
 BUILD_CMD="$COMPOSE_CMD -f \"$SCRIPT_DIR/docker-compose.yml\" build $PARALLEL_FLAG --build-arg BUILDKIT_INLINE_CACHE=1"
 
-# 根据操作系统类型执行不同的命令
+# 根据操作系统类型执行不同的命令 | Execute different commands based on OS type
 if [[ "$OS_TYPE" == "Darwin" ]]; then
     # macOS
-    echo "在macOS上构建Docker镜像..."
+    echo "在macOS上构建Docker镜像... | Building Docker image on macOS..."
     eval $BUILD_CMD
 elif [[ "$OS_TYPE" == "Linux" ]]; then
     # Linux
-    echo "在Linux上构建Docker镜像..."
+    echo "在Linux上构建Docker镜像... | Building Docker image on Linux..."
     eval $BUILD_CMD
 elif [[ "$OS_TYPE" == MINGW* ]] || [[ "$OS_TYPE" == CYGWIN* ]] || [[ "$OS_TYPE" == MSYS* ]]; then
     # Windows
-    echo "在Windows上构建Docker镜像..."
+    echo "在Windows上构建Docker镜像... | Building Docker image on Windows..."
     eval $BUILD_CMD
 else
-    echo "未知操作系统，尝试使用标准命令构建..."
+    echo "未知操作系统，尝试使用标准命令构建... | Unknown OS, trying to build with standard command..."
     eval $BUILD_CMD
 fi
 
-# 检查构建结果
+# 检查构建结果 | Check build result
 if [ $? -eq 0 ]; then
-    echo "Docker镜像构建成功！"
-    echo "构建时间: $BUILD_TIME"
-    echo "可以使用以下命令启动容器："
+    echo "Docker镜像构建成功！ | Docker image build successful!"
+    echo "构建时间 | Build time: $BUILD_TIME"
+    echo "可以使用以下命令启动容器： | You can use the following command to start the container:"
     echo "$COMPOSE_CMD -f \"$SCRIPT_DIR/docker-compose.yml\" up -d"
 else
-    echo "Docker镜像构建失败，请检查错误信息。"
+    echo "Docker镜像构建失败，请检查错误信息。 | Docker image build failed, please check error messages."
     exit 1
-fi 
+fi

.container/check_docker.bat

@@ -1,62 +1,62 @@
 @echo off
-echo 检查Docker环境...
+echo 检查Docker环境... | Checking Docker environment...
 
-REM 检查Docker是否安装
+REM 检查Docker是否安装 | Check if Docker is installed
 where docker >nul 2>nul
 if %ERRORLEVEL% NEQ 0 (
-    echo 错误: Docker未安装
-    echo 在Windows上安装Docker的方法:
-    echo 1. 访问 https://docs.docker.com/desktop/install/windows-install/ 下载Docker Desktop
-    echo 2. 安装并启动Docker Desktop
+    echo 错误 | Error: Docker未安装 | Docker not installed
+    echo 在Windows上安装Docker的方法 | How to install Docker on Windows:
+    echo 1. 访问 | Visit https://docs.docker.com/desktop/install/windows-install/ 下载Docker Desktop | to download Docker Desktop
+    echo 2. 安装并启动Docker Desktop | Install and start Docker Desktop
     pause
     exit /b 1
 )
 
-echo Docker已安装
+echo Docker已安装 | Docker is installed
 
-REM 检查Docker Compose是否安装
+REM 检查Docker Compose是否安装 | Check if Docker Compose is installed
 where docker-compose >nul 2>nul
 if %ERRORLEVEL% NEQ 0 (
-    echo 警告: Docker-Compose未找到，尝试使用新的docker compose命令
+    echo 警告 | Warning: Docker-Compose未找到，尝试使用新的docker compose命令 | Docker-Compose not found, trying to use new docker compose command
     docker compose version >nul 2>nul
     if %ERRORLEVEL% NEQ 0 (
-        echo 错误: Docker Compose未安装
-        echo Docker Desktop for Windows应该已包含Docker Compose
-        echo 请确保Docker Desktop已正确安装
+        echo 错误 | Error: Docker Compose未安装 | Docker Compose not installed
+        echo Docker Desktop for Windows应该已包含Docker Compose | Docker Desktop for Windows should already include Docker Compose
+        echo 请确保Docker Desktop已正确安装 | Please make sure Docker Desktop is properly installed
         pause
         exit /b 1
     ) else (
-        echo 使用新的docker compose命令
+        echo 使用新的docker compose命令 | Using new docker compose command
         set COMPOSE_CMD=docker compose
     )
 ) else (
-    echo Docker-Compose已安装
+    echo Docker-Compose已安装 | Docker-Compose is installed
     set COMPOSE_CMD=docker-compose
 )
 
-REM 检查Docker是否正在运行
+REM 检查Docker是否正在运行 | Check if Docker is running
 docker info >nul 2>nul
 if %ERRORLEVEL% NEQ 0 (
-    echo 错误: Docker未运行
-    echo 请启动Docker Desktop应用程序
+    echo 错误 | Error: Docker未运行 | Docker not running
+    echo 请启动Docker Desktop应用程序 | Please start Docker Desktop application
     pause
     exit /b 1
 )
 
-echo Docker正在运行
+echo Docker正在运行 | Docker is running
 
-REM 检查是否有.env文件
+REM 检查是否有.env文件 | Check if .env file exists
 if not exist "owl\.env" (
-    echo 警告: 未找到owl\.env文件
-    echo 请运行以下命令创建环境变量文件:
+    echo 警告 | Warning: 未找到owl\.env文件 | owl\.env file not found
+    echo 请运行以下命令创建环境变量文件 | Please run the following command to create environment variable file:
     echo copy owl\.env_template owl\.env
-    echo 然后编辑owl\.env文件，填写必要的API密钥
+    echo 然后编辑owl\.env文件，填写必要的API密钥 | Then edit owl\.env file and fill in necessary API keys
 ) else (
-    echo 环境变量文件已存在
+    echo 环境变量文件已存在 | Environment variable file exists
 )
 
-echo 所有检查完成，您的系统已准备好构建和运行OWL项目的Docker容器
-echo 请运行以下命令构建Docker镜像:
+echo 所有检查完成，您的系统已准备好构建和运行OWL项目的Docker容器 | All checks completed, your system is ready to build and run OWL project Docker container
+echo 请运行以下命令构建Docker镜像 | Please run the following command to build Docker image:
 echo %COMPOSE_CMD% build
 
-pause 
+pause

.container/check_docker.sh

@@ -1,92 +1,92 @@
 #!/bin/bash
 
-# 检测操作系统类型
+# 检测操作系统类型 | Detect operating system type
 OS_TYPE=$(uname -s)
-echo "检测到操作系统: $OS_TYPE"
+echo "检测到操作系统 | Detected OS: $OS_TYPE"
 
-# 检查Docker是否安装
+# 检查Docker是否安装 | Check if Docker is installed
 if ! command -v docker &> /dev/null; then
-    echo "错误: Docker未安装"
+    echo "错误 | Error: Docker未安装 | Docker not installed"
     
     if [[ "$OS_TYPE" == "Darwin" ]]; then
-        echo "在macOS上安装Docker的方法:"
-        echo "1. 访问 https://docs.docker.com/desktop/install/mac-install/ 下载Docker Desktop"
-        echo "2. 安装并启动Docker Desktop"
+        echo "在macOS上安装Docker的方法 | How to install Docker on macOS:"
+        echo "1. 访问 | Visit https://docs.docker.com/desktop/install/mac-install/ 下载Docker Desktop | to download Docker Desktop"
+        echo "2. 安装并启动Docker Desktop | Install and start Docker Desktop"
     elif [[ "$OS_TYPE" == "Linux" ]]; then
-        echo "在Linux上安装Docker的方法:"
-        echo "1. 运行以下命令:"
+        echo "在Linux上安装Docker的方法 | How to install Docker on Linux:"
+        echo "1. 运行以下命令 | Run the following commands:"
         echo "   sudo apt-get update"
         echo "   sudo apt-get install docker.io docker-compose"
-        echo "2. 启动Docker服务:"
+        echo "2. 启动Docker服务 | Start Docker service:"
         echo "   sudo systemctl start docker"
         echo "   sudo systemctl enable docker"
     elif [[ "$OS_TYPE" == MINGW* ]] || [[ "$OS_TYPE" == CYGWIN* ]] || [[ "$OS_TYPE" == MSYS* ]]; then
-        echo "在Windows上安装Docker的方法:"
-        echo "1. 访问 https://docs.docker.com/desktop/install/windows-install/ 下载Docker Desktop"
-        echo "2. 安装并启动Docker Desktop"
+        echo "在Windows上安装Docker的方法 | How to install Docker on Windows:"
+        echo "1. 访问 | Visit https://docs.docker.com/desktop/install/windows-install/ 下载Docker Desktop | to download Docker Desktop"
+        echo "2. 安装并启动Docker Desktop | Install and start Docker Desktop"
     fi
     
     exit 1
 fi
 
-echo "Docker已安装"
+echo "Docker已安装 | Docker is installed"
 
-# 检查Docker Compose是否安装
+# 检查Docker Compose是否安装 | Check if Docker Compose is installed
 if ! command -v docker-compose &> /dev/null; then
-    echo "错误: Docker Compose未安装"
+    echo "错误 | Error: Docker Compose未安装 | Docker Compose not installed"
     
     if [[ "$OS_TYPE" == "Darwin" ]]; then
-        echo "Docker Desktop for Mac已包含Docker Compose"
+        echo "Docker Desktop for Mac已包含Docker Compose | Docker Desktop for Mac already includes Docker Compose"
     elif [[ "$OS_TYPE" == "Linux" ]]; then
-        echo "在Linux上安装Docker Compose的方法:"
-        echo "1. 运行以下命令:"
+        echo "在Linux上安装Docker Compose的方法 | How to install Docker Compose on Linux:"
+        echo "1. 运行以下命令 | Run the following command:"
         echo "   sudo apt-get install docker-compose"
     elif [[ "$OS_TYPE" == MINGW* ]] || [[ "$OS_TYPE" == CYGWIN* ]] || [[ "$OS_TYPE" == MSYS* ]]; then
-        echo "Docker Desktop for Windows已包含Docker Compose"
+        echo "Docker Desktop for Windows已包含Docker Compose | Docker Desktop for Windows already includes Docker Compose"
     fi
     
     exit 1
 fi
 
-echo "Docker Compose已安装"
+echo "Docker Compose已安装 | Docker Compose is installed"
 
-# 检查Docker是否正在运行
+# 检查Docker是否正在运行 | Check if Docker is running
 if ! docker info &> /dev/null; then
-    echo "错误: Docker未运行"
+    echo "错误 | Error: Docker未运行 | Docker not running"
     
     if [[ "$OS_TYPE" == "Darwin" ]]; then
-        echo "请启动Docker Desktop应用程序"
+        echo "请启动Docker Desktop应用程序 | Please start Docker Desktop application"
     elif [[ "$OS_TYPE" == "Linux" ]]; then
-        echo "请运行以下命令启动Docker服务:"
+        echo "请运行以下命令启动Docker服务 | Please run the following command to start Docker service:"
         echo "sudo systemctl start docker"
     elif [[ "$OS_TYPE" == MINGW* ]] || [[ "$OS_TYPE" == CYGWIN* ]] || [[ "$OS_TYPE" == MSYS* ]]; then
-        echo "请启动Docker Desktop应用程序"
+        echo "请启动Docker Desktop应用程序 | Please start Docker Desktop application"
     fi
     
     exit 1
 fi
 
-echo "Docker正在运行"
+echo "Docker正在运行 | Docker is running"
 
-# 检查是否有足够的磁盘空间
+# 检查是否有足够的磁盘空间 | Check if there is enough disk space
 FREE_SPACE=$(df -h . | awk 'NR==2 {print $4}')
-echo "可用磁盘空间: $FREE_SPACE"
+echo "可用磁盘空间 | Available disk space: $FREE_SPACE"
 
-# 检查是否有.env文件
+# 检查是否有.env文件 | Check if .env file exists
 if [ ! -f "owl/.env" ]; then
-    echo "警告: 未找到owl/.env文件"
-    echo "请运行以下命令创建环境变量文件:"
+    echo "警告 | Warning: 未找到owl/.env文件 | owl/.env file not found"
+    echo "请运行以下命令创建环境变量文件 | Please run the following command to create environment variable file:"
     echo "cp owl/.env_template owl/.env"
-    echo "然后编辑owl/.env文件，填写必要的API密钥"
+    echo "然后编辑owl/.env文件，填写必要的API密钥 | Then edit owl/.env file and fill in necessary API keys"
 else
-    echo "环境变量文件已存在"
+    echo "环境变量文件已存在 | Environment variable file exists"
 fi
 
-echo "所有检查完成，您的系统已准备好构建和运行OWL项目的Docker容器"
-echo "请运行以下命令构建Docker镜像:"
+echo "所有检查完成，您的系统已准备好构建和运行OWL项目的Docker容器 | All checks completed, your system is ready to build and run OWL project Docker container"
+echo "请运行以下命令构建Docker镜像 | Please run the following command to build Docker image:"
 
 if [[ "$OS_TYPE" == MINGW* ]] || [[ "$OS_TYPE" == CYGWIN* ]] || [[ "$OS_TYPE" == MSYS* ]]; then
     echo "build_docker.bat"
 else
     echo "./build_docker.sh"
-fi 
+fi

.container/docker-compose.yml

@@ -4,49 +4,49 @@ services:
       context: ..
       dockerfile: .container/Dockerfile
       args:
-        # 构建参数
+        # 构建参数 | Build arguments
         BUILDKIT_INLINE_CACHE: 1
-      # 使用BuildKit加速构建
+      # 使用BuildKit加速构建 | Use BuildKit to accelerate build
       cache_from:
         - python:3.10-slim
     volumes:
-      # 挂载.env文件，方便配置API密钥
+      # 挂载.env文件，方便配置API密钥 | Mount .env file for easy API key configuration
       - ./owl/.env:/app/owl/.env
-      # 可选：挂载数据目录
+      # 可选：挂载数据目录 | Optional: Mount data directory
       - ./data:/app/data
-      # 挂载缓存目录，避免重复下载
+      # 挂载缓存目录，避免重复下载 | Mount cache directories to avoid repeated downloads
       - playwright-cache:/root/.cache/ms-playwright
       - pip-cache:/root/.pip/cache
     environment:
-      # 可以在这里设置环境变量，覆盖.env文件中的设置
+      # 可以在这里设置环境变量，覆盖.env文件中的设置 | Set environment variables here to override settings in .env file
       - OPENAI_API_KEY=${OPENAI_API_KEY}
-      # 添加显示相关的环境变量
+      # 添加显示相关的环境变量 | Add display-related environment variables
       - DISPLAY=:99
       - PLAYWRIGHT_BROWSERS_PATH=/root/.cache/ms-playwright
-      # 设置Python不生成.pyc文件，减少磁盘IO
+      # 设置Python不生成.pyc文件，减少磁盘IO | Set Python to not generate .pyc files, reduce disk IO
       - PYTHONDONTWRITEBYTECODE=1
-      # 设置Python不缓冲输出，方便查看日志
+      # 设置Python不缓冲输出，方便查看日志 | Set Python to not buffer output for easier log viewing
       - PYTHONUNBUFFERED=1
-      # 设置终端颜色
+      # 设置终端颜色 | Set terminal color
       - TERM=xterm-256color
-      # 启用pip缓存
+      # 启用pip缓存 | Enable pip cache
       - PIP_CACHE_DIR=/root/.pip/cache
     ports:
-      # 如果项目有Web界面，可以映射端口
+      # 如果项目有Web界面，可以映射端口 | If the project has a web interface, map ports
       - "8000:8000"
-    # 使用交互模式运行容器
+    # 使用交互模式运行容器 | Run container in interactive mode
     stdin_open: true
     tty: true
-    # 添加共享内存大小，提高浏览器性能
+    # 添加共享内存大小，提高浏览器性能 | Add shared memory size to improve browser performance
     shm_size: 2gb
-    # 设置资源限制
+    # 设置资源限制 | Set resource limits
     deploy:
       resources:
         limits:
           cpus: '2'
           memory: 4G
 
-# 定义持久化卷，用于缓存
+# 定义持久化卷，用于缓存 | Define persistent volumes for caching
 volumes:
   playwright-cache:
-  pip-cache: 
+  pip-cache:

.container/run_in_docker.bat

@@ -1,71 +1,71 @@
 @echo off
 setlocal enabledelayedexpansion
 
-REM 定义配置变量
+REM 定义配置变量 | Define configuration variables
 set SERVICE_NAME=owl
 set PYTHON_CMD=xvfb-python
 set MAX_WAIT_SECONDS=60
 set CHECK_INTERVAL_SECONDS=2
 
-REM 检查参数
+REM 检查参数 | Check parameters
 if "%~1"=="" (
-    echo 用法: run_in_docker.bat [脚本名称] "你的问题"
-    echo 例如: run_in_docker.bat run.py "什么是人工智能？"
-    echo 或者: run_in_docker.bat run_deepseek_example.py "什么是人工智能？"
-    echo 如果不指定脚本名称，默认使用 run.py
+    echo 用法 | Usage: run_in_docker.bat [脚本名称 | script name] "你的问题 | your question"
+    echo 例如 | Example: run_in_docker.bat run.py "什么是人工智能？ | What is artificial intelligence?"
+    echo 或者 | Or: run_in_docker.bat run_deepseek_example.py "什么是人工智能？ | What is artificial intelligence?"
+    echo 如果不指定脚本名称，默认使用 run.py | If script name is not specified, run.py will be used by default
     exit /b 1
 )
 
-REM 判断第一个参数是否是脚本名称
+REM 判断第一个参数是否是脚本名称 | Determine if the first parameter is a script name
 set SCRIPT_NAME=%~1
 set QUERY=%~2
 
 if "!SCRIPT_NAME:~-3!"==".py" (
-    REM 如果提供了第二个参数，则为查询内容
+    REM 如果提供了第二个参数，则为查询内容 | If a second parameter is provided, it's the query content
     if "!QUERY!"=="" (
-        echo 请提供查询参数，例如: run_in_docker.bat !SCRIPT_NAME! "你的问题"
+        echo 请提供查询参数，例如 | Please provide query parameter, e.g.: run_in_docker.bat !SCRIPT_NAME! "你的问题 | your question"
         exit /b 1
     )
 ) else (
-    REM 如果第一个参数不是脚本名称，则默认使用 run.py
+    REM 如果第一个参数不是脚本名称，则默认使用 run.py | If the first parameter is not a script name, use run.py by default
     set QUERY=!SCRIPT_NAME!
     set SCRIPT_NAME=run.py
 )
 
-REM 检查脚本是否存在
+REM 检查脚本是否存在 | Check if the script exists
 if not exist "owl\!SCRIPT_NAME!" (
-    echo 错误: 脚本 'owl\!SCRIPT_NAME!' 不存在
-    echo 可用的脚本有:
+    echo 错误 | Error: 脚本 | Script 'owl\!SCRIPT_NAME!' 不存在 | does not exist
+    echo 可用的脚本有 | Available scripts:
     dir /b owl\*.py | findstr /v "__"
     exit /b 1
 )
 
-echo 使用脚本: !SCRIPT_NAME!
-echo 查询内容: !QUERY!
+echo 使用脚本 | Using script: !SCRIPT_NAME!
+echo 查询内容 | Query content: !QUERY!
 
-REM 从docker-compose.yml获取服务名称（如果文件存在）
+REM 从docker-compose.yml获取服务名称（如果文件存在） | Get service name from docker-compose.yml (if file exists)
 if exist ".container\docker-compose.yml" (
     for /f "tokens=*" %%a in ('findstr /r "^  [a-zA-Z0-9_-]*:" .container\docker-compose.yml') do (
         set line=%%a
         set service=!line:~2,-1!
         if not "!service!"=="" (
-            REM 使用第一个找到的服务名称
+            REM 使用第一个找到的服务名称 | Use the first service name found
             set SERVICE_NAME=!service!
-            echo 从docker-compose.yml检测到服务名称: !SERVICE_NAME!
+            echo 从docker-compose.yml检测到服务名称 | Detected service name from docker-compose.yml: !SERVICE_NAME!
             goto :found_service
         )
     )
 )
 :found_service
 
-REM 确保Docker容器正在运行
+REM 确保Docker容器正在运行 | Ensure Docker container is running
 docker-compose ps | findstr "!SERVICE_NAME!.*Up" > nul
 if errorlevel 1 (
-    echo 启动Docker容器...
+    echo 启动Docker容器... | Starting Docker container...
     docker-compose up -d
     
-    REM 使用循环检查容器是否就绪
-    echo 等待容器启动...
+    REM 使用循环检查容器是否就绪 | Use loop to check if container is ready
+    echo 等待容器启动... | Waiting for container to start...
     set /a total_wait=0
     
     :wait_loop
@@ -75,42 +75,42 @@ if errorlevel 1 (
     docker-compose ps | findstr "!SERVICE_NAME!.*Up" > nul
     if errorlevel 1 (
         if !total_wait! LSS !MAX_WAIT_SECONDS! (
-            echo 容器尚未就绪，已等待!total_wait!秒，继续等待...
+            echo 容器尚未就绪，已等待!total_wait!秒，继续等待... | Container not ready yet, waited for !total_wait! seconds, continuing to wait...
             goto :wait_loop
         ) else (
-            echo 错误：容器启动超时，已等待!MAX_WAIT_SECONDS!秒
-            echo 请检查Docker容器状态：docker-compose ps
+            echo 错误 | Error：容器启动超时，已等待!MAX_WAIT_SECONDS!秒 | Container startup timeout, waited for !MAX_WAIT_SECONDS! seconds
+            echo 请检查Docker容器状态 | Please check Docker container status：docker-compose ps
             exit /b 1
         )
     ) else (
-        echo 容器已就绪，共等待了!total_wait!秒
+        echo 容���已就绪，共等待了!total_wait!秒 | Container is ready, waited for !total_wait! seconds in total
     )
 )
 
-REM 检查容器中是否存在xvfb-python命令
-echo 检查容器中的命令...
+REM 检查容器中是否存在xvfb-python命令 | Check if xvfb-python command exists in container
+echo 检查容器中的命令... | Checking commands in container...
 docker-compose exec -T !SERVICE_NAME! which !PYTHON_CMD! > nul 2>&1
 if errorlevel 1 (
-    echo 警告：容器中未找到!PYTHON_CMD!命令，尝试使用python替代
+    echo 警告 | Warning：容器中未找到!PYTHON_CMD!命令，尝试使用python替代 | !PYTHON_CMD! command not found in container, trying to use python instead
     set PYTHON_CMD=python
     
-    REM 检查python命令是否存在
+    REM 检查python命令是否存在 | Check if python command exists
     docker-compose exec -T !SERVICE_NAME! which python > nul 2>&1
     if errorlevel 1 (
-        echo 错误：容器中未找到python命令
-        echo 请检查容器配置
+        echo 错误 | Error：容器中未找到python命令 | python command not found in container
+        echo 请检查容器配置 | Please check container configuration
         exit /b 1
     )
 )
 
-REM 在容器中运行指定的脚本，传递查询参数
-echo 在Docker容器中使用!PYTHON_CMD!运行脚本...
+REM 在容器中运行指定的脚本，传递查询参数 | Run the specified script in container, passing query parameter
+echo 在Docker容器中使用!PYTHON_CMD!运行脚本... | Running script in Docker container using !PYTHON_CMD!...
 docker-compose exec -T !SERVICE_NAME! !PYTHON_CMD! !SCRIPT_NAME! "!QUERY!"
 
 if errorlevel 0 (
-    echo 查询完成！
+    echo 查询完成！ | Query completed!
 ) else (
-    echo 查询执行失败，请检查错误信息。
+    echo 查询执行失败，请检查错误信息。 | Query execution failed, please check error messages.
 )
 
-pause 
+pause

.container/run_in_docker.sh

@@ -1,44 +1,44 @@
 #!/bin/bash
 
-# 定义配置变量
+# 定义配置变量 | Define configuration variables
 SERVICE_NAME="owl"
 PYTHON_CMD="xvfb-python"
 MAX_WAIT_SECONDS=60
 CHECK_INTERVAL_SECONDS=2
 
-# 检测操作系统类型
+# 检测操作系统类型 | Detect operating system type
 OS_TYPE=$(uname -s)
-echo "检测到操作系统: $OS_TYPE"
+echo "检测到操作系统 | Detected operating system: $OS_TYPE"
 
-# 检查是否提供了查询参数
+# 检查是否提供了查询参数 | Check if query parameters are provided
 if [ $# -lt 1 ]; then
-    echo "用法: ./run_in_docker.sh [脚本名称] '你的问题'"
-    echo "例如: ./run_in_docker.sh run.py '什么是人工智能？'"
-    echo "或者: ./run_in_docker.sh run_deepseek_example.py '什么是人工智能？'"
-    echo "如果不指定脚本名称，默认使用 run.py"
+    echo "用法 | Usage: ./run_in_docker.sh [脚本名称 | script name] '你的问题 | your question'"
+    echo "例如 | Example: ./run_in_docker.sh run.py '什么是人工智能？ | What is artificial intelligence?'"
+    echo "或者 | Or: ./run_in_docker.sh run_deepseek_example.py '什么是人工智能？ | What is artificial intelligence?'"
+    echo "如果不指定脚本名称，默认使用 run.py | If script name is not specified, run.py will be used by default"
     exit 1
 fi
 
-# 判断第一个参数是否是脚本名称
+# 判断第一个参数是否是脚本名称 | Determine if the first parameter is a script name
 if [[ $1 == *.py ]]; then
     SCRIPT_NAME="$1"
-    # 如果提供了第二个参数，则为查询内容
+    # 如果提供了第二个参数，则为查询内容 | If a second parameter is provided, it's the query content
     if [ $# -ge 2 ]; then
         QUERY="$2"
     else
-        echo "请提供查询参数，例如: ./run_in_docker.sh $SCRIPT_NAME '你的问题'"
+        echo "请提供查询参数，例如 | Please provide query parameter, e.g.: ./run_in_docker.sh $SCRIPT_NAME '你的问题 | your question'"
         exit 1
     fi
 else
-    # 如果第一个参数不是脚本名称，则默认使用 run.py
+    # 如果第一个参数不是脚本名称，则默认使用 run.py | If the first parameter is not a script name, use run.py by default
     SCRIPT_NAME="run.py"
     QUERY="$1"
 fi
 
-# 检查脚本是否存在
+# 检查脚本是否存在 | Check if the script exists
 if [ ! -f "owl/$SCRIPT_NAME" ]; then
-    echo "错误: 脚本 'owl/$SCRIPT_NAME' 不存在"
-    echo "可用的脚本有:"
+    echo "错误 | Error: 脚本 | Script 'owl/$SCRIPT_NAME' 不存在 | does not exist"
+    echo "可用的脚本有 | Available scripts:"
     if [[ "$OS_TYPE" == MINGW* ]] || [[ "$OS_TYPE" == CYGWIN* ]] || [[ "$OS_TYPE" == MSYS* ]]; then
         find owl -name "*.py" | grep -v "__" | sed 's/\\/\//g'
     else
@@ -47,36 +47,36 @@ if [ ! -f "owl/$SCRIPT_NAME" ]; then
     exit 1
 fi
 
-echo "使用脚本: $SCRIPT_NAME"
-echo "查询内容: $QUERY"
+echo "使用脚本 | Using script: $SCRIPT_NAME"
+echo "查询内容 | Query content: $QUERY"
 
-# 从docker-compose.yml获取服务名称（如果文件存在）
+# 从docker-compose.yml获取服务名称（如果文件存在） | Get service name from docker-compose.yml (if file exists)
 if [ -f ".container/docker-compose.yml" ]; then
     DETECTED_SERVICE=$(grep -E "^  [a-zA-Z0-9_-]*:" .container/docker-compose.yml | head -1 | sed 's/^  \(.*\):.*/\1/')
     if [ ! -z "$DETECTED_SERVICE" ]; then
         SERVICE_NAME="$DETECTED_SERVICE"
-        echo "从docker-compose.yml检测到服务名称: $SERVICE_NAME"
+        echo "从docker-compose.yml检测到服务名称 | Detected service name from docker-compose.yml: $SERVICE_NAME"
     fi
 fi
 
-# 检查Docker Compose命令
+# 检查Docker Compose命令 | Check Docker Compose command
 if command -v docker-compose &> /dev/null; then
     COMPOSE_CMD="docker-compose"
 elif docker compose version &> /dev/null; then
     COMPOSE_CMD="docker compose"
 else
-    echo "错误: 未找到Docker Compose命令"
+    echo "错误 | Error: 未找到Docker Compose命令 | Docker Compose command not found"
     exit 1
 fi
 
-# 确保Docker容器正在运行
+# 确保Docker容器正在运行 | Ensure Docker container is running
 CONTAINER_RUNNING=$($COMPOSE_CMD ps | grep -c "$SERVICE_NAME.*Up" || true)
 if [ "$CONTAINER_RUNNING" -eq 0 ]; then
-    echo "启动Docker容器..."
+    echo "启动Docker容器... | Starting Docker container..."
     $COMPOSE_CMD up -d
     
-    # 使用循环检查容器是否就绪
-    echo "等待容器启动..."
+    # 使用循环检查容器是否就绪 | Use loop to check if container is ready
+    echo "等待容器启动... | Waiting for container to start..."
     TOTAL_WAIT=0
     
     while [ $TOTAL_WAIT -lt $MAX_WAIT_SECONDS ]; do
@@ -85,51 +85,51 @@ if [ "$CONTAINER_RUNNING" -eq 0 ]; then
         
         CONTAINER_RUNNING=$($COMPOSE_CMD ps | grep -c "$SERVICE_NAME.*Up" || true)
         if [ "$CONTAINER_RUNNING" -gt 0 ]; then
-            echo "容器已就绪，共等待了 $TOTAL_WAIT 秒"
+            echo "容器已就绪，共等待了 $TOTAL_WAIT 秒 | Container is ready, waited for $TOTAL_WAIT seconds in total"
             break
         else
-            echo "容器尚未就绪，已等待 $TOTAL_WAIT 秒，继续等待..."
+            echo "容器尚未就绪，已等待 $TOTAL_WAIT 秒，继续等待... | Container not ready yet, waited for $TOTAL_WAIT seconds, continuing to wait..."
         fi
     done
     
     if [ "$CONTAINER_RUNNING" -eq 0 ]; then
-        echo "错误：容器启动超时，已等待 $MAX_WAIT_SECONDS 秒"
-        echo "请检查Docker容器状态：$COMPOSE_CMD ps"
+        echo "错误 | Error：容器启动超时，已等待 $MAX_WAIT_SECONDS 秒 | Container startup timeout, waited for $MAX_WAIT_SECONDS seconds"
+        echo "请检查Docker容器状态 | Please check Docker container status：$COMPOSE_CMD ps"
         exit 1
     fi
 fi
 
-# 检查容器中是否存在指定的Python命令
-echo "检查容器中的命令..."
+# 检查容器中是否存在指定的Python命令 | Check if specified Python command exists in container
+echo "检查容器中的命令... | Checking commands in container..."
 if ! $COMPOSE_CMD exec -T $SERVICE_NAME which $PYTHON_CMD &> /dev/null; then
-    echo "警告：容器中未找到 $PYTHON_CMD 命令，尝试使用python替代"
+    echo "警告 | Warning：容器中未找到 $PYTHON_CMD 命令，尝试使用python替代 | $PYTHON_CMD command not found in container, trying to use python instead"
     PYTHON_CMD="python"
     
-    # 检查python命令是否存在
+    # 检查python命令是否存在 | Check if python command exists
     if ! $COMPOSE_CMD exec -T $SERVICE_NAME which python &> /dev/null; then
-        echo "错误：容器中未找到python命令"
-        echo "请检查容器配置"
+        echo "错误 | Error：容器中未找到python命令 | python command not found in container"
+        echo "请检查容器配置 | Please check container configuration"
         exit 1
     fi
 fi
 
-# 在容器中运行指定的脚本，传递查询参数
-echo "在Docker容器中使用 $PYTHON_CMD 运行脚本..."
+# 在容器中运行指定的脚本，传递查询参数 | Run the specified script in container, passing query parameter
+echo "在Docker容器中使用 $PYTHON_CMD 运行脚本... | Running script in Docker container using $PYTHON_CMD..."
 
-# 根据操作系统类型执行不同的命令
+# 根据操作系统类型执行不同的命令 | Execute different commands based on operating system type
 if [[ "$OS_TYPE" == MINGW* ]] || [[ "$OS_TYPE" == CYGWIN* ]] || [[ "$OS_TYPE" == MSYS* ]]; then
-    # Windows可能需要特殊处理引号
+    # Windows可能需要特殊处理引号 | Windows may need special handling for quotes
     winpty $COMPOSE_CMD exec -T $SERVICE_NAME $PYTHON_CMD $SCRIPT_NAME "$QUERY"
     RESULT=$?
 else
-    # macOS 或 Linux
+    # macOS 或 Linux | macOS or Linux
     $COMPOSE_CMD exec -T $SERVICE_NAME $PYTHON_CMD $SCRIPT_NAME "$QUERY"
     RESULT=$?
 fi
 
-# 检查命令执行结果
+# 检查命令执行结果 | Check command execution result
 if [ $RESULT -eq 0 ]; then
-    echo "查询完成！"
+    echo "查询完成！ | Query completed!"
 else
-    echo "查询执行失败，请检查错误信息。"
-fi 
+    echo "查询执行失败，请检查错误信息。 | Query execution failed, please check error messages."
+fi