Upload folder using huggingface_hub

.container/.dockerignore

@@ -0,0 +1,74 @@
+# Git
+.git
+.gitignore
+.github
+
+# Docker
+Dockerfile
+docker-compose.yml
+.dockerignore
+DOCKER_README.md
+run_in_docker.sh
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+.pytest_cache/
+.coverage
+htmlcov/
+
+# 虚拟环境
+venv/
+ENV/
+env/
+.env
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+
+# 临时文件
+temp_*
+*.tmp
+*.log
+*.bak
+
+# 缓存
+.cache/
+.npm/
+.yarn/
+
+# 大型数据文件
+*.csv
+*.sqlite
+*.db
+*.hdf5
+*.h5
+*.parquet
+*.feather
+*.pkl
+*.pickle
+
+# 数据目录
+data/ 

.container/DOCKER_README.md

@@ -0,0 +1,298 @@
+# OWL项目Docker使用指南
+
+本文档提供了如何使用Docker运行OWL项目的详细说明。
+
+## 前提条件
+
+- 安装 [Docker](https://docs.docker.com/get-docker/)
+- 安装 [Docker Compose](https://docs.docker.com/compose/install/) (推荐v2.x版本)
+- 获取必要的API密钥（OpenAI API等）
+
+## 技术说明
+
+本Docker配置使用了以下技术来确保OWL项目在容器中正常运行：
+
+- **Xvfb**：虚拟帧缓冲区，用于在无显示器的环境中模拟X服务器
+- **Playwright**：用于自动化浏览器操作，配置为无头模式
+- **共享内存**：增加了共享内存大小，以提高浏览器性能
+- **BuildKit**：使用Docker BuildKit加速构建过程
+- **缓存优化**：使用持久化卷缓存pip和Playwright依赖
+- **跨平台兼容**：提供了适用于Windows和macOS/Linux的脚本
+
+## Docker Compose版本说明
+
+本项目使用的docker-compose.yml文件兼容Docker Compose v2.x版本。如果您使用的是较旧的Docker Compose v1.x版本，可能需要手动添加版本号：
+
+```yaml
+version: '3'
+
+services:
+  # ...其余配置保持不变
+```
+
+## 快速开始
+
+### 0. 检查环境
+
+首先，运行检查脚本确保您的环境已准备好：
+
+#### 在macOS/Linux上检查
+
+```bash
+# 先给脚本添加执行权限
+chmod +x check_docker.sh
+
+# 运行检查脚本
+./check_docker.sh
+```
+
+#### 在Windows上检查
+
+```cmd
+check_docker.bat
+```
+
+如果检查脚本发现任何问题，请按照提示进行修复。
+
+### 1. 配置环境变量
+
+复制环境变量模板文件并填写必要的API密钥：
+
+```bash
+cp owl/.env_template owl/.env
+```
+
+然后编辑 `owl/.env` 文件，填写必要的API密钥，例如：
+
+```
+OPENAI_API_KEY=your_openai_api_key
+GOOGLE_API_KEY=your_google_api_key
+SEARCH_ENGINE_ID=your_search_engine_id
+```
+
+### 2. 快速构建Docker镜像
+
+#### 在macOS/Linux上构建
+
+使用提供的Shell脚本，可以加速Docker镜像的构建：
+
+```bash
+# 先给脚本添加执行权限
+chmod +x build_docker.sh
+
+# 运行构建脚本
+./build_docker.sh
+```
+
+#### 在Windows上构建
+
+使用提供的批处理文件：
+
+```cmd
+build_docker.bat
+```
+
+或者使用标准方式构建并启动：
+
+```bash
+# 使用BuildKit加速构建
+set DOCKER_BUILDKIT=1
+set COMPOSE_DOCKER_CLI_BUILD=1
+docker-compose build --build-arg BUILDKIT_INLINE_CACHE=1
+
+# 启动容器
+docker-compose up -d
+```
+
+### 3. 交互式使用容器
+
+容器启动后，会自动进入交互式shell环境，并显示欢迎信息和可用脚本列表：
+
+```bash
+# 进入容器（如果没有自动进入）
+docker-compose exec owl bash
+```
+
+在容器内，您可以直接运行任何可用的脚本：
+
+```bash
+# 运行默认脚本
+xvfb-python run.py
+
+# 运行DeepSeek示例
+xvfb-python run_deepseek_example.py
+
+# 运行脚本并传递查询参数
+xvfb-python run.py "什么是人工智能？"
+```
+
+### 4. 使用外部脚本运行查询
+
+#### 在macOS/Linux上运行
+
+```bash
+# 先给脚本添加执行权限
+chmod +x run_in_docker.sh
+
+# 默认使用 run.py 脚本
+./run_in_docker.sh "你的问题"
+
+# 指定使用特定脚本
+./run_in_docker.sh run_deepseek_example.py "你的问题"
+```
+
+#### 在Windows上运行
+
+```cmd
+REM 默认使用 run.py 脚本
+run_in_docker.bat "你的问题"
+
+REM 指定使用特定脚本
+run_in_docker.bat run_deepseek_example.py "你的问题"
+```
+
+**可用脚本**：
+- `run.py` - 默认脚本，使用OpenAI GPT-4o模型
+- `run_deepseek_example.py` - 使用DeepSeek模型
+- `run_gaia_roleplaying.py` - GAIA基准测试脚本
+
+## 目录挂载
+
+Docker Compose配置中已经设置了以下挂载点：
+
+- `./owl/.env:/app/owl/.env`：挂载环境变量文件，方便修改API密钥
+- `./data:/app/data`：挂载数据目录，用于存储和访问数据文件
+- `playwright-cache`：持久化卷，用于缓存Playwright浏览器
+- `pip-cache`：持久化卷，用于缓存pip包
+
+## 环境变量
+
+您可以通过以下两种方式设置环境变量：
+
+1. 修改 `owl/.env` 文件
+2. 在 `docker-compose.yml` 文件的 `environment` 部分添加环境变量
+
+## 构建优化
+
+本Docker配置包含多项构建优化：
+
+1. **使用国内镜像源**：使用清华大学镜像源加速pip包下载
+2. **层优化**：减少Dockerfile中的层数，提高构建效率
+3. **缓存利用**：
+   - 启用pip缓存，避免重复下载依赖包
+   - 使用Docker BuildKit内联缓存
+   - 合理安排Dockerfile指令顺序，最大化利用缓存
+4. **BuildKit**：启用Docker BuildKit加速构建
+5. **持久化缓存**：
+   - 使用Docker卷缓存pip包（`pip-cache`）
+   - 使用Docker卷缓存Playwright浏览器（`playwright-cache`）
+   - 本地缓存目录（`.docker-cache`）
+
+### 缓存清理
+
+如果需要清理缓存，可以使用以下命令：
+
+```bash
+# 清理Docker构建缓存
+docker builder prune
+
+# 清理Docker卷（会删除所有未使用的卷，包括缓存卷）
+docker volume prune
+
+# 清理本��缓存目录
+rm -rf .docker-cache
+```
+
+## 跨平台兼容性
+
+本项目提供了适用于不同操作系统的脚本：
+
+1. **检查脚本**：
+   - `check_docker.sh`（macOS/Linux）：检查Docker环境
+   - `check_docker.bat`（Windows）：检查Docker环境
+
+2. **构建脚本**：
+   - `build_docker.sh`（macOS/Linux）：构建Docker镜像
+   - `build_docker.bat`（Windows）：构建Docker镜像
+
+3. **运行脚本**：
+   - `run_in_docker.sh`（macOS/Linux）：运行Docker容器中的脚本
+   - `run_in_docker.bat`（Windows）：运行Docker容器中的脚本
+
+这些脚本会自动检测操作系统类型，并使用适当的命令。
+
+## 故障排除
+
+### 容器无法启动
+
+检查日志以获取更多信息：
+
+```bash
+docker-compose logs
+```
+
+### API密钥问题
+
+确保您已经在 `owl/.env` 文件中正确设置了所有必要的API密钥。
+
+### Docker Compose警告
+
+如果您看到关于`version`属性过时的警告：
+
+```
+WARN[0000] docker-compose.yml: the attribute `version` is obsolete
+```
+
+这是因为您使用的是Docker Compose v2.x，它不再需要显式指定版本号。我们已经从配置文件中移除了这个属性，所以您不会再看到这个警告。
+
+### 浏览器相关问题
+
+如果遇到浏览器相关的问题，可以尝试以下解决方案：
+
+1. 确保在Docker容器中使用`xvfb-python`命令运行Python脚本
+2. 检查是否正确安装了Xvfb和相关依赖
+3. 增加共享内存大小（在docker-compose.yml中已设置为2GB）
+
+### 构建速度慢
+
+如果构建速度慢，可以尝试以下解决方案：
+
+1. 确保启用了Docker BuildKit（`DOCKER_BUILDKIT=1`）
+2. 确保启用了pip缓存（已在docker-compose.yml中配置）
+3. 使用`--build-arg BUILDKIT_INLINE_CACHE=1`参数构建（已在构建脚本中配置）
+4. 如果是首次构建，下载依赖包可能需要较长时间，后续构建会更快
+
+### Windows特有问题
+
+如果在Windows上遇到问题：
+
+1. 确保使用管理员权限运行命令提示符或PowerShell
+2. 如果遇到路径问题，尝试使用正斜杠（/）而不是反斜杠（\）
+3. 如果遇到Docker Compose命令问题，尝试使用`docker compose`（无连字符）
+
+### 内存不足
+
+如果遇到内存不足的问题，可以在 `docker-compose.yml` 文件中调整资源限制：
+
+```yaml
+services:
+  owl:
+    # 其他配置...
+    deploy:
+      resources:
+        limits:
+          cpus: '4'  # 增加CPU核心数
+          memory: 8G  # 增加内存限制
+```
+
+## 自定义Docker镜像
+
+如果需要自定义Docker镜像，可以修改 `Dockerfile` 文件，然后重新构建：
+
+```bash
+# macOS/Linux
+./build_docker.sh
+
+# Windows
+build_docker.bat
+``` 

.container/DOCKER_README_en.md

@@ -0,0 +1,298 @@
+# OWL Project Docker Usage Guide
+
+This document provides detailed instructions on how to run the OWL project using Docker.
+
+## Prerequisites
+
+• Install [Docker](https://docs.docker.com/get-docker/)
+• Install [Docker Compose](https://docs.docker.com/compose/install/) (recommended v2.x version)
+• Obtain necessary API keys (OpenAI API, etc.)
+
+## Technical Notes
+
+This Docker configuration uses the following technologies to ensure the OWL project runs smoothly in containers:
+
+• **Xvfb**: Virtual framebuffer, used to simulate an X server in a headless environment
+• **Playwright**: Used for browser automation, configured in headless mode
+• **Shared Memory**: Increased shared memory size to improve browser performance
+• **BuildKit**: Uses Docker BuildKit to accelerate the build process
+• **Cache Optimization**: Uses persistent volumes to cache pip and Playwright dependencies
+• **Cross-Platform Compatibility**: Provides scripts for both Windows and macOS/Linux
+
+## Docker Compose Version Notes
+
+The docker-compose.yml file used in this project is compatible with Docker Compose v2.x. If you are using an older Docker Compose v1.x version, you may need to manually add the version number:
+
+```yaml
+version: '3'
+
+services:
+  # ...rest of the configuration remains unchanged
+```
+
+## Quick Start
+
+### 0. Check Environment
+
+First, run the check script to ensure your environment is ready:
+
+#### Check on macOS/Linux
+
+```bash
+# First, add execute permissions to the script
+chmod +x check_docker.sh
+
+# Run the check script
+./check_docker.sh
+```
+
+#### Check on Windows
+
+```cmd
+check_docker.bat
+```
+
+If the check script finds any issues, please follow the prompts to fix them.
+
+### 1. Configure Environment Variables
+
+Copy the environment variable template file and fill in the necessary API keys:
+
+```bash
+cp owl/.env_template owl/.env
+```
+
+Then edit the `owl/.env` file and fill in the necessary API keys, for example:
+
+```
+OPENAI_API_KEY=your_openai_api_key
+GOOGLE_API_KEY=your_google_api_key
+SEARCH_ENGINE_ID=your_search_engine_id
+```
+
+### 2. Quick Build Docker Image
+
+#### Build on macOS/Linux
+
+Use the provided shell script to speed up the Docker image build:
+
+```bash
+# First, add execute permissions to the script
+chmod +x build_docker.sh
+
+# Run the build script
+./build_docker.sh
+```
+
+#### Build on Windows
+
+Use the provided batch file:
+
+```cmd
+build_docker.bat
+```
+
+Or build and start using the standard method:
+
+```bash
+# Use BuildKit to accelerate the build
+set DOCKER_BUILDKIT=1
+set COMPOSE_DOCKER_CLI_BUILD=1
+docker-compose build --build-arg BUILDKIT_INLINE_CACHE=1
+
+# Start the container
+docker-compose up -d
+```
+
+### 3. Interactive Use of the Container
+
+After the container starts, it will automatically enter an interactive shell environment and display a welcome message and a list of available scripts:
+
+```bash
+# Enter the container (if not automatically entered)
+docker-compose exec owl bash
+```
+
+Inside the container, you can directly run any available script:
+
+```bash
+# Run the default script
+xvfb-python run.py
+
+# Run the DeepSeek example
+xvfb-python run_deepseek_example.py
+
+# Run the script and pass query parameters
+xvfb-python run.py "What is artificial intelligence?"
+```
+
+### 4. Run Queries Using External Scripts
+
+#### Run on macOS/Linux
+
+```bash
+# First, add execute permissions to the script
+chmod +x run_in_docker.sh
+
+# Default to using the run.py script
+./run_in_docker.sh "your question"
+
+# Specify a particular script
+./run_in_docker.sh run_deepseek_example.py "your question"
+```
+
+#### Run on Windows
+
+```cmd
+REM Default to using the run.py script
+run_in_docker.bat "your question"
+
+REM Specify a particular script
+run_in_docker.bat run_deepseek_example.py "your question"
+```
+
+**Available Scripts**:
+• `run.py` - Default script, uses OpenAI GPT-4o model
+• `run_deepseek_example.py` - Uses the DeepSeek model
+• `run_gaia_roleplaying.py` - GAIA benchmark script
+
+## Directory Mounts
+
+The Docker Compose configuration has set up the following mount points:
+
+• `./owl/.env:/app/owl/.env`: Mounts the environment variable file for easy modification of API keys
+• `./data:/app/data`: Mounts the data directory for storing and accessing data files
+• `playwright-cache`: Persistent volume for caching Playwright browsers
+• `pip-cache`: Persistent volume for caching pip packages
+
+## Environment Variables
+
+You can set environment variables in two ways:
+
+1. Modify the `owl/.env` file
+2. Add environment variables in the `environment` section of the `docker-compose.yml` file
+
+## Build Optimization
+
+This Docker configuration includes several build optimizations:
+
+1. **Use of Domestic Mirror Sources**: Uses Tsinghua University mirror sources to accelerate pip package downloads
+2. **Layer Optimization**: Reduces the number of layers in the Dockerfile to improve build efficiency
+3. **Cache Utilization**:
+   • Enables pip caching to avoid repeated dependency downloads
+   • Uses Docker BuildKit inline caching
+   • Arranges Dockerfile instructions to maximize cache utilization
+4. **BuildKit**: Enables Docker BuildKit to accelerate builds
+5. **Persistent Caching**:
+   • Uses Docker volumes to cache pip packages (`pip-cache`)
+   • Uses Docker volumes to cache Playwright browsers (`playwright-cache`)
+   • Local cache directory (`.docker-cache`)
+
+### Cache Cleanup
+
+If you need to clean the cache, you can use the following commands:
+
+```bash
+# Clean Docker build cache
+docker builder prune
+
+# Clean Docker volumes (will delete all unused volumes, including cache volumes)
+docker volume prune
+
+# Clean local cache directory
+rm -rf .docker-cache
+```
+
+## Cross-Platform Compatibility
+
+This project provides scripts for different operating systems:
+
+1. **Check Scripts**:
+   • `check_docker.sh` (macOS/Linux): Checks the Docker environment
+   • `check_docker.bat` (Windows): Checks the Docker environment
+
+2. **Build Scripts**:
+   • `build_docker.sh` (macOS/Linux): Builds the Docker image
+   • `build_docker.bat` (Windows): Builds the Docker image
+
+3. **Run Scripts**:
+   • `run_in_docker.sh` (macOS/Linux): Runs scripts in the Docker container
+   • `run_in_docker.bat` (Windows): Runs scripts in the Docker container
+
+These scripts automatically detect the operating system type and use appropriate commands.
+
+## Troubleshooting
+
+### Container Fails to Start
+
+Check the logs for more information:
+
+```bash
+docker-compose logs
+```
+
+### API Key Issues
+
+Ensure that you have correctly set all necessary API keys in the `owl/.env` file.
+
+### Docker Compose Warnings
+
+If you see a warning about the `version` attribute being obsolete:
+
+```
+WARN[0000] docker-compose.yml: the attribute `version` is obsolete
+```
+
+This is because you are using Docker Compose v2.x, which no longer requires an explicit version number. We have removed this attribute from the configuration file, so you should no longer see this warning.
+
+### Browser-Related Issues
+
+If you encounter browser-related issues, try the following solutions:
+
+1. Ensure that you are using the `xvfb-python` command to run Python scripts in the Docker container
+2. Check that Xvfb and related dependencies are correctly installed
+3. Increase the shared memory size (set to 2GB in docker-compose.yml)
+
+### Slow Build Speed
+
+If the build speed is slow, try the following solutions:
+
+1. Ensure that Docker BuildKit is enabled (`DOCKER_BUILDKIT=1`)
+2. Ensure that pip caching is enabled (configured in docker-compose.yml)
+3. Use the `--build-arg BUILDKIT_INLINE_CACHE=1` parameter when building (configured in the build script)
+4. If this is the first build, downloading dependencies may take some time, but subsequent builds will be faster
+
+### Windows-Specific Issues
+
+If you encounter issues on Windows:
+
+1. Ensure that you are running the Command Prompt or PowerShell with administrator privileges
+2. If you encounter path issues, try using forward slashes (/) instead of backslashes (\)
+3. If you encounter Docker Compose command issues, try using `docker compose` (without the hyphen)
+
+### Insufficient Memory
+
+If you encounter insufficient memory issues, you can adjust resource limits in the `docker-compose.yml` file:
+
+```yaml
+services:
+  owl:
+    # Other configurations...
+    deploy:
+      resources:
+        limits:
+          cpus: '4'  # Increase CPU cores
+          memory: 8G  # Increase memory limit
+```
+
+## Custom Docker Image
+
+If you need to customize the Docker image, modify the `Dockerfile` file and then rebuild:
+
+```bash
+# macOS/Linux
+./build_docker.sh
+
+# Windows
+build_docker.bat
+```

.container/Dockerfile

@@ -0,0 +1,106 @@
+# 使用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镜像源以加速下载 | 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 | 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}" \
+      org.opencontainers.image.version="${VERSION}" \
+      org.opencontainers.image.title="OWL Project" \
+      org.opencontainers.image.description="OWL Project Docker Image" \
+      org.opencontainers.image.source="https://github.com/yourusername/owl"
+
+# 设置工作目录 | Set working directory
+WORKDIR /app
+
+# 设置pip镜像源以加速下载 | Set pip mirror to accelerate downloads
+ARG PIP_INDEX_URL
+RUN pip config set global.index-url ${PIP_INDEX_URL}
+
+# 从builder阶段复制已安装的Python包 | Copy installed Python packages from builder stage
+COPY --from=builder /install /usr/local
+
+# 优化apt安装，减少层数 | Optimize apt installation, reduce layers
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    git \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    # 添加xvfb和相关依赖 | Add xvfb and related dependencies
+    xvfb \
+    xauth \
+    x11-utils \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# 安装 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用户 | 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
+
+# 创建欢迎脚本 | 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用户 | 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)"
+
+# 容器启动命令 | Container startup command
+CMD ["/bin/bash", "-c", "owl-welcome && /bin/bash"]

.container/build_docker.bat

@@ -0,0 +1,147 @@
+@echo off
+setlocal enabledelayedexpansion
+
+echo 在Windows上构建Docker镜像... | Building Docker image on Windows...
+
+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 解析命令行参数 | Parse command line arguments
+set CLEAN_CACHE=0
+set REBUILD=0
+set SERVICE=
+
+:parse_args
+if "%~1"=="" goto :end_parse_args
+if /i "%~1"=="--clean" (
+    set CLEAN_CACHE=1
+    shift
+    goto :parse_args
+)
+if /i "%~1"=="--rebuild" (
+    set REBUILD=1
+    shift
+    goto :parse_args
+)
+if /i "%~1"=="--service" (
+    set SERVICE=%~2
+    shift
+    shift
+    goto :parse_args
+)
+if /i "%~1"=="--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是否安装 | Check if Docker is installed
+where docker >nul 2>nul
+if %ERRORLEVEL% NEQ 0 (
+    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是否运行 | Check if Docker is running
+docker info >nul 2>nul
+if %ERRORLEVEL% NEQ 0 (
+    echo 错误 | Error: Docker未运行 | Docker not running
+    echo 请启动Docker Desktop应用程序 | Please start Docker Desktop application
+    pause
+    exit /b 1
+)
+
+REM 检查docker-compose.yml文件是否存在 | Check if docker-compose.yml file exists
+if not exist "%COMPOSE_FILE%" (
+    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命令 | Check Docker Compose command
+where docker-compose >nul 2>nul
+if %ERRORLEVEL% EQU 0 (
+    set COMPOSE_CMD=docker-compose
+) else (
+    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 错误 | 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环境变量 | Set Docker BuildKit environment variables
+set DOCKER_BUILDKIT=1
+set COMPOSE_DOCKER_CLI_BUILD=1
+
+echo 启用Docker BuildKit加速构建... | Enabling Docker BuildKit to accelerate build...
+
+REM 清理缓存（如果指定） | Clean cache (if specified)
+if %CLEAN_CACHE% EQU 1 (
+    echo 清理缓存目录... | Cleaning cache directory...
+    if exist "%CACHE_DIR%" rmdir /s /q "%CACHE_DIR%"
+)
+
+REM 创建缓存目录 | Create cache directory
+if not exist "%CACHE_DIR%" (
+    echo 创建缓存目录... | Creating cache directory...
+    mkdir "%CACHE_DIR%"
+)
+
+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%"
+set "DAY=%dt:~6,2%"
+set "HOUR=%dt:~8,2%"
+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镜像 | Build Docker image
+echo 开始构建Docker镜像... | Starting to build Docker image...
+
+if "%SERVICE%"=="" (
+    if %REBUILD% EQU 1 (
+        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%... | Force rebuilding service %SERVICE%...
+        %COMPOSE_CMD% build --no-cache %BUILD_ARGS% %SERVICE%
+    ) else (
+        echo 构建服务 %SERVICE%... | Building service %SERVICE%...
+        %COMPOSE_CMD% build %BUILD_ARGS% %SERVICE%
+    )
+)
+
+if %ERRORLEVEL% EQU 0 (
+    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镜像构建失败，请检查错误信息。 | Docker image build failed, please check error messages.
+)
+
+pause

.container/build_docker.sh

@@ -0,0 +1,150 @@
+#!/bin/bash
+
+# 设置配置变量 | Set configuration variables
+CACHE_DIR=".docker-cache/pip"
+BUILD_ARGS="--build-arg BUILDKIT_INLINE_CACHE=1"
+COMPOSE_FILE="docker-compose.yml"
+CLEAN_CACHE=0
+REBUILD=0
+SERVICE=""
+
+# 解析命令行参数 | Parse command line arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --clean)
+            CLEAN_CACHE=1
+            shift
+            ;;
+        --rebuild)
+            REBUILD=1
+            shift
+            ;;
+        --service)
+            SERVICE="$2"
+            shift 2
+            ;;
+        --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 "未知选项 | Unknown option: $1"
+            echo "使用 --help 查看帮助 | Use --help to see help"
+            exit 1
+            ;;
+    esac
+done
+
+# 检测操作系统类型 | Detect operating system type
+OS_TYPE=$(uname -s)
+echo "检测到操作系统 | Detected OS: $OS_TYPE"
+
+# 检查Docker是否安装 | Check if Docker is installed
+if ! command -v docker &> /dev/null; then
+    echo "错误 | Error: Docker未安装 | Docker not installed"
+    echo "请先安装Docker | Please install Docker first: https://docs.docker.com/get-docker/"
+    exit 1
+fi
+
+# 检查Docker是否运行 | Check if Docker is running
+if ! docker info &> /dev/null; then
+    echo "错误 | Error: Docker未运行 | Docker not running"
+    echo "请启动Docker服务 | Please start Docker service"
+    exit 1
+fi
+
+# 检查docker-compose.yml文件是否存在 | Check if docker-compose.yml file exists
+if [ ! -f "$COMPOSE_FILE" ]; then
+    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环境变量 | Set Docker BuildKit environment variables
+export DOCKER_BUILDKIT=1
+export COMPOSE_DOCKER_CLI_BUILD=1
+
+echo "启用Docker BuildKit加速构建... | Enabling Docker BuildKit to accelerate build..."
+
+# 清理缓存（如果指定） | Clean cache (if specified)
+if [ $CLEAN_CACHE -eq 1 ]; then
+    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 directory: $SCRIPT_DIR"
+echo "项目根目录 | Project root directory: $PROJECT_ROOT"
+
+# 切换到项目根目录 | Change to project root directory
+cd "$PROJECT_ROOT"
+
+# 检查Docker Compose命令 | Check Docker Compose command
+if command -v docker-compose &> /dev/null; then
+    COMPOSE_CMD="docker-compose"
+    echo "使用 docker-compose 命令 | Using docker-compose command"
+elif docker compose version &> /dev/null; then
+    COMPOSE_CMD="docker compose"
+    echo "使用 docker compose 命令 | Using docker compose command"
+else
+    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核心数，用于并行构建 | 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核心，启用并行构建... | 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镜像... | Building Docker image on macOS..."
+    eval $BUILD_CMD
+elif [[ "$OS_TYPE" == "Linux" ]]; then
+    # Linux
+    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镜像... | Building Docker image on Windows..."
+    eval $BUILD_CMD
+else
+    echo "未知操作系统，尝试使用标准命令构建... | Unknown OS, trying to build with standard command..."
+    eval $BUILD_CMD
+fi
+
+# 检查构建结果 | Check build result
+if [ $? -eq 0 ]; then
+    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镜像构建失败，请检查错误信息。 | Docker image build failed, please check error messages."
+    exit 1
+fi

.container/check_docker.bat

@@ -0,0 +1,62 @@
+@echo off
+echo 检查Docker环境... | Checking Docker environment...
+
+REM 检查Docker是否安装 | Check if Docker is installed
+where docker >nul 2>nul
+if %ERRORLEVEL% NEQ 0 (
+    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已安装 | Docker is installed
+
+REM 检查Docker Compose是否安装 | Check if Docker Compose is installed
+where docker-compose >nul 2>nul
+if %ERRORLEVEL% NEQ 0 (
+    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 错误 | 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命令 | Using new docker compose command
+        set COMPOSE_CMD=docker compose
+    )
+) else (
+    echo Docker-Compose已安装 | Docker-Compose is installed
+    set COMPOSE_CMD=docker-compose
+)
+
+REM 检查Docker是否正在运行 | Check if Docker is running
+docker info >nul 2>nul
+if %ERRORLEVEL% NEQ 0 (
+    echo 错误 | Error: Docker未运行 | Docker not running
+    echo 请启动Docker Desktop应用程序 | Please start Docker Desktop application
+    pause
+    exit /b 1
+)
+
+echo Docker正在运行 | Docker is running
+
+REM 检查是否有.env文件 | Check if .env file exists
+if not exist "owl\.env" (
+    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密钥 | Then edit owl\.env file and fill in necessary API keys
+) else (
+    echo 环境变量文件已存在 | Environment variable file exists
+)
+
+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

.container/check_docker.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+
+# 检测操作系统类型 | Detect operating system type
+OS_TYPE=$(uname -s)
+echo "检测到操作系统 | Detected OS: $OS_TYPE"
+
+# 检查Docker是否安装 | Check if Docker is installed
+if ! command -v docker &> /dev/null; then
+    echo "错误 | Error: Docker未安装 | Docker not installed"
+    
+    if [[ "$OS_TYPE" == "Darwin" ]]; then
+        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的方法 | 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服务 | 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的方法 | 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已安装 | Docker is installed"
+
+# 检查Docker Compose是否安装 | Check if Docker Compose is installed
+if ! command -v docker-compose &> /dev/null; then
+    echo "错误 | Error: Docker Compose未安装 | Docker Compose not installed"
+    
+    if [[ "$OS_TYPE" == "Darwin" ]]; then
+        echo "Docker Desktop for Mac已包含Docker Compose | Docker Desktop for Mac already includes Docker Compose"
+    elif [[ "$OS_TYPE" == "Linux" ]]; then
+        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 | Docker Desktop for Windows already includes Docker Compose"
+    fi
+    
+    exit 1
+fi
+
+echo "Docker Compose已安装 | Docker Compose is installed"
+
+# 检查Docker是否正在运行 | Check if Docker is running
+if ! docker info &> /dev/null; then
+    echo "错误 | Error: Docker未运行 | Docker not running"
+    
+    if [[ "$OS_TYPE" == "Darwin" ]]; then
+        echo "请启动Docker Desktop应用程序 | Please start Docker Desktop application"
+    elif [[ "$OS_TYPE" == "Linux" ]]; then
+        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应用程序 | Please start Docker Desktop application"
+    fi
+    
+    exit 1
+fi
+
+echo "Docker正在运行 | Docker is running"
+
+# 检查是否有足够的磁盘空间 | Check if there is enough disk space
+FREE_SPACE=$(df -h . | awk 'NR==2 {print $4}')
+echo "可用磁盘空间 | Available disk space: $FREE_SPACE"
+
+# 检查是否有.env文件 | Check if .env file exists
+if [ ! -f "owl/.env" ]; then
+    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密钥 | Then edit owl/.env file and fill in necessary API keys"
+else
+    echo "环境变量文件已存在 | Environment variable file exists"
+fi
+
+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

.container/docker-compose.yml

@@ -0,0 +1,52 @@
+services:
+  owl:
+    build:
+      context: ..
+      dockerfile: .container/Dockerfile
+      args:
+        # 构建参数 | Build arguments
+        BUILDKIT_INLINE_CACHE: 1
+      # 使用BuildKit加速构建 | Use BuildKit to accelerate build
+      cache_from:
+        - python:3.10-slim
+    volumes:
+      # 挂载.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文件中的设置 | 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 | Set Python to not generate .pyc files, reduce disk IO
+      - PYTHONDONTWRITEBYTECODE=1
+      # 设置Python不缓冲输出，方便查看日志 | Set Python to not buffer output for easier log viewing
+      - PYTHONUNBUFFERED=1
+      # 设置终端颜色 | Set terminal color
+      - TERM=xterm-256color
+      # 启用pip缓存 | Enable pip cache
+      - PIP_CACHE_DIR=/root/.pip/cache
+    ports:
+      # 如果项目有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:

.container/run_in_docker.bat

@@ -0,0 +1,116 @@
+@echo off
+setlocal enabledelayedexpansion
+
+REM 定义配置变量 | Define configuration variables
+set SERVICE_NAME=owl
+set PYTHON_CMD=xvfb-python
+set MAX_WAIT_SECONDS=60
+set CHECK_INTERVAL_SECONDS=2
+
+REM 检查参数 | Check parameters
+if "%~1"=="" (
+    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 判断第一个参数是否是脚本名称 | Determine if the first parameter is a script name
+set SCRIPT_NAME=%~1
+set QUERY=%~2
+
+if "!SCRIPT_NAME:~-3!"==".py" (
+    REM 如果提供了第二个参数，则为查询内容 | If a second parameter is provided, it's the query content
+    if "!QUERY!"=="" (
+        echo 请提供查询参数，例如 | Please provide query parameter, e.g.: run_in_docker.bat !SCRIPT_NAME! "你的问题 | your question"
+        exit /b 1
+    )
+) else (
+    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 检查脚本是否存在 | Check if the script exists
+if not exist "owl\!SCRIPT_NAME!" (
+    echo 错误 | Error: 脚本 | Script 'owl\!SCRIPT_NAME!' 不存在 | does not exist
+    echo 可用的脚本有 | Available scripts:
+    dir /b owl\*.py | findstr /v "__"
+    exit /b 1
+)
+
+echo 使用脚本 | Using script: !SCRIPT_NAME!
+echo 查询内容 | Query content: !QUERY!
+
+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 使用第一个找到的服务名称 | Use the first service name found
+            set SERVICE_NAME=!service!
+            echo 从docker-compose.yml检测到服务名称 | Detected service name from docker-compose.yml: !SERVICE_NAME!
+            goto :found_service
+        )
+    )
+)
+:found_service
+
+REM 确保Docker容器正在运行 | Ensure Docker container is running
+docker-compose ps | findstr "!SERVICE_NAME!.*Up" > nul
+if errorlevel 1 (
+    echo 启动Docker容器... | Starting Docker container...
+    docker-compose up -d
+    
+    REM 使用循环检查容器是否就绪 | Use loop to check if container is ready
+    echo 等待容器启动... | Waiting for container to start...
+    set /a total_wait=0
+    
+    :wait_loop
+    timeout /t !CHECK_INTERVAL_SECONDS! /nobreak > nul
+    set /a total_wait+=!CHECK_INTERVAL_SECONDS!
+    
+    docker-compose ps | findstr "!SERVICE_NAME!.*Up" > nul
+    if errorlevel 1 (
+        if !total_wait! LSS !MAX_WAIT_SECONDS! (
+            echo 容器尚未就绪，已等待!total_wait!秒，继续等待... | Container not ready yet, waited for !total_wait! seconds, continuing to wait...
+            goto :wait_loop
+        ) else (
+            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!秒 | Container is ready, waited for !total_wait! seconds in total
+    )
+)
+
+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 警告 | Warning：容器中未找到!PYTHON_CMD!命令，尝试使用python替代 | !PYTHON_CMD! command not found in container, trying to use python instead
+    set PYTHON_CMD=python
+    
+    REM 检查python命令是否存在 | Check if python command exists
+    docker-compose exec -T !SERVICE_NAME! which python > nul 2>&1
+    if errorlevel 1 (
+        echo 错误 | Error：容器中未找到python命令 | python command not found in container
+        echo 请检查容器配置 | Please check container configuration
+        exit /b 1
+    )
+)
+
+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 查询完成！ | Query completed!
+) else (
+    echo 查询执行失败，请检查错误信息。 | Query execution failed, please check error messages.
+)
+
+pause

.container/run_in_docker.sh

@@ -0,0 +1,135 @@
+#!/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 "检测到操作系统 | Detected operating system: $OS_TYPE"
+
+# 检查是否提供了查询参数 | Check if query parameters are provided
+if [ $# -lt 1 ]; then
+    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 "请提供查询参数，例如 | Please provide query parameter, e.g.: ./run_in_docker.sh $SCRIPT_NAME '你的问题 | your question'"
+        exit 1
+    fi
+else
+    # 如果第一个参数不是脚本名称，则默认使用 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 "错误 | 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
+        ls -1 owl/*.py | grep -v "__"
+    fi
+    exit 1
+fi
+
+echo "使用脚本 | Using script: $SCRIPT_NAME"
+echo "查询内容 | Query content: $QUERY"
+
+# 从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检测到服务名称 | Detected service name from docker-compose.yml: $SERVICE_NAME"
+    fi
+fi
+
+# 检查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 "错误 | Error: 未找到Docker Compose命令 | Docker Compose command not found"
+    exit 1
+fi
+
+# 确保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容器... | Starting Docker container..."
+    $COMPOSE_CMD up -d
+    
+    # 使用循环检查容器是否就绪 | 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
+        sleep $CHECK_INTERVAL_SECONDS
+        TOTAL_WAIT=$((TOTAL_WAIT + CHECK_INTERVAL_SECONDS))
+        
+        CONTAINER_RUNNING=$($COMPOSE_CMD ps | grep -c "$SERVICE_NAME.*Up" || true)
+        if [ "$CONTAINER_RUNNING" -gt 0 ]; then
+            echo "容器已就绪，共等待了 $TOTAL_WAIT 秒 | Container is ready, waited for $TOTAL_WAIT seconds in total"
+            break
+        else
+            echo "容器尚未就绪，已等待 $TOTAL_WAIT 秒，继续等待... | Container not ready yet, waited for $TOTAL_WAIT seconds, continuing to wait..."
+        fi
+    done
+    
+    if [ "$CONTAINER_RUNNING" -eq 0 ]; then
+        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命令 | 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 "警告 | Warning：容器中未找到 $PYTHON_CMD 命令，尝试使用python替代 | $PYTHON_CMD command not found in container, trying to use python instead"
+    PYTHON_CMD="python"
+    
+    # 检查python命令是否存在 | Check if python command exists
+    if ! $COMPOSE_CMD exec -T $SERVICE_NAME which python &> /dev/null; then
+        echo "错误 | Error：容器中未找到python命令 | python command not found in container"
+        echo "请检查容器配置 | Please check container configuration"
+        exit 1
+    fi
+fi
+
+# 在容器中运行指定的脚本，传递查询参数 | 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 may need special handling for quotes
+    winpty $COMPOSE_CMD exec -T $SERVICE_NAME $PYTHON_CMD $SCRIPT_NAME "$QUERY"
+    RESULT=$?
+else
+    # 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 "查询完成！ | Query completed!"
+else
+    echo "查询执行失败，请检查错误信息。 | Query execution failed, please check error messages."
+fi

.gitattributes

@@ -33,3 +33,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/community.png filter=lfs diff=lfs merge=lfs -text
+assets/community_2.png filter=lfs diff=lfs merge=lfs -text
+assets/community_3.jpg filter=lfs diff=lfs merge=lfs -text
+assets/community_4.jpg filter=lfs diff=lfs merge=lfs -text
+assets/community_5.jpg filter=lfs diff=lfs merge=lfs -text
+assets/community_6.jpg filter=lfs diff=lfs merge=lfs -text
+assets/community_6.png filter=lfs diff=lfs merge=lfs -text
+assets/meetup.jpg filter=lfs diff=lfs merge=lfs -text
+assets/owl_architecture.png filter=lfs diff=lfs merge=lfs -text
+assets/qr_code.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,60 @@
+# Python
+__pycache__/
+**/__pycache__/
+*/__pycache__/*
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+.dist
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.env
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+
+# Project specific
+owl/data
+owl/tmp
+owl/.env
+owl/utils/__pycache__/
+
+# Logs
+*.log
+logs/
+log/
+
+# Coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+coverage.xml
+*.cover
+
+owl/camel/types/__pycache__/
+owl/camel/__pycache__/
+owl/camel/utils/__pycache_/

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

.pre-commit-config.yaml

@@ -0,0 +1,29 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: 'v0.7.4'
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix, --show-fixes]
+        exclude: ^docs/cookbooks/  # Ignore files under docs/cookbooks
+      - id: ruff-format
+        exclude: ^docs/cookbooks/  # Ignore files under docs/cookbooks
+
+  - repo: local
+    hooks:
+      - id: mypy
+        name: Check mypy
+        entry: mypy --namespace-packages -p owl
+        language: python
+        types: [python]
+        pass_filenames: false
+        require_serial: true
+        exclude: ^docs/cookbooks/  # Ignore files under docs/cookbooks
+
+  - repo: local
+    hooks:
+    - id: check-license
+      name: Check License
+      entry: python licenses/update_license.py . licenses/license_template.txt 
+      language: system
+      types: [python]
+      exclude: ^docs/cookbooks/  # Ignore files under docs/cookbooks

README.md

@@ -1,13 +1,392 @@
 ---
-title: Owl
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
+title: owl
+app_file: run_app.py
 sdk: gradio
-sdk_version: 5.0.1
-app_file: app.py
-pinned: false
-short_description: owl
+sdk_version: 5.23.1
 ---
+<h1 align="center">
+	🦉 OWL: Optimized Workforce Learning for General Multi-Agent Assistance in Real-World Task Automation
+</h1>
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+
+<div align="center">
+
+[![Documentation][docs-image]][docs-url]
+[![Discord][discord-image]][discord-url]
+[![X][x-image]][x-url]
+[![Reddit][reddit-image]][reddit-url]
+[![Wechat][wechat-image]][wechat-url]
+[![Wechat][owl-image]][owl-url]
+[![Hugging Face][huggingface-image]][huggingface-url]
+[![Star][star-image]][star-url]
+[![Package License][package-license-image]][package-license-url]
+
+
+</div>
+
+
+<hr>
+
+<div align="center">
+<h4 align="center">
+
+[中文阅读](https://github.com/camel-ai/owl/tree/main/README_zh.md) |
+[Community](https://github.com/camel-ai/owl#community) |
+[Installation](#️-installation) |
+[Examples](https://github.com/camel-ai/owl/tree/main/owl) |
+[Paper](https://arxiv.org/abs/2303.17760) |
+[Citation](https://github.com/camel-ai/owl#citation) |
+[Contributing](https://github.com/camel-ai/owl/graphs/contributors) |
+[CAMEL-AI](https://www.camel-ai.org/)
+
+</h4>
+
+<div align="center" style="background-color: #f0f7ff; padding: 10px; border-radius: 5px; margin: 15px 0;">
+  <h3 style="color: #1e88e5; margin: 0;">
+    🏆 OWL achieves <span style="color: #d81b60; font-weight: bold; font-size: 1.2em;">58.18</span> average score on GAIA benchmark and ranks <span style="color: #d81b60; font-weight: bold; font-size: 1.2em;">🏅️ #1</span> among open-source frameworks! 🏆
+  </h3>
+</div>
+
+<div align="center">
+
+🦉 OWL is a cutting-edge framework for multi-agent collaboration that pushes the boundaries of task automation, built on top of the [CAMEL-AI Framework](https://github.com/camel-ai/camel).
+
+<!-- OWL achieves **58.18** average score on [GAIA](https://huggingface.co/spaces/gaia-benchmark/leaderboard) benchmark and ranks 🏅️ #1 among open-source frameworks. -->
+
+Our vision is to revolutionize how AI agents collaborate to solve real-world tasks. By leveraging dynamic agent interactions, OWL enables more natural, efficient, and robust task automation across diverse domains.
+
+</div>
+
+![](./assets/owl_architecture.png)
+
+<br>
+
+
+</div>
+
+<!-- # Key Features -->
+# 📋 Table of Contents
+
+- [📋 Table of Contents](#-table-of-contents)
+- [🔥 News](#-news)
+- [🎬 Demo Video](#-demo-video)
+- [✨️ Core Features](#-core-features)
+- [🛠️ Installation](#️-installation)
+  - [**Clone the Github repository**](#clone-the-github-repository)
+  - [**Set up Environment**](#set-up-environment)
+  - [**Install Dependencies**](#install-dependencies)
+  - [**Setup Environment Variables**](#setup-environment-variables)
+  - [**Running with Docker**](#running-with-docker)
+  
+- [🚀 Quick Start](#-quick-start)
+- [🌐 Web Interface](#-web-interface)
+- [🧪 Experiments](#-experiments)
+- [⏱️ Future Plans](#️-future-plans)
+- [📄 License](#-license)
+- [🖊️ Cite](#️-cite)
+- [🔥 Community](#-community)
+- [❓ FAQ](#-faq)
+- [⭐ Star History](#-star-history)
+
+
+# 🔥 News
+
+- **[2025.03.07]**: We open-source the codebase of 🦉 OWL project.
+
+# 🎬 Demo Video
+
+https://private-user-images.githubusercontent.com/55657767/420211368-f29f477d-7eef-46da-8d7a-8f3bcf506da2.mp4
+
+https://private-user-images.githubusercontent.com/55657767/420212194-e813fc05-136a-485f-8df3-f10d9b4e63ec.mp4
+
+# ✨️ Core Features
+
+- **Real-time Information Retrieval**: Leverage Wikipedia, Google Search, and other online sources for up-to-date information.
+- **Multimodal Processing**: Support for handling internet or local videos, images, and audio data.
+- **Browser Automation**: Utilize the Playwright framework for simulating browser interactions, including scrolling, clicking, input handling, downloading, navigation, and more.
+- **Document Parsing**: Extract content from Word, Excel, PDF, and PowerPoint files, converting them into text or Markdown format.
+- **Code Execution**: Write and execute Python code using interpreter.
+- **Built-in Toolkits**: Access to a comprehensive set of built-in toolkits including ArxivToolkit, AudioAnalysisToolkit, CodeExecutionToolkit, DalleToolkit, DataCommonsToolkit, ExcelToolkit, GitHubToolkit, GoogleMapsToolkit, GoogleScholarToolkit, ImageAnalysisToolkit, MathToolkit, NetworkXToolkit, NotionToolkit, OpenAPIToolkit, RedditToolkit, SearchToolkit, SemanticScholarToolkit, SymPyToolkit, VideoAnalysisToolkit, WeatherToolkit, WebToolkit, and many more for specialized tasks.
+
+# 🛠️ Installation
+
+## Option 1: Using uv (Recommended)
+
+```bash
+# Clone github repo
+git clone https://github.com/camel-ai/owl.git
+
+# Change directory into project directory
+cd owl
+
+# Install uv if you don't have it already
+pip install uv
+
+# Create a virtual environment and install dependencies
+# We support using Python 3.10, 3.11, 3.12
+uv venv .venv --python=3.10
+
+# Activate the virtual environment
+# For macOS/Linux
+source .venv/bin/activate
+# For Windows
+.venv\Scripts\activate
+
+# Install CAMEL with all dependencies
+uv pip install -e .
+
+# Exit the virtual environment when done
+deactivate
+```
+
+## Option 2: Using venv and pip
+
+```bash
+# Clone github repo
+git clone https://github.com/camel-ai/owl.git
+
+# Change directory into project directory
+cd owl
+
+# Create a virtual environment
+# For Python 3.10 (also works with 3.11, 3.12)
+python3.10 -m venv .venv
+
+# Activate the virtual environment
+# For macOS/Linux
+source .venv/bin/activate
+# For Windows
+.venv\Scripts\activate
+
+# Install from requirements.txt
+pip install -r requirements.txt
+```
+
+## Option 3: Using conda
+
+```bash
+# Clone github repo
+git clone https://github.com/camel-ai/owl.git
+
+# Change directory into project directory
+cd owl
+
+# Create a conda environment
+conda create -n owl python=3.10
+
+# Activate the conda environment
+conda activate owl
+
+# Option 1: Install as a package (recommended)
+pip install -e .
+
+# Option 2: Install from requirements.txt
+pip install -r requirements.txt
+
+# Exit the conda environment when done
+conda deactivate
+```
+
+## **Setup Environment Variables** 
+
+In the `owl/.env_template` file, you will find all the necessary API keys along with the websites where you can register for each service. To use these API services, follow these steps:
+
+1. *Copy and Rename*: Duplicate the `.env_template` file and rename the copy to `.env`.
+```bash
+cp owl/.env_template .env
+```
+2. *Fill in Your Keys*: Open the `.env` file and insert your API keys in the corresponding fields.  (For the minimal example (`run_mini.py`), you only need to configure the LLM API key (e.g., OPENAI_API_KEY).)
+3. *For using more other models*: please refer to our CAMEL models docs:https://docs.camel-ai.org/key_modules/models.html#supported-model-platforms-in-camel
+
+
+> **Note**: For optimal performance, we strongly recommend using OpenAI models. Our experiments show that other models may result in significantly lower performance on complex tasks and benchmarks.
+
+## **Running with Docker**
+
+```bash
+# Clone the repository
+git clone https://github.com/camel-ai/owl.git
+cd owl
+
+# Configure environment variables
+cp owl/.env_template owl/.env
+# Edit the .env file and fill in your API keys
+
+
+# Option 1: Using docker-compose directly
+cd .container
+docker-compose up -d
+# Run OWL inside the container
+docker-compose exec owl bash -c "xvfb-python run.py"
+
+# Option 2: Build and run using the provided scripts
+cd .container
+chmod +x build_docker.sh
+./build_docker.sh
+# Run OWL inside the container
+./run_in_docker.sh "your question"
+```
+
+For more detailed Docker usage instructions, including cross-platform support, optimized configurations, and troubleshooting, please refer to [DOCKER_README.md](.container/DOCKER_README_en.md).
+
+# 🚀 Quick Start
+
+
+   
+Run the following demo case:
+
+```bash
+python owl/run.py
+```
+
+## Running with Different Models
+
+OWL supports various LLM backends. You can use the following scripts to run with different models:
+
+```bash
+# Run with Qwen model
+python owl/run_qwen.py
+
+# Run with Deepseek model
+python owl/run_deepseek.py
+
+# Run with other OpenAI-compatible models
+python owl/run_openai_compatiable_model.py
+```
+
+For a simpler version that only requires an LLM API key, you can try our minimal example:
+
+```bash
+python owl/run_mini.py
+```
+
+You can run OWL agent with your own task by modifying the `run.py` script:
+
+```python
+# Define your own task
+question = "Task description here."
+
+society = construct_society(question)
+answer, chat_history, token_count = run_society(society)
+
+print(f"\033[94mAnswer: {answer}\033[0m")
+```
+
+For uploading files, simply provide the file path along with your question:
+
+```python
+# Task with a local file (e.g., file path: `tmp/example.docx`)
+question = "What is in the given DOCX file? Here is the file path: tmp/example.docx"
+
+society = construct_society(question)
+answer, chat_history, token_count = run_society(society)
+print(f"\033[94mAnswer: {answer}\033[0m")
+```
+
+OWL will then automatically invoke document-related tools to process the file and extract the answer.
+
+
+Example tasks you can try:
+- "Find the latest stock price for Apple Inc."
+- "Analyze the sentiment of recent tweets about climate change"
+- "Help me debug this Python code: [your code here]"
+- "Summarize the main points from this research paper: [paper URL]"
+
+# 🌐 Web Interface
+
+OWL now includes a web-based user interface that makes it easier to interact with the system. To start the web interface, run:
+
+```bash
+python run_app.py
+```
+
+The web interface provides the following features:
+
+- **Easy Model Selection**: Choose between different models (OpenAI, Qwen, DeepSeek, etc.)
+- **Environment Variable Management**: Configure your API keys and other settings directly from the UI
+- **Interactive Chat Interface**: Communicate with OWL agents through a user-friendly interface
+- **Task History**: View the history and results of your interactions
+
+The web interface is built using Gradio and runs locally on your machine. No data is sent to external servers beyond what's required for the model API calls you configure.
+
+# 🧪 Experiments
+
+To reproduce OWL's GAIA benchmark score of 58.18:
+
+1. Switch to the `gaia58.18` branch:
+```bash
+git checkout gaia58.18
+```
+
+1. Run the evaluation script:
+```bash
+python run_gaia_roleplaying.py
+```
+
+# ⏱️ Future Plans
+
+- [ ] Write a technical blog post detailing our exploration and insights in multi-agent collaboration in real-world tasks.
+- [ ] Enhance the toolkit ecosystem with more specialized tools for domain-specific tasks.
+- [ ] Develop more sophisticated agent interaction patterns and communication protocols
+
+
+# 📄 License
+
+The source code is licensed under Apache 2.0.
+
+# 🖊️ Cite
+
+If you find this repo useful, please cite:
+
+
+```
+@misc{owl2025,
+  title        = {OWL: Optimized Workforce Learning for General Multi-Agent Assistance in Real-World Task Automation},
+  author       = {{CAMEL-AI.org}},
+  howpublished = {\url{https://github.com/camel-ai/owl}},
+  note         = {Accessed: 2025-03-07},
+  year         = {2025}
+}
+```
+
+# 🔥 Community
+Join us for further discussions!
+<!-- ![](./assets/community.png) -->
+![](./assets/community_6.png)
+<!-- ![](./assets/meetup.jpg) -->
+
+# ❓ FAQ
+
+**Q: Why don't I see Chrome running locally after starting the example script?**
+
+A: If OWL determines that a task can be completed using non-browser tools (such as search or code execution), the browser will not be launched. The browser window will only appear when OWL determines that browser-based interaction is necessary.
+
+# ⭐ Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=camel-ai/owl&type=Date)](https://star-history.com/#camel-ai/owl&Date)
+
+
+
+[docs-image]: https://img.shields.io/badge/Documentation-EB3ECC
+[docs-url]: https://camel-ai.github.io/camel/index.html
+[star-image]: https://img.shields.io/github/stars/camel-ai/owl?label=stars&logo=github&color=brightgreen
+[star-url]: https://github.com/camel-ai/owl/stargazers
+[package-license-image]: https://img.shields.io/badge/License-Apache_2.0-blue.svg
+[package-license-url]: https://github.com/camel-ai/owl/blob/main/licenses/LICENSE
+
+[colab-url]: https://colab.research.google.com/drive/1AzP33O8rnMW__7ocWJhVBXjKziJXPtim?usp=sharing
+[colab-image]: https://colab.research.google.com/assets/colab-badge.svg
+[huggingface-url]: https://huggingface.co/camel-ai
+[huggingface-image]: https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-CAMEL--AI-ffc107?color=ffc107&logoColor=white
+[discord-url]: https://discord.camel-ai.org/
+[discord-image]: https://img.shields.io/discord/1082486657678311454?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb
+[wechat-url]: https://ghli.org/camel/wechat.png
+[wechat-image]: https://img.shields.io/badge/WeChat-CamelAIOrg-brightgreen?logo=wechat&logoColor=white
+[x-url]: https://x.com/CamelAIOrg
+[x-image]: https://img.shields.io/twitter/follow/CamelAIOrg?style=social
+[twitter-image]: https://img.shields.io/twitter/follow/CamelAIOrg?style=social&color=brightgreen&logo=twitter
+[reddit-url]: https://www.reddit.com/r/CamelAI/
+[reddit-image]: https://img.shields.io/reddit/subreddit-subscribers/CamelAI?style=plastic&logo=reddit&label=r%2FCAMEL&labelColor=white
+[ambassador-url]: https://www.camel-ai.org/community
+[owl-url]: ./assets/qr_code.jpg
+[owl-image]: https://img.shields.io/badge/WeChat-OWLProject-brightgreen?logo=wechat&logoColor=white

README_zh.md

@@ -0,0 +1,375 @@
+<h1 align="center">
+	🦉 OWL: Optimized Workforce Learning for General Multi-Agent Assistance in Real-World Task Automation
+  🦉 OWL: 优化劳动力学习的通用智能体，用于处理现实世界的自动化任务
+</h1>
+
+
+<div align="center">
+
+[![文档][docs-image]][docs-url]
+[![Discord][discord-image]][discord-url]
+[![X][x-image]][x-url]
+[![Reddit][reddit-image]][reddit-url]
+[![微信][wechat-image]][wechat-url]
+[![微信][owl-image]][owl-url]
+[![Hugging Face][huggingface-image]][huggingface-url]
+[![Star][star-image]][star-url]
+[![软件许可证][package-license-image]][package-license-url]
+
+
+</div>
+
+
+<hr>
+
+<div align="center">
+<h4 align="center">
+
+[English README](https://github.com/camel-ai/owl/tree/main) |
+[社区](https://github.com/camel-ai/camel#community) |
+[安装](#️-installation) |
+[示例](https://github.com/camel-ai/owl/tree/main/owl) |
+[论文](https://arxiv.org/abs/2303.17760) |
+[引用](#-community) |
+[贡献](https://github.com/camel-ai/owl/graphs/contributors) |
+[CAMEL-AI](https://www.camel-ai.org/)
+
+</h4>
+
+<div align="center" style="background-color: #f0f7ff; padding: 10px; border-radius: 5px; margin: 15px 0;">
+  <h3 style="color: #1e88e5; margin: 0;">
+    🏆 OWL 在 GAIA 基准测试中取得 <span style="color: #d81b60; font-weight: bold; font-size: 1.2em;">58.18</span> 平均分，在开源框架中排名 <span style="color: #d81b60; font-weight: bold; font-size: 1.2em;">🏅️ #1</span>！ 🏆
+  </h3>
+</div>
+
+<div align="center">
+
+🦉 OWL 是一个前沿的多智能体协作框架，推动任务自动化的边界，构建在 [CAMEL-AI Framework](https://github.com/camel-ai/camel)。
+
+我们的愿景是彻底变革 AI 智能体协作解决现实任务的方式。通过利用动态智能体交互，OWL 实现了跨多领域更自然、高效且稳健的任务自动化。
+
+</div>
+
+![](./assets/owl_architecture.png)
+
+
+
+<br>
+
+
+</div>
+
+<!-- # Key Features -->
+# 📋 目录
+
+- [📋 目录](#-目录)
+- [🔥 新闻](#-新闻)
+- [🎬 演示视频](#-演示视频)
+- [✨️ 核心功能](#-核心功能)
+- [🛠️ 安装](#️-安装)
+  - [**选项1：使用 uv（推荐）**](#选项1使用-uv推荐)
+  - [**选项2：使用 venv 和 pip**](#选项2使用-venv-和-pip)
+  - [**选项3：使用 conda**](#选项3使用-conda)
+  - [**设置环境变量**](#设置环境变量)
+  - [**使用Docker运行**](#使用docker运行)
+- [🚀 快速开始](#-快速开始)
+- [🌐 网页界面](#-网页界面)
+- [🧪 实验](#-实验)
+- [⏱️ 未来计划](#️-未来计划)
+- [📄 许可证](#-许可证)
+- [🖊️ 引用](#️-引用)
+- [🔥 社区](#-社区)
+- [❓ 常见问题](#-常见问题)
+
+
+# 🔥 新闻
+
+- **[2025.03.07]**: 我们开源了 🦉 OWL 项目的代码库。
+
+# 🎬 演示视频
+
+https://private-user-images.githubusercontent.com/55657767/420211368-f29f477d-7eef-46da-8d7a-8f3bcf506da2.mp4
+
+https://private-user-images.githubusercontent.com/55657767/420212194-e813fc05-136a-485f-8df3-f10d9b4e63ec.mp4
+
+# ✨️ 核心功能
+
+- **在线搜索**：使用维基百科、谷歌搜索等，进行实时信息检索
+- **多模态处理**：支持互联网或本地视频、图片、语音处理
+- **浏览器操作**：借助Playwright框架开发浏览器模拟交互，支持页面滚动、点击、输入、下载、历史回退等功能
+- **文件解析**：word、excel、PDF、PowerPoint信息提取，内容转文本/Markdown
+- **代码执行**：编写python代码，并使用解释器运行
+- **丰富工具包**：提供丰富的工具包，包括ArxivToolkit（学术论文检索）、AudioAnalysisToolkit（音频分析）、CodeExecutionToolkit（代码执行）、DalleToolkit（图像生成）、DataCommonsToolkit（数据共享）、ExcelToolkit（Excel处理）、GitHubToolkit（GitHub交互）、GoogleMapsToolkit（地图服务）、GoogleScholarToolkit（学术搜索）、ImageAnalysisToolkit（图像分析）、MathToolkit（数学计算）、NetworkXToolkit（图形分析）、NotionToolkit（Notion交互）、OpenAPIToolkit（API操作）、RedditToolkit（Reddit交互）、SearchToolkit（搜索服务）、SemanticScholarToolkit（语义学术搜索）、SymPyToolkit（符号计算）、VideoAnalysisToolkit（视频分析）、WeatherToolkit（天气查询）、WebToolkit（网页交互）等多种专业工具，满足各类特定任务需求。
+
+# 🛠️ 安装
+
+## 选项1：使用 uv（推荐）
+
+```bash
+# 克隆 GitHub 仓库
+git clone https://github.com/camel-ai/owl.git
+
+# 进入项目目录
+cd owl
+
+# 如果你还没有安装 uv，请先安装
+pip install uv
+
+# 创建虚拟环境并安装依赖
+# 我们支持使用 Python 3.10、3.11、3.12
+uv venv .venv --python=3.10
+
+# 激活虚拟环境
+# 对于 macOS/Linux
+source .venv/bin/activate
+# 对于 Windows
+.venv\Scripts\activate
+
+# 安装 CAMEL 及其所有依赖
+uv pip install -e .
+
+# 完成后退出虚拟环境
+deactivate
+```
+
+## 选项2：使用 venv 和 pip
+
+```bash
+# 克隆 GitHub 仓库
+git clone https://github.com/camel-ai/owl.git
+
+# 进入项目目录
+cd owl
+
+# 创建虚拟环境
+# 对于 Python 3.10（也适用于 3.11、3.12）
+python3.10 -m venv .venv
+
+# 激活虚拟环境
+# 对于 macOS/Linux
+source .venv/bin/activate
+# 对于 Windows
+.venv\Scripts\activate
+
+# 从 requirements.txt 安装
+pip install -r requirements.txt
+```
+
+## 选项3：使用 conda
+
+```bash
+# 克隆 GitHub 仓库
+git clone https://github.com/camel-ai/owl.git
+
+# 进入项目目录
+cd owl
+
+# 创建 conda 环境
+conda create -n owl python=3.10
+
+# 激活 conda 环境
+conda activate owl
+
+# 选项1：作为包安装（推荐）
+pip install -e .
+
+# 选项2：从 requirements.txt 安装
+pip install -r requirements.txt
+
+# 完成后退出 conda 环境
+conda deactivate
+```
+
+## **设置环境变量**  
+
+在 `owl/.env_template` 文件中，你可以找到所有必要的 API 密钥以及各服务的注册网址。要使用这些 API 服务，请按照以下步骤操作：
+
+1. *复制并重命名*: 复制 `.env_template` 文件，并将副本重命名为 `.env`。
+2. *填写你的密钥*: 打开 `.env` 文件，在相应字段中填入你的 API 密钥。 
+3. *如需使用更多其他模型*：请参考我们CAMEL的models文档：https://docs.camel-ai.org/key_modules/models.html#supported-model-platforms-in-camel
+
+> **注意**：为获得最佳性能，我们强烈建议使用 OpenAI 模型。我们通过测试发现，其他模型在处理复杂任务和基准测试时可能会导致性能显著降低。
+
+## **使用Docker运行**
+
+如果您希望使用Docker运行OWL项目，我们提供了完整的Docker支持：
+
+```bash
+# 克隆仓库
+git clone https://github.com/camel-ai/owl.git
+cd owl
+
+# 配置环境变量
+cp owl/.env_template owl/.env
+# 编辑.env文件，填入您的API密钥
+
+# 选项1：直接使用docker-compose
+cd .container
+docker-compose up -d
+# 在容器中运行OWL
+docker-compose exec owl bash -c "xvfb-python run.py"
+
+# 选项2：使用提供的脚本构建和运行
+cd .container
+chmod +x build_docker.sh
+./build_docker.sh
+# 在容器中运行OWL
+./run_in_docker.sh "您的问题"
+```
+
+更多详细的Docker使用说明，包括跨平台支持、优化配置和故障排除，请参阅 [DOCKER_README.md](.container/DOCKER_README.md)
+
+# 🚀 快速开始
+   
+运行以下示例：
+
+```bash
+python owl/run.py
+```
+
+我们还提供了一个最小化示例，只需配置LLM的API密钥即可运行：
+
+```bash
+python owl/run_mini.py
+```
+
+## 使用不同的模型
+
+OWL 支持多种 LLM 后端。您可以使用以下脚本来运行不同的模型：
+
+```bash
+# 使用 Qwen 模型运行
+python owl/run_qwen.py
+
+# 使用 Deepseek 模型运行
+python owl/run_deepseek.py
+
+# 使用其他 OpenAI 兼容模型运行
+python owl/run_openai_compatiable_model.py
+```
+
+你可以通过修改 `run.py` 脚本来运行自己的任务：
+
+```python
+# Define your own task
+question = "Task description here."
+
+society = construct_society(question)
+answer, chat_history, token_count = run_society(society)
+
+print(f"\033[94mAnswer: {answer}\033[0m")
+```
+
+上传文件时，只需提供文件路径和问题：
+
+```python
+# 处理本地文件（例如，文件路径为 `tmp/example.docx`）
+question = "给定的 DOCX 文件中有什么内容？文件路径如下：tmp/example.docx"
+
+society = construct_society(question)
+answer, chat_history, token_count = run_society(society)
+
+print(f"答案：{answer}")
+```
+
+OWL 将自动调用与文档相关的工具来处理文件并提取答案。
+
+你可以尝试以下示例任务：
+- "查询苹果公司的最新股票价格"
+- "分析关于气候变化的最新推文情绪"
+- "帮我调试这段 Python 代码：[在此粘贴你的代码]"
+- "总结这篇研究论文的主要观点：[论文URL]"
+
+# 🌐 网页界面
+
+OWL 现在包含一个基于网页的用户界面，使与系统交互变得更加容易。要启动网页界面，请运行：
+
+```bash
+python run_app.py
+```
+
+网页界面提供以下功能：
+
+- **便捷的模型选择**：选择不同的模型（OpenAI、Qwen、DeepSeek等）
+- **环境变量管理**：直接从界面配置API密钥和其他设置
+- **交互式聊天界面**：通过用户友好的界面与OWL智能体交流
+- **任务历史**：查看交互的历史记录和结果
+
+网页界面使用Gradio构建，在您的本地机器上运行。除了您配置的模型API调用所需的数据外，不会向外部服务器发送任何数据。
+
+# 🧪 实验
+
+我们提供了一个脚本用于复现 GAIA 上的实验结果。
+要复现我们在 GAIA 基准测试中获得的 58.18 分：
+
+1. 切换到 `gaia58.18` 分支：
+```bash
+git checkout gaia58.18
+```
+
+2. 运行评估脚本：
+```bash
+python run_gaia_roleplaying.py
+```
+
+# ⏱️ 未来计划
+
+- [ ] 撰写一篇技术博客，详细介绍我们在现实任务中多智能体协作方面的探索与见解。
+- [ ] 通过引入更多针对特定领域任务的专业工具，进一步完善工具生态系统。
+- [ ] 开发更复杂的智能体交互模式和通信协议
+
+
+# 📄 许可证
+
+源代码采用 Apache 2.0 许可证。
+
+# 🖊️ 引用
+
+如果你觉得这个仓库对你有帮助，请引用：
+
+
+```
+@misc{owl2025,
+  title        = {OWL: Optimized Workforce Learning for General Multi-Agent Assistance in Real-World Task Automation},
+  author       = {{CAMEL-AI.org}},
+  howpublished = {\url{https://github.com/camel-ai/owl}},
+  note         = {Accessed: 2025-03-07},
+  year         = {2025}
+}
+```
+
+# 🔥 社区
+加入我们，参与更多讨论！
+<!-- ![](./assets/community.png) -->
+![](./assets/community_6.png)
+<!-- ![](./assets/meetup.jpg) -->
+
+# ❓ 常见问题
+
+**Q: 为什么启动示例脚本后，我没有看到本地运行Chrome浏览器？**
+
+A: 当OWL判断某个任务可以使用非浏览器工具（如搜索、代码分析等）完成时，浏览器就不会启动。只有在判断需要使用浏览器工具的时候，本地才会弹出浏览器窗口，并进行浏览器模拟交互。
+
+[docs-image]: https://img.shields.io/badge/Documentation-EB3ECC
+[docs-url]: https://camel-ai.github.io/camel/index.html
+[star-image]: https://img.shields.io/github/stars/camel-ai/owl?label=stars&logo=github&color=brightgreen
+[star-url]: https://github.com/camel-ai/owl/stargazers
+[package-license-image]: https://img.shields.io/badge/License-Apache_2.0-blue.svg
+[package-license-url]: https://github.com/camel-ai/owl/blob/main/licenses/LICENSE
+
+[colab-url]: https://colab.research.google.com/drive/1AzP33O8rnMW__7ocWJhVBXjKziJXPtim?usp=sharing
+[colab-image]: https://colab.research.google.com/assets/colab-badge.svg
+[huggingface-url]: https://huggingface.co/camel-ai
+[huggingface-image]: https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-CAMEL--AI-ffc107?color=ffc107&logoColor=white
+[discord-url]: https://discord.camel-ai.org/
+[discord-image]: https://img.shields.io/discord/1082486657678311454?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb
+[wechat-url]: https://ghli.org/camel/wechat.png
+[wechat-image]: https://img.shields.io/badge/WeChat-CamelAIOrg-brightgreen?logo=wechat&logoColor=white
+[x-url]: https://x.com/CamelAIOrg
+[x-image]: https://img.shields.io/twitter/follow/CamelAIOrg?style=social
+[twitter-image]: https://img.shields.io/twitter/follow/CamelAIOrg?style=social&color=brightgreen&logo=twitter
+[reddit-url]: https://www.reddit.com/r/CamelAI/
+[reddit-image]: https://img.shields.io/reddit/subreddit-subscribers/CamelAI?style=plastic&logo=reddit&label=r%2FCAMEL&labelColor=white
+[ambassador-url]: https://www.camel-ai.org/community
+[owl-url]: ./assets/qr_code.jpg
+[owl-image]: https://img.shields.io/badge/WeChat-OWLProject-brightgreen?logo=wechat&logoColor=white

licenses/LICENSE

@@ -0,0 +1,13 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========

licenses/license_template.txt

@@ -0,0 +1,13 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========

licenses/update_license.py

@@ -0,0 +1,126 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import os
+import re
+import sys
+from pathlib import Path
+from typing import List
+
+
+# The license template file is hard-coded with specific start and end lines
+def fine_license_start_line(lines: List[str], start_with: str) -> int:
+    for i in range(len(lines)):
+        if lines[i].startswith(start_with):
+            return i
+    return None
+
+
+def find_license_end_line(lines: List[str], start_with: str) -> int:
+    for i in range(len(lines) - 1, -1, -1):
+        if lines[i].startswith(start_with):
+            return i
+    return None
+
+
+def update_license_in_file(
+    file_path: str,
+    license_template_path: str,
+    start_line_start_with: str,
+    end_line_start_with: str,
+) -> bool:
+    with open(file_path, "r", encoding="utf-8") as f:  # for windows compatibility
+        content = f.read()
+
+    with open(license_template_path, "r", encoding="utf-8") as f:
+        new_license = f.read().strip()
+
+    maybe_existing_licenses = re.findall(
+        r"^#.*?(?=\n)", content, re.MULTILINE | re.DOTALL
+    )
+    start_index = fine_license_start_line(
+        maybe_existing_licenses, start_line_start_with
+    )
+    end_index = find_license_end_line(maybe_existing_licenses, end_line_start_with)
+    if start_index is not None and end_index is not None:
+        maybe_existing_licenses = maybe_existing_licenses[start_index : end_index + 1]
+    else:
+        maybe_existing_licenses = None
+    if maybe_existing_licenses:
+        maybe_old_licenses = "\n".join(maybe_existing_licenses)
+        if maybe_old_licenses.strip() != new_license.strip():
+            replaced_content = content.replace(maybe_old_licenses, new_license)
+            with open(file_path, "w") as f:
+                f.write(replaced_content)
+            print(f"Replaced license in {file_path}")
+            return True
+        else:
+            return False
+    else:
+        with open(file_path, "w") as f:
+            f.write(new_license + "\n" + content)
+        print(f"Added license to {file_path}")
+        return True
+
+
+def update_license_in_directory(
+    directory_path: str,
+    license_template_path: str,
+    start_line_start_with: str,
+    end_line_start_with: str,
+) -> None:
+    # Check if directory exists
+    if not os.path.isdir(directory_path):
+        raise NotADirectoryError(f"{directory_path} is not a directory")
+    # Check if license template exists
+    if not os.path.isfile(license_template_path):
+        raise FileNotFoundError(f"{license_template_path} not found")
+
+    file_count = 0
+    for py_files in Path(directory_path).rglob("*.py"):
+        if py_files.name.startswith("."):
+            continue
+        if any(part.startswith(".") for part in py_files.parts):
+            continue
+        if update_license_in_file(
+            py_files,
+            license_template_path,
+            start_line_start_with,
+            end_line_start_with,
+        ):
+            file_count += 1
+
+    print(f"License updated in {file_count} files")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print(
+            "Usage from command line: "
+            "python update_license.py <directory_path> <license_template_path>"
+            "No valid input arguments found, please enter manually."
+        )
+        directory_path = input("Enter directory path: ")
+        license_template_path = input("Enter license template path: ")
+    else:
+        directory_path = sys.argv[1]
+        license_template_path = sys.argv[2]
+
+    start_line_start_with = "# ========= Copyright"
+    end_line_start_with = "# ========= Copyright"
+    update_license_in_directory(
+        directory_path,
+        license_template_path,
+        start_line_start_with,
+        end_line_start_with,
+    )

owl/.env_template

@@ -0,0 +1,28 @@
+# MODEL & API (See https://github.com/camel-ai/camel/blob/master/camel/types/enums.py)
+
+# OPENAI API
+OPENAI_API_KEY = ""
+# OPENAI_API_BASE_URL = ""
+
+# Qwen API (https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key)
+# QWEN_API_KEY=""
+
+# DeepSeek API (https://platform.deepseek.com/api_keys)
+# DEEPSEEK_API_KEY=""
+
+#===========================================
+# Tools & Services API
+#===========================================
+
+# Google Search API (https://developers.google.com/custom-search/v1/overview)
+GOOGLE_API_KEY=""
+SEARCH_ENGINE_ID=""
+
+# Hugging Face API (https://huggingface.co/join)
+HF_TOKEN=""
+
+# Chunkr API (https://chunkr.ai/)
+CHUNKR_API_KEY=""
+
+# Firecrawl API (https://www.firecrawl.dev/)
+FIRECRAWL_API_KEY=""

owl/app.py

@@ -0,0 +1,669 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import os
+import sys
+import gradio as gr
+import subprocess
+import threading
+import time
+from datetime import datetime
+import queue
+from pathlib import Path
+import json
+import signal
+import dotenv
+
+# 设置日志队列
+log_queue = queue.Queue()
+
+# 当前运行的进程
+current_process = None
+process_lock = threading.Lock()
+
+# 脚本选项
+SCRIPTS = {
+    "Qwen Mini (中文)": "run_qwen_mini_zh.py",
+    "Qwen （中文）": "run_qwen_zh.py",
+    "Mini": "run_mini.py",
+    "DeepSeek （中文）": "run_deepseek_zh.py",
+    "Default": "run.py",
+    "GAIA Roleplaying": "run_gaia_roleplaying.py",
+}
+
+# 脚本描述
+SCRIPT_DESCRIPTIONS = {
+    "Qwen Mini (中文)": "使用阿里云Qwen模型的中文版本，适合中文问答和任务",
+    "Qwen （中文）": "使用阿里云Qwen模型，支持多种工具和功能",
+    "Mini": "轻量级版本，使用OpenAI GPT-4o模型",
+    "DeepSeek （中文）": "使用DeepSeek模型，适合非多模态任务",
+    "Default": "默认OWL实现，使用OpenAI GPT-4o模型和全套工具",
+    "GAIA Roleplaying": "GAIA基准测试实现，用于评估模型能力",
+}
+
+# 环境变量分组
+ENV_GROUPS = {
+    "模型API": [
+        {
+            "name": "OPENAI_API_KEY",
+            "label": "OpenAI API密钥",
+            "type": "password",
+            "required": False,
+            "help": "OpenAI API密钥，用于访问GPT模型。获取方式：https://platform.openai.com/api-keys",
+        },
+        {
+            "name": "OPENAI_API_BASE_URL",
+            "label": "OpenAI API基础URL",
+            "type": "text",
+            "required": False,
+            "help": "OpenAI API的基础URL，可选。如果使用代理或自定义端点，请设置此项。",
+        },
+        {
+            "name": "QWEN_API_KEY",
+            "label": "阿里云Qwen API密钥",
+            "type": "password",
+            "required": False,
+            "help": "阿里云Qwen API密钥，用于访问Qwen模型。获取方式：https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key",
+        },
+        {
+            "name": "DEEPSEEK_API_KEY",
+            "label": "DeepSeek API密钥",
+            "type": "password",
+            "required": False,
+            "help": "DeepSeek API密钥，用于访问DeepSeek模型。获取方式：https://platform.deepseek.com/api_keys",
+        },
+    ],
+    "搜索工具": [
+        {
+            "name": "GOOGLE_API_KEY",
+            "label": "Google API密钥",
+            "type": "password",
+            "required": False,
+            "help": "Google搜索API密钥，用于网络搜索功能。获取方式：https://developers.google.com/custom-search/v1/overview",
+        },
+        {
+            "name": "SEARCH_ENGINE_ID",
+            "label": "搜索引擎ID",
+            "type": "text",
+            "required": False,
+            "help": "Google自定义搜索引擎ID，与Google API密钥配合使用。获取方式：https://developers.google.com/custom-search/v1/overview",
+        },
+    ],
+    "其他工具": [
+        {
+            "name": "HF_TOKEN",
+            "label": "Hugging Face令牌",
+            "type": "password",
+            "required": False,
+            "help": "Hugging Face API令牌，用于访问Hugging Face模型和数据集。获取方式：https://huggingface.co/join",
+        },
+        {
+            "name": "CHUNKR_API_KEY",
+            "label": "Chunkr API密钥",
+            "type": "password",
+            "required": False,
+            "help": "Chunkr API密钥，用于文档处理功能。获取方式：https://chunkr.ai/",
+        },
+        {
+            "name": "FIRECRAWL_API_KEY",
+            "label": "Firecrawl API密钥",
+            "type": "password",
+            "required": False,
+            "help": "Firecrawl API密钥，用于网页爬取功能。获取方式：https://www.firecrawl.dev/",
+        },
+    ],
+    "自定义环境变量": [],  # 用户自定义的环境变量将存储在这里
+}
+
+
+def get_script_info(script_name):
+    """获取脚本的详细信息"""
+    return SCRIPT_DESCRIPTIONS.get(script_name, "无描述信息")
+
+
+def load_env_vars():
+    """加载环境变量"""
+    env_vars = {}
+    # 尝试从.env文件加载
+    dotenv.load_dotenv()
+
+    # ���取所有环境变量
+    for group in ENV_GROUPS.values():
+        for var in group:
+            env_vars[var["name"]] = os.environ.get(var["name"], "")
+
+    # 加载.env文件中可能存在的其他环境变量
+    if Path(".env").exists():
+        with open(".env", "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    key, value = line.split("=", 1)
+                    key = key.strip()
+                    value = value.strip().strip("\"'")
+
+                    # 检查是否是已知的环境变量
+                    known_var = False
+                    for group in ENV_GROUPS.values():
+                        if any(var["name"] == key for var in group):
+                            known_var = True
+                            break
+
+                    # 如果不是已知的环境变量，添加到自定义环境变量组
+                    if not known_var and key not in env_vars:
+                        ENV_GROUPS["自定义环境变量"].append(
+                            {
+                                "name": key,
+                                "label": key,
+                                "type": "text",
+                                "required": False,
+                                "help": "用户自定义环境变量",
+                            }
+                        )
+                        env_vars[key] = value
+
+    return env_vars
+
+
+def save_env_vars(env_vars):
+    """保存环境变量到.env文件"""
+    # 读取现有的.env文件内容
+    env_path = Path(".env")
+    existing_content = {}
+
+    if env_path.exists():
+        with open(env_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    key, value = line.split("=", 1)
+                    existing_content[key.strip()] = value.strip()
+
+    # 更新环境变量
+    for key, value in env_vars.items():
+        if value:  # 只保存非空值
+            # 确保值是字符串形式，并用引号包裹
+            value = str(value)  # 确保值是字符串
+            if not (value.startswith('"') and value.endswith('"')) and not (
+                value.startswith("'") and value.endswith("'")
+            ):
+                value = f'"{value}"'
+            existing_content[key] = value
+            # 同时更新当前进程的环境变量
+            os.environ[key] = value.strip("\"'")
+
+    # 写入.env文件
+    with open(env_path, "w", encoding="utf-8") as f:
+        for key, value in existing_content.items():
+            f.write(f"{key}={value}\n")
+
+    return "✅ 环境变量已保存"
+
+
+def add_custom_env_var(name, value, var_type):
+    """添加自定义环境变量"""
+    if not name:
+        return "❌ 环境变量名不能为空", None
+
+    # 检查是否已存在同名环境变量
+    for group in ENV_GROUPS.values():
+        if any(var["name"] == name for var in group):
+            return f"❌ 环境变量 {name} 已存在", None
+
+    # 添加到自定义环境变量组
+    ENV_GROUPS["自定义环境变量"].append(
+        {
+            "name": name,
+            "label": name,
+            "type": var_type,
+            "required": False,
+            "help": "用户自定义环境变量",
+        }
+    )
+
+    # 保存环境变量
+    env_vars = {name: value}
+    save_env_vars(env_vars)
+
+    # 返回成功消息和更新后的环境变量组
+    return f"✅ 已添加环境变量 {name}", ENV_GROUPS["自定义环境变量"]
+
+
+def terminate_process():
+    """终止当前运行的进程"""
+    global current_process
+
+    with process_lock:
+        if current_process is not None and current_process.poll() is None:
+            # 在Windows上使用CTRL_BREAK_EVENT，在Unix上使用SIGTERM
+            if os.name == "nt":
+                current_process.send_signal(signal.CTRL_BREAK_EVENT)
+            else:
+                current_process.terminate()
+
+            # 等待进程终止
+            try:
+                current_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                # 如果进程没有在5秒内终止，强制终止
+                current_process.kill()
+
+            log_queue.put("进程已终止\n")
+            return "✅ 进程已终止"
+        else:
+            return "❌ 没有正在运行的进程"
+
+
+def run_script(script_dropdown, question, progress=gr.Progress()):
+    """运行选定的脚本并返回输出"""
+    global current_process
+
+    script_name = SCRIPTS.get(script_dropdown)
+    if not script_name:
+        return "❌ 无效的脚本选择", "", "", "", None
+
+    if not question.strip():
+        return "请输入问题！", "", "", "", None
+
+    # 清空日志队列
+    while not log_queue.empty():
+        log_queue.get()
+
+    # 创建日志目录
+    log_dir = Path("logs")
+    log_dir.mkdir(exist_ok=True)
+
+    # 创建带时间戳的日志文件
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_file = log_dir / f"{script_name.replace('.py', '')}_{timestamp}.log"
+
+    # 构建命令
+    cmd = [
+        sys.executable,
+        os.path.join("owl", "script_adapter.py"),
+        os.path.join("owl", script_name),
+    ]
+
+    # 创建环境变量副本并添加问题
+    env = os.environ.copy()
+    env["OWL_QUESTION"] = question
+
+    # 启动进程
+    with process_lock:
+        current_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            env=env,
+        )
+
+    # 创建线程来读取输出
+    def read_output():
+        try:
+            with open(log_file, "w", encoding="utf-8") as f:
+                for line in iter(current_process.stdout.readline, ""):
+                    if line:
+                        # 写入日志文件
+                        f.write(line)
+                        f.flush()
+                        # 添加到队列
+                        log_queue.put(line)
+        except Exception as e:
+            log_queue.put(f"读取输出时出错: {str(e)}\n")
+
+    # 启动读取线程
+    threading.Thread(target=read_output, daemon=True).start()
+
+    # 收集日志
+    logs = []
+    progress(0, desc="正在运行...")
+
+    # 等待进程完成或超时
+    start_time = time.time()
+    timeout = 1800  # 30分钟超时
+
+    while current_process.poll() is None:
+        # 检查是否超时
+        if time.time() - start_time > timeout:
+            with process_lock:
+                if current_process.poll() is None:
+                    if os.name == "nt":
+                        current_process.send_signal(signal.CTRL_BREAK_EVENT)
+                    else:
+                        current_process.terminate()
+                    log_queue.put("执行超时，已终止进程\n")
+            break
+
+        # 从队列获取日志
+        while not log_queue.empty():
+            log = log_queue.get()
+            logs.append(log)
+
+        # 更新进度
+        elapsed = time.time() - start_time
+        progress(min(elapsed / 300, 0.99), desc="正在运行...")
+
+        # 短暂休眠以减少CPU使用
+        time.sleep(0.1)
+
+        # 每秒更新一次日志显示
+        yield (
+            status_message(current_process),
+            extract_answer(logs),
+            "".join(logs),
+            str(log_file),
+            None,
+        )
+
+    # 获取剩余日志
+    while not log_queue.empty():
+        logs.append(log_queue.get())
+
+    # 提取聊天历史（如果有）
+    chat_history = extract_chat_history(logs)
+
+    # 返回最终状态和日志
+    return (
+        status_message(current_process),
+        extract_answer(logs),
+        "".join(logs),
+        str(log_file),
+        chat_history,
+    )
+
+
+def status_message(process):
+    """根据进程状态返回状态消息"""
+    if process.poll() is None:
+        return "⏳ 正在运行..."
+    elif process.returncode == 0:
+        return "✅ 执行成功"
+    else:
+        return f"❌ 执行失败 (返回码: {process.returncode})"
+
+
+def extract_answer(logs):
+    """从日志中提取答案"""
+    answer = ""
+    for log in logs:
+        if "Answer:" in log:
+            answer = log.split("Answer:", 1)[1].strip()
+            break
+    return answer
+
+
+def extract_chat_history(logs):
+    """尝试从日志中提取聊天历史"""
+    try:
+        chat_json_str = ""
+        capture_json = False
+
+        for log in logs:
+            if "chat_history" in log:
+                # 开始捕获JSON
+                start_idx = log.find("[")
+                if start_idx != -1:
+                    capture_json = True
+                    chat_json_str = log[start_idx:]
+            elif capture_json:
+                # 继续捕获JSON直到找到匹配的结束括号
+                chat_json_str += log
+                if "]" in log:
+                    # 找到结束括号，尝试解析JSON
+                    end_idx = chat_json_str.rfind("]") + 1
+                    if end_idx > 0:
+                        try:
+                            # 清理可能的额外文本
+                            json_str = chat_json_str[:end_idx].strip()
+                            chat_data = json.loads(json_str)
+
+                            # 格式化为Gradio聊天组件可用的格式
+                            formatted_chat = []
+                            for msg in chat_data:
+                                if "role" in msg and "content" in msg:
+                                    role = "用户" if msg["role"] == "user" else "助手"
+                                    formatted_chat.append([role, msg["content"]])
+                            return formatted_chat
+                        except json.JSONDecodeError:
+                            # 如果解析失败，继续捕获
+                            pass
+                        except Exception:
+                            # 其他错误，停止捕获
+                            capture_json = False
+    except Exception:
+        pass
+    return None
+
+
+def create_ui():
+    """创建Gradio界面"""
+    # 加载环境变量
+    env_vars = load_env_vars()
+
+    with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue")) as app:
+        gr.Markdown(
+            """
+            # 🦉 OWL 智能助手运行平台
+            
+            选择一个模型并输入您的问题，系统将运行相应的脚本并显示结果。
+            """
+        )
+
+        with gr.Tabs() as tabs:
+            with gr.TabItem("运行模式"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        # 确保默认值是SCRIPTS中存在的键
+                        default_script = list(SCRIPTS.keys())[0] if SCRIPTS else None
+                        script_dropdown = gr.Dropdown(
+                            choices=list(SCRIPTS.keys()),
+                            value=default_script,
+                            label="选择模式",
+                        )
+
+                        script_info = gr.Textbox(
+                            value=get_script_info(default_script)
+                            if default_script
+                            else "",
+                            label="模型描述",
+                            interactive=False,
+                        )
+
+                        script_dropdown.change(
+                            fn=lambda x: get_script_info(x),
+                            inputs=script_dropdown,
+                            outputs=script_info,
+                        )
+
+                        question_input = gr.Textbox(
+                            lines=5, placeholder="请输入您的问题...", label="问题"
+                        )
+
+                        gr.Markdown(
+                            """
+                            > **注意**: 您输入的问题将替换脚本中的默认问题。系统会自动处理问题的替换，确保您的问题被正确使用。
+                            """
+                        )
+
+                        with gr.Row():
+                            run_button = gr.Button("运行", variant="primary")
+                            stop_button = gr.Button("终止", variant="stop")
+
+                    with gr.Column(scale=2):
+                        with gr.Tabs():
+                            with gr.TabItem("结果"):
+                                status_output = gr.Textbox(label="状态")
+                                answer_output = gr.Textbox(label="回答", lines=10)
+                                log_file_output = gr.Textbox(label="日志文件路径")
+
+                            with gr.TabItem("运行日志"):
+                                log_output = gr.Textbox(label="完整日志", lines=25)
+
+                            with gr.TabItem("聊天历史"):
+                                chat_output = gr.Chatbot(label="对话历史")
+
+                # 示例问题
+                examples = [
+                    [
+                        "Qwen Mini (中文)",
+                        "浏览亚马逊并找出一款对程序员有吸引力的产品。请提供产品名称和价格",
+                    ],
+                    [
+                        "DeepSeek （中文）",
+                        "请分析GitHub上CAMEL-AI项目的最新统计数据。找出该项目的星标数量、贡献者数量和最近的活跃度。然后，创建一个简单的Excel表格来展示这些数据，并生成一个柱状图来可视化这些指标。最后，总结CAMEL项目的受欢迎程度和发展趋势。",
+                    ],
+                    [
+                        "Default",
+                        "Navigate to Amazon.com and identify one product that is attractive to coders. Please provide me with the product name and price. No need to verify your answer.",
+                    ],
+                ]
+
+                gr.Examples(examples=examples, inputs=[script_dropdown, question_input])
+
+            with gr.TabItem("环境变量配置"):
+                env_inputs = {}
+                save_status = gr.Textbox(label="保存状态", interactive=False)
+
+                # 添加自定义环境变量部分
+                with gr.Accordion("添加自定义环境变量", open=True):
+                    with gr.Row():
+                        new_var_name = gr.Textbox(
+                            label="环境变量名", placeholder="例如：MY_CUSTOM_API_KEY"
+                        )
+                        new_var_value = gr.Textbox(
+                            label="环境变量值", placeholder="输入值"
+                        )
+                        new_var_type = gr.Dropdown(
+                            choices=["text", "password"], value="text", label="类型"
+                        )
+
+                    add_var_button = gr.Button("添加环境变量", variant="primary")
+                    add_var_status = gr.Textbox(label="添加状态", interactive=False)
+
+                    # 自定义环境变量列表
+                    custom_vars_list = gr.JSON(
+                        value=ENV_GROUPS["自定义环境变量"],
+                        label="已添加的自定义环境变量",
+                        visible=len(ENV_GROUPS["自定义环境变量"]) > 0,
+                    )
+
+                    # 添加环境变量按钮点击事件
+                    add_var_button.click(
+                        fn=add_custom_env_var,
+                        inputs=[new_var_name, new_var_value, new_var_type],
+                        outputs=[add_var_status, custom_vars_list],
+                    )
+
+                # 现有环境变量配置
+                for group_name, vars in ENV_GROUPS.items():
+                    if (
+                        group_name != "自定义环境变量" or len(vars) > 0
+                    ):  # 只显示非空的自定义环境变量组
+                        with gr.Accordion(
+                            group_name, open=(group_name != "自定义环境变量")
+                        ):
+                            for var in vars:
+                                # 添加帮助信息
+                                gr.Markdown(f"**{var['help']}**")
+
+                                if var["type"] == "password":
+                                    env_inputs[var["name"]] = gr.Textbox(
+                                        value=env_vars.get(var["name"], ""),
+                                        label=var["label"],
+                                        placeholder=f"请输入{var['label']}",
+                                        type="password",
+                                    )
+                                else:
+                                    env_inputs[var["name"]] = gr.Textbox(
+                                        value=env_vars.get(var["name"], ""),
+                                        label=var["label"],
+                                        placeholder=f"请输入{var['label']}",
+                                    )
+
+                save_button = gr.Button("保存环境变量", variant="primary")
+
+                # 保存环境变量
+                save_inputs = [
+                    env_inputs[var_name]
+                    for group in ENV_GROUPS.values()
+                    for var in group
+                    for var_name in [var["name"]]
+                    if var_name in env_inputs
+                ]
+                save_button.click(
+                    fn=lambda *values: save_env_vars(
+                        dict(
+                            zip(
+                                [
+                                    var["name"]
+                                    for group in ENV_GROUPS.values()
+                                    for var in group
+                                    if var["name"] in env_inputs
+                                ],
+                                values,
+                            )
+                        )
+                    ),
+                    inputs=save_inputs,
+                    outputs=save_status,
+                )
+
+        # 运行脚本
+        run_button.click(
+            fn=run_script,
+            inputs=[script_dropdown, question_input],
+            outputs=[
+                status_output,
+                answer_output,
+                log_output,
+                log_file_output,
+                chat_output,
+            ],
+            show_progress=True,
+        )
+
+        # 终止运行
+        stop_button.click(fn=terminate_process, inputs=[], outputs=[status_output])
+
+        # 添加页脚
+        gr.Markdown(
+            """
+            ### 📝 使用说明
+            
+            - 选择一个模型并输入您的问题
+            - 点击"运行"按钮开始执行
+            - 如需终止运行，点击"终止"按钮
+            - 在"结果"标签页查看执行状态和回答
+            - 在"运行日志"标签页查看完整日志
+            - 在"聊天历史"标签页查看对话历史（如果有）
+            - 在"环境变量配置"标签页配置API密钥和其他环境变量
+            - 您可以添加自定义环境变量，满足特殊需求
+            
+            ### ⚠️ 注意事项
+            
+            - 运行某些模型可能需要API密钥，请确保在"环境变量配置"标签页中设置了相应的环境变量
+            - 某些脚本可能需要较长时间运行，请耐心等待
+            - 如果运行超过30分钟，进程将自动终止
+            - 您输入的问题将替换脚本中的默认问题，确保问题与所选模型兼容
+            """
+        )
+
+    return app
+
+
+if __name__ == "__main__":
+    # 创建并启动应用
+    app = create_ui()
+    app.queue().launch(share=True)

owl/run.py

@@ -0,0 +1,138 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from dotenv import load_dotenv
+from camel.models import ModelFactory
+from camel.toolkits import (
+    AudioAnalysisToolkit,
+    CodeExecutionToolkit,
+    ExcelToolkit,
+    ImageAnalysisToolkit,
+    SearchToolkit,
+    VideoAnalysisToolkit,
+    WebToolkit,
+)
+from camel.types import ModelPlatformType, ModelType
+from camel.logger import set_log_level
+
+from utils import OwlRolePlaying, run_society, DocumentProcessingToolkit
+
+load_dotenv()
+
+set_log_level(level="DEBUG")
+
+
+def construct_society(question: str) -> OwlRolePlaying:
+    r"""Construct a society of agents based on the given question.
+
+    Args:
+        question (str): The task or question to be addressed by the society.
+
+    Returns:
+        OwlRolePlaying: A configured society of agents ready to address the question.
+    """
+
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "video": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "image": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "document": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+    }
+
+    # Configure toolkits
+    tools = [
+        *WebToolkit(
+            headless=False,  # Set to True for headless mode (e.g., on remote servers)
+            web_agent_model=models["web"],
+            planning_agent_model=models["planning"],
+        ).get_tools(),
+        *VideoAnalysisToolkit(model=models["video"]).get_tools(),
+        *AudioAnalysisToolkit().get_tools(),  # This requires OpenAI Key
+        *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
+        *ImageAnalysisToolkit(model=models["image"]).get_tools(),
+        SearchToolkit().search_duckduckgo,
+        SearchToolkit().search_google,  # Comment this out if you don't have google search
+        SearchToolkit().search_wiki,
+        *ExcelToolkit().get_tools(),
+        *DocumentProcessingToolkit(model=models["document"]).get_tools(),
+    ]
+
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+
+    # Configure task parameters
+    task_kwargs = {
+        "task_prompt": question,
+        "with_task_specify": False,
+    }
+
+    # Create and return the society
+    society = OwlRolePlaying(
+        **task_kwargs,
+        user_role_name="user",
+        user_agent_kwargs=user_agent_kwargs,
+        assistant_role_name="assistant",
+        assistant_agent_kwargs=assistant_agent_kwargs,
+    )
+
+    return society
+
+
+def main():
+    r"""Main function to run the OWL system with an example question."""
+    # Example research question
+    question = "Navigate to Amazon.com and identify one product that is attractive to coders. Please provide me with the product name and price. No need to verify your answer."
+
+    # Construct and run the society
+    society = construct_society(question)
+    answer, chat_history, token_count = run_society(society)
+
+    # Output the result
+    print(f"\033[94mAnswer: {answer}\033[0m")
+
+
+if __name__ == "__main__":
+    main()

owl/run_deepseek_zh.py

@@ -0,0 +1,141 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+
+# To run this file, you need to configure the DeepSeek API key
+# You can obtain your API key from DeepSeek platform: https://platform.deepseek.com/api_keys
+# Set it as DEEPSEEK_API_KEY="your-api-key" in your .env file or add it to your environment variables
+
+
+from dotenv import load_dotenv
+
+
+from camel.models import ModelFactory
+from camel.toolkits import (
+    CodeExecutionToolkit,
+    ExcelToolkit,
+    SearchToolkit,
+)
+from camel.types import ModelPlatformType, ModelType
+
+
+from utils import OwlRolePlaying, run_society, DocumentProcessingToolkit
+
+from camel.logger import set_log_level
+
+set_log_level(level="DEBUG")
+
+load_dotenv()
+
+
+def construct_society(question: str) -> OwlRolePlaying:
+    r"""Construct a society of agents based on the given question.
+
+    Args:
+        question (str): The task or question to be addressed by the society.
+
+    Returns:
+        OwlRolePlaying: A configured society of agents ready to address the question.
+    """
+
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "video": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "image": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+        "document": ModelFactory.create(
+            model_platform=ModelPlatformType.DEEPSEEK,
+            model_type=ModelType.DEEPSEEK_CHAT,
+            model_config_dict={"temperature": 0},
+        ),
+    }
+
+    # Configure toolkits
+    tools = [
+        *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
+        SearchToolkit().search_duckduckgo,
+        SearchToolkit().search_wiki,
+        *ExcelToolkit().get_tools(),
+        *DocumentProcessingToolkit(model=models["document"]).get_tools(),
+    ]
+
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+
+    # Configure task parameters
+    task_kwargs = {
+        "task_prompt": question,
+        "with_task_specify": False,
+    }
+
+    # Create and return the society
+    society = OwlRolePlaying(
+        **task_kwargs,
+        user_role_name="user",
+        user_agent_kwargs=user_agent_kwargs,
+        assistant_role_name="assistant",
+        assistant_agent_kwargs=assistant_agent_kwargs,
+        output_language="Chinese",
+    )
+
+    return society
+
+
+def main():
+    r"""Main function to run the OWL system with an example question."""
+    # Example research question
+    question = (
+        "请分析GitHub上CAMEL-AI项目的最新统计数据。找出该项目的星标数量、"
+        "贡献者数量和最近的活跃度。然后，创建一个简单的Excel表格来展示这些数据，"
+        "并生成一个柱状图来可视化这些指标。最后，总结CAMEL项目的受欢迎程度和发展趋势。"
+    )
+
+    # Construct and run the society
+    society = construct_society(question)
+    answer, chat_history, token_count = run_society(society)
+
+    # Output the result
+    print(f"\033[94mAnswer: {answer}\033[0m")
+
+
+if __name__ == "__main__":
+    main()

owl/run_gaia_roleplaying.py

@@ -0,0 +1,135 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from dotenv import load_dotenv
+
+
+import os
+
+from camel.models import ModelFactory
+from camel.logger import get_logger
+from camel.toolkits import (
+    AudioAnalysisToolkit,
+    CodeExecutionToolkit,
+    ExcelToolkit,
+    ImageAnalysisToolkit,
+    SearchToolkit,
+    VideoAnalysisToolkit,
+    WebToolkit,
+)
+from camel.types import ModelPlatformType, ModelType
+from camel.configs import ChatGPTConfig
+
+from utils import GAIABenchmark
+from camel.logger import set_log_level
+
+set_log_level(level="DEBUG")
+
+load_dotenv()
+
+logger = get_logger(__name__)
+
+# Configuration
+LEVEL = 1
+SAVE_RESULT = True
+test_idx = [0]
+
+
+def main():
+    """Main function to run the GAIA benchmark."""
+    # Create cache directory
+    cache_dir = "tmp/"
+    os.makedirs(cache_dir, exist_ok=True)
+
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+        "video": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+        "image": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict=ChatGPTConfig(temperature=0, top_p=1).as_dict(),
+        ),
+    }
+
+    # Configure toolkits
+    tools = [
+        *WebToolkit(
+            headless=False,  # Set to True for headless mode (e.g., on remote servers)
+            web_agent_model=models["web"],
+            planning_agent_model=models["planning"],
+        ).get_tools(),
+        *VideoAnalysisToolkit(
+            model=models["video"]
+        ).get_tools(),  # This requires OpenAI Key
+        *AudioAnalysisToolkit().get_tools(),  # This requires OpenAI Key
+        *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
+        *ImageAnalysisToolkit(model=models["image"]).get_tools(),
+        *SearchToolkit().get_tools(),
+        *ExcelToolkit().get_tools(),
+    ]
+
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+
+    # Initialize benchmark
+    benchmark = GAIABenchmark(data_dir="data/gaia", save_to="results/result.json")
+
+    # Print benchmark information
+    print(f"Number of validation examples: {len(benchmark.valid)}")
+    print(f"Number of test examples: {len(benchmark.test)}")
+
+    # Run benchmark
+    result = benchmark.run(
+        on="valid",
+        level=LEVEL,
+        idx=test_idx,
+        save_result=SAVE_RESULT,
+        user_role_name="user",
+        user_agent_kwargs=user_agent_kwargs,
+        assistant_role_name="assistant",
+        assistant_agent_kwargs=assistant_agent_kwargs,
+    )
+
+    # Output results
+    logger.success(f"Correct: {result['correct']}, Total: {result['total']}")
+    logger.success(f"Accuracy: {result['accuracy']}")
+
+
+if __name__ == "__main__":
+    main()

owl/run_mini.py

@@ -0,0 +1,112 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from dotenv import load_dotenv
+
+from camel.models import ModelFactory
+from camel.toolkits import (
+    SearchToolkit,
+    WebToolkit,
+)
+from camel.types import ModelPlatformType, ModelType
+from camel.logger import set_log_level
+
+from utils import OwlRolePlaying, run_society
+
+load_dotenv()
+set_log_level(level="DEBUG")
+
+
+def construct_society(question: str) -> OwlRolePlaying:
+    r"""Construct a society of agents based on the given question.
+
+    Args:
+        question (str): The task or question to be addressed by the society.
+
+    Returns:
+        OwlRolePlaying: A configured society of agents ready to address the
+            question.
+    """
+
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI,
+            model_type=ModelType.GPT_4O,
+            model_config_dict={"temperature": 0},
+        ),
+    }
+
+    # Configure toolkits
+    tools = [
+        *WebToolkit(
+            headless=False,  # Set to True for headless mode (e.g., on remote servers)
+            web_agent_model=models["web"],
+            planning_agent_model=models["planning"],
+        ).get_tools(),
+        SearchToolkit().search_duckduckgo,
+        SearchToolkit().search_wiki,
+    ]
+
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+
+    # Configure task parameters
+    task_kwargs = {
+        "task_prompt": question,
+        "with_task_specify": False,
+    }
+
+    # Create and return the society
+    society = OwlRolePlaying(
+        **task_kwargs,
+        user_role_name="user",
+        user_agent_kwargs=user_agent_kwargs,
+        assistant_role_name="assistant",
+        assistant_agent_kwargs=assistant_agent_kwargs,
+    )
+
+    return society
+
+
+def main():
+    r"""Main function to run the OWL system with an example question."""
+    # Example research question
+    question = "Navigate to Amazon.com and identify one product that is attractive to coders. Please provide me with the product name and price. No need to verify your answer."
+
+    # Construct and run the society
+    society = construct_society(question)
+    answer, chat_history, token_count = run_society(society)
+
+    # Output the result
+    print(f"\033[94mAnswer: {answer}\033[0m")
+
+
+if __name__ == "__main__":
+    main()

owl/run_openai_compatiable_model.py

@@ -0,0 +1,136 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import os
+
+from dotenv import load_dotenv
+from camel.models import ModelFactory
+from camel.toolkits import (
+    CodeExecutionToolkit,
+    ExcelToolkit,
+    ImageAnalysisToolkit,
+    SearchToolkit,
+    WebToolkit,
+)
+from camel.types import ModelPlatformType
+
+from utils import OwlRolePlaying, run_society
+
+from camel.logger import set_log_level
+
+set_log_level(level="DEBUG")
+
+load_dotenv()
+
+
+def construct_society(question: str) -> OwlRolePlaying:
+    r"""Construct a society of agents based on the given question.
+
+    Args:
+        question (str): The task or question to be addressed by the society.
+
+    Returns:
+        OwlRolePlaying: A configured society of agents ready to address the question.
+    """
+
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
+            model_type="qwen-max",
+            api_key=os.getenv("QWEN_API_KEY"),
+            url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            model_config_dict={"temperature": 0.4, "max_tokens": 4096},
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
+            model_type="qwen-max",
+            api_key=os.getenv("QWEN_API_KEY"),
+            url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            model_config_dict={"temperature": 0.4, "max_tokens": 4096},
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
+            model_type="qwen-vl-max",
+            api_key=os.getenv("QWEN_API_KEY"),
+            url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            model_config_dict={"temperature": 0.4, "max_tokens": 4096},
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
+            model_type="qwen-max",
+            api_key=os.getenv("QWEN_API_KEY"),
+            url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            model_config_dict={"temperature": 0.4, "max_tokens": 4096},
+        ),
+        "image": ModelFactory.create(
+            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
+            model_type="qwen-vl-max",
+            api_key=os.getenv("QWEN_API_KEY"),
+            url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+            model_config_dict={"temperature": 0.4, "max_tokens": 4096},
+        ),
+    }
+
+    # Configure toolkits
+    tools = [
+        *WebToolkit(
+            headless=False,  # Set to True for headless mode (e.g., on remote servers)
+            web_agent_model=models["web"],
+            planning_agent_model=models["planning"],
+        ).get_tools(),
+        *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
+        *ImageAnalysisToolkit(model=models["image"]).get_tools(),
+        SearchToolkit().search_duckduckgo,
+        SearchToolkit().search_google,  # Comment this out if you don't have google search
+        SearchToolkit().search_wiki,
+        *ExcelToolkit().get_tools(),
+    ]
+
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+
+    # Configure task parameters
+    task_kwargs = {
+        "task_prompt": question,
+        "with_task_specify": False,
+    }
+
+    # Create and return the society
+    society = OwlRolePlaying(
+        **task_kwargs,
+        user_role_name="user",
+        user_agent_kwargs=user_agent_kwargs,
+        assistant_role_name="assistant",
+        assistant_agent_kwargs=assistant_agent_kwargs,
+    )
+
+    return society
+
+
+def main():
+    r"""Main function to run the OWL system with an example question."""
+    # Example research question
+    question = "Navigate to Amazon.com and identify one product that is attractive to coders. Please provide me with the product name and price. No need to verify your answer."
+
+    # Construct and run the society
+    society = construct_society(question)
+    answer, chat_history, token_count = run_society(society)
+
+    # Output the result
+    print(f"\033[94mAnswer: {answer}\033[0m")
+
+
+if __name__ == "__main__":
+    main()

owl/run_qwen_mini_zh.py

@@ -0,0 +1,102 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+# To run this file, you need to configure the Qwen API key
+# You can obtain your API key from Bailian platform: bailian.console.aliyun.com
+# Set it as QWEN_API_KEY="your-api-key" in your .env file or add it to your environment variables
+
+from dotenv import load_dotenv
+
+from camel.models import ModelFactory
+from camel.toolkits import WebToolkit, SearchToolkit
+from camel.types import ModelPlatformType, ModelType
+
+from utils import OwlRolePlaying, run_society
+
+from camel.logger import set_log_level
+
+set_log_level(level="DEBUG")
+
+load_dotenv()
+
+
+def construct_society(question: str) -> OwlRolePlaying:
+    r"""Construct the society based on the question."""
+
+    user_role_name = "user"
+    assistant_role_name = "assistant"
+
+    user_model = ModelFactory.create(
+        model_platform=ModelPlatformType.QWEN,
+        model_type=ModelType.QWEN_VL_MAX,
+        model_config_dict={"temperature": 0},
+    )
+
+    assistant_model = ModelFactory.create(
+        model_platform=ModelPlatformType.QWEN,
+        model_type=ModelType.QWEN_VL_MAX,
+        model_config_dict={"temperature": 0},
+    )
+
+    planning_model = ModelFactory.create(
+        model_platform=ModelPlatformType.QWEN,
+        model_type=ModelType.QWEN_VL_MAX,
+        model_config_dict={"temperature": 0},
+    )
+
+    web_model = ModelFactory.create(
+        model_platform=ModelPlatformType.QWEN,
+        model_type=ModelType.QWEN_VL_MAX,
+        model_config_dict={"temperature": 0},
+    )
+
+    tools_list = [
+        *WebToolkit(
+            headless=False,
+            web_agent_model=web_model,
+            planning_agent_model=planning_model,
+            output_language="Chinese",
+        ).get_tools(),
+        SearchToolkit().search_duckduckgo,
+    ]
+
+    user_role_name = "user"
+    user_agent_kwargs = dict(model=user_model)
+    assistant_role_name = "assistant"
+    assistant_agent_kwargs = dict(model=assistant_model, tools=tools_list)
+
+    task_kwargs = {
+        "task_prompt": question,
+        "with_task_specify": False,
+    }
+
+    society = OwlRolePlaying(
+        **task_kwargs,
+        user_role_name=user_role_name,
+        user_agent_kwargs=user_agent_kwargs,
+        assistant_role_name=assistant_role_name,
+        assistant_agent_kwargs=assistant_agent_kwargs,
+        output_language="Chinese",
+    )
+
+    return society
+
+
+# Example case
+question = "浏览亚马逊并找出一款对程序员有吸引力的产品。请提供产品名称和价格"
+
+society = construct_society(question)
+answer, chat_history, token_count = run_society(society)
+
+print(f"\033[94mAnswer: {answer}\033[0m")

owl/run_qwen_zh.py

@@ -0,0 +1,145 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+# To run this file, you need to configure the Qwen API key
+# You can obtain your API key from Bailian platform: bailian.console.aliyun.com
+# Set it as QWEN_API_KEY="your-api-key" in your .env file or add it to your environment variables
+
+from dotenv import load_dotenv
+from camel.models import ModelFactory
+from camel.toolkits import (
+    CodeExecutionToolkit,
+    ExcelToolkit,
+    ImageAnalysisToolkit,
+    SearchToolkit,
+    VideoAnalysisToolkit,
+    WebToolkit,
+)
+from camel.types import ModelPlatformType, ModelType
+
+from utils import OwlRolePlaying, run_society, DocumentProcessingToolkit
+
+from camel.logger import set_log_level
+
+set_log_level(level="DEBUG")
+
+load_dotenv()
+
+
+def construct_society(question: str) -> OwlRolePlaying:
+    """
+    Construct a society of agents based on the given question.
+
+    Args:
+        question (str): The task or question to be addressed by the society.
+
+    Returns:
+        OwlRolePlaying: A configured society of agents ready to address the question.
+    """
+
+    # Create models for different components
+    models = {
+        "user": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_VL_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "assistant": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_VL_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "web": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_VL_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "planning": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_VL_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "video": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_VL_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "image": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_VL_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+        "document": ModelFactory.create(
+            model_platform=ModelPlatformType.QWEN,
+            model_type=ModelType.QWEN_VL_MAX,
+            model_config_dict={"temperature": 0},
+        ),
+    }
+
+    # Configure toolkits
+    tools = [
+        *WebToolkit(
+            headless=False,  # Set to True for headless mode (e.g., on remote servers)
+            web_agent_model=models["web"],
+            planning_agent_model=models["planning"],
+            output_language="Chinese",
+        ).get_tools(),
+        *VideoAnalysisToolkit(model=models["video"]).get_tools(),
+        *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
+        *ImageAnalysisToolkit(model=models["image"]).get_tools(),
+        SearchToolkit().search_duckduckgo,
+        SearchToolkit().search_google,  # Comment this out if you don't have google search
+        SearchToolkit().search_wiki,
+        *ExcelToolkit().get_tools(),
+        *DocumentProcessingToolkit(model=models["document"]).get_tools(),
+    ]
+
+    # Configure agent roles and parameters
+    user_agent_kwargs = {"model": models["user"]}
+    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+
+    # Configure task parameters
+    task_kwargs = {
+        "task_prompt": question,
+        "with_task_specify": False,
+    }
+
+    # Create and return the society
+    society = OwlRolePlaying(
+        **task_kwargs,
+        user_role_name="user",
+        user_agent_kwargs=user_agent_kwargs,
+        assistant_role_name="assistant",
+        assistant_agent_kwargs=assistant_agent_kwargs,
+        output_language="Chinese",
+    )
+
+    return society
+
+
+def main():
+    r"""Main function to run the OWL system with an example question."""
+    # Example research question
+    question = "浏览亚马逊并找出一款对程序员有吸引力的产品。请提供产品名称和价格"
+
+    # Construct and run the society
+    society = construct_society(question)
+    answer, chat_history, token_count = run_society(society)
+
+    # Output the result
+    print(f"\033[94mAnswer: {answer}\033[0m")
+
+
+if __name__ == "__main__":
+    main()

owl/script_adapter.py

@@ -0,0 +1,263 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import os
+import sys
+import importlib.util
+import re
+from pathlib import Path
+import traceback
+
+
+def load_module_from_path(module_name, file_path):
+    """从文件路径加载Python模块"""
+    try:
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        if spec is None:
+            print(f"错误: 无法从 {file_path} 创建模块规范")
+            return None
+
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        spec.loader.exec_module(module)
+        return module
+    except Exception as e:
+        print(f"加载模块时出错: {e}")
+        traceback.print_exc()
+        return None
+
+
+def run_script_with_env_question(script_name):
+    """使用环境变量中的问题运行脚本"""
+    # 获取环境变量中的问题
+    question = os.environ.get("OWL_QUESTION")
+    if not question:
+        print("错误: 未设置OWL_QUESTION环境变量")
+        sys.exit(1)
+
+    # 脚本路径
+    script_path = Path(script_name).resolve()
+    if not script_path.exists():
+        print(f"错误: 脚本 {script_path} 不存在")
+        sys.exit(1)
+
+    # 创建临时文件路径
+    temp_script_path = script_path.with_name(f"temp_{script_path.name}")
+
+    try:
+        # 读取脚本内容
+        try:
+            with open(script_path, "r", encoding="utf-8") as f:
+                content = f.read()
+        except Exception as e:
+            print(f"读取脚本文件时出错: {e}")
+            sys.exit(1)
+
+        # 检查脚本是否有main函数
+        has_main = re.search(r"def\s+main\s*\(\s*\)\s*:", content) is not None
+
+        # 转义问题中的特殊字符
+        escaped_question = (
+            question.replace("\\", "\\\\").replace('"', '\\"').replace("'", "\\'")
+        )
+
+        # 查找脚本中所有的question赋值 - 改进的正则表达式
+        # 匹配单行和多行字符串赋值
+        question_assignments = re.findall(
+            r'question\s*=\s*(?:["\'].*?["\']|""".*?"""|\'\'\'.*?\'\'\'|\(.*?\))',
+            content,
+            re.DOTALL,
+        )
+        print(f"在脚本中找到 {len(question_assignments)} 个question赋值")
+
+        # 修改脚本内容，替换所有的question赋值
+        modified_content = content
+
+        # 如果脚本中有question赋值，替换所有的赋值
+        if question_assignments:
+            for assignment in question_assignments:
+                modified_content = modified_content.replace(
+                    assignment, f'question = "{escaped_question}"'
+                )
+            print(f"已替换脚本中的所有question赋值为: {question}")
+        else:
+            # 如果没有找到question赋值，尝试在main函数前插入
+            if has_main:
+                main_match = re.search(r"def\s+main\s*\(\s*\)\s*:", content)
+                if main_match:
+                    insert_pos = main_match.start()
+                    modified_content = (
+                        content[:insert_pos]
+                        + f'\n# 用户输入的问题\nquestion = "{escaped_question}"\n\n'
+                        + content[insert_pos:]
+                    )
+                    print(f"已在main函数前插入问题: {question}")
+            else:
+                # 如果没有main函数，在文件开头插入
+                modified_content = (
+                    f'# 用户输入的问题\nquestion = "{escaped_question}"\n\n' + content
+                )
+                print(f"已在文件开头插入问题: {question}")
+
+        # 添加monkey patch代码，确保construct_society函数使用用户的问题
+        monkey_patch_code = f"""
+# 确保construct_society函数使用用户的问题
+original_construct_society = globals().get('construct_society')
+if original_construct_society:
+    def patched_construct_society(*args, **kwargs):
+        # 忽略传入的参数，始终使用用户的问题
+        return original_construct_society("{escaped_question}")
+    
+    # 替换原始函数
+    globals()['construct_society'] = patched_construct_society
+    print("已修补construct_society函数，确保使用用户问题")
+"""
+
+        # 在文件末尾添加monkey patch代码
+        modified_content += monkey_patch_code
+
+        # 如果脚本没有调用main函数，添加调用代码
+        if has_main and "__main__" not in content:
+            modified_content += """
+
+# 确保调用main函数
+if __name__ == "__main__":
+    main()
+"""
+            print("已添加main函数调用代码")
+
+        # 如果脚本没有construct_society调用，添加调用代码
+        if (
+            "construct_society" in content
+            and "run_society" in content
+            and "Answer:" not in content
+        ):
+            modified_content += f"""
+
+# 确保执行construct_society和run_society
+if "construct_society" in globals() and "run_society" in globals():
+    try:
+        society = construct_society("{escaped_question}")
+        from utils import run_society
+        answer, chat_history, token_count = run_society(society)
+        print(f"Answer: {{answer}}")
+    except Exception as e:
+        print(f"运行时出错: {{e}}")
+        import traceback
+        traceback.print_exc()
+"""
+            print("已添加construct_society和run_society调用代码")
+
+        # 执行修改后的脚本
+        try:
+            # 将脚本目录添加到sys.path
+            script_dir = script_path.parent
+            if str(script_dir) not in sys.path:
+                sys.path.insert(0, str(script_dir))
+
+            # 创建临时文件
+            try:
+                with open(temp_script_path, "w", encoding="utf-8") as f:
+                    f.write(modified_content)
+                print(f"已创建临时脚本文件: {temp_script_path}")
+            except Exception as e:
+                print(f"创建临时脚本文件时出错: {e}")
+                sys.exit(1)
+
+            try:
+                # 直接执行临时脚本
+                print("开始执行脚本...")
+
+                # 如果有main函数，加载模块并调用main
+                if has_main:
+                    # 加载临时模块
+                    module_name = f"temp_{script_path.stem}"
+                    module = load_module_from_path(module_name, temp_script_path)
+
+                    if module is None:
+                        print(f"错误: 无法加载模块 {module_name}")
+                        sys.exit(1)
+
+                    # 确保模块中有question变量，并且值是用户输入的问题
+                    setattr(module, "question", question)
+
+                    # 如果模块中有construct_society函数，修补它
+                    if hasattr(module, "construct_society"):
+                        original_func = module.construct_society
+
+                        def patched_func(*args, **kwargs):
+                            return original_func(question)
+
+                        module.construct_society = patched_func
+                        print("已在模块级别修补construct_society函数")
+
+                    # 调用main函数
+                    if hasattr(module, "main"):
+                        print("调用main函数...")
+                        module.main()
+                    else:
+                        print(f"错误: 脚本 {script_path} 中没有main函数")
+                        sys.exit(1)
+                else:
+                    # 如果没有main函数，直接执行修改后的脚本
+                    print("直接执行脚本内容...")
+                    # 使用更安全的方式执行脚本
+                    with open(temp_script_path, "r", encoding="utf-8") as f:
+                        script_code = f.read()
+
+                    # 创建一个安全的全局命名空间
+                    safe_globals = {
+                        "__file__": str(temp_script_path),
+                        "__name__": "__main__",
+                    }
+                    # 添加内置函数
+                    safe_globals.update(
+                        {k: v for k, v in globals().items() if k in ["__builtins__"]}
+                    )
+
+                    # 执行脚本
+                    exec(script_code, safe_globals)
+
+            except Exception as e:
+                print(f"执行脚本时出错: {e}")
+                traceback.print_exc()
+                sys.exit(1)
+
+        except Exception as e:
+            print(f"处理脚本时出错: {e}")
+            traceback.print_exc()
+            sys.exit(1)
+
+    except Exception as e:
+        print(f"处理脚本时出错: {e}")
+        traceback.print_exc()
+        sys.exit(1)
+
+    finally:
+        # 删除临时文件
+        if temp_script_path.exists():
+            try:
+                temp_script_path.unlink()
+                print(f"已删除临时脚本文件: {temp_script_path}")
+            except Exception as e:
+                print(f"删除临时脚本文件时出错: {e}")
+
+
+if __name__ == "__main__":
+    # 检查命令行参数
+    if len(sys.argv) < 2:
+        print("用法: python script_adapter.py <script_path>")
+        sys.exit(1)
+
+    # 运行指定的脚本
+    run_script_with_env_question(sys.argv[1])

owl/utils/__init__.py

@@ -0,0 +1,27 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from .common import extract_pattern
+from .enhanced_role_playing import OwlRolePlaying, OwlGAIARolePlaying, run_society
+from .gaia import GAIABenchmark
+from .document_toolkit import DocumentProcessingToolkit
+
+__all__ = [
+    "extract_pattern",
+    "OwlRolePlaying",
+    "OwlGAIARolePlaying",
+    "run_society",
+    "GAIABenchmark",
+    "DocumentProcessingToolkit",
+]

owl/utils/common.py

@@ -0,0 +1,36 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import sys
+
+sys.path.append("../")
+
+import re
+from typing import Optional
+from camel.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def extract_pattern(content: str, pattern: str) -> Optional[str]:
+    try:
+        _pattern = rf"<{pattern}>(.*?)</{pattern}>"
+        match = re.search(_pattern, content, re.DOTALL)
+        if match:
+            text = match.group(1)
+            return text.strip()
+        else:
+            return None
+    except Exception as e:
+        logger.warning(f"Error extracting answer: {e}, current content: {content}")
+        return None

owl/utils/document_toolkit.py

@@ -0,0 +1,324 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.toolkits import ImageAnalysisToolkit, ExcelToolkit
+from camel.utils import retry_on_error
+from camel.logger import get_logger
+from camel.models import BaseModelBackend
+from docx2markdown._docx_to_markdown import docx_to_markdown
+from chunkr_ai import Chunkr
+import requests
+import mimetypes
+import json
+from typing import List, Optional, Tuple, Literal
+from urllib.parse import urlparse
+import os
+import subprocess
+import xmltodict
+import nest_asyncio
+
+nest_asyncio.apply()
+
+logger = get_logger(__name__)
+
+
+class DocumentProcessingToolkit(BaseToolkit):
+    r"""A class representing a toolkit for processing document and return the content of the document.
+
+    This class provides method for processing docx, pdf, pptx, etc. It cannot process excel files.
+    """
+
+    def __init__(
+        self, cache_dir: Optional[str] = None, model: Optional[BaseModelBackend] = None
+    ):
+        self.image_tool = ImageAnalysisToolkit(model=model)
+        # self.audio_tool = AudioAnalysisToolkit()
+        self.excel_tool = ExcelToolkit()
+
+        self.cache_dir = "tmp/"
+        if cache_dir:
+            self.cache_dir = cache_dir
+
+    @retry_on_error()
+    def extract_document_content(self, document_path: str) -> Tuple[bool, str]:
+        r"""Extract the content of a given document (or url) and return the processed text.
+        It may filter out some information, resulting in inaccurate content.
+
+        Args:
+            document_path (str): The path of the document to be processed, either a local path or a URL. It can process image, audio files, zip files and webpages, etc.
+
+        Returns:
+            Tuple[bool, str]: A tuple containing a boolean indicating whether the document was processed successfully, and the content of the document (if success).
+        """
+        import asyncio
+
+        logger.debug(
+            f"Calling extract_document_content function with document_path=`{document_path}`"
+        )
+
+        if any(document_path.endswith(ext) for ext in [".jpg", ".jpeg", ".png"]):
+            res = self.image_tool.ask_question_about_image(
+                document_path, "Please make a detailed caption about the image."
+            )
+            return True, res
+
+        # if any(document_path.endswith(ext) for ext in ['.mp3', '.wav']):
+        #     res = self.audio_tool.ask_question_about_audio(document_path, "Please transcribe the audio content to text.")
+        #     return True, res
+
+        if any(document_path.endswith(ext) for ext in ["xls", "xlsx"]):
+            res = self.excel_tool.extract_excel_content(document_path)
+            return True, res
+
+        if any(document_path.endswith(ext) for ext in ["zip"]):
+            extracted_files = self._unzip_file(document_path)
+            return True, f"The extracted files are: {extracted_files}"
+
+        if any(document_path.endswith(ext) for ext in ["json", "jsonl", "jsonld"]):
+            with open(document_path, "r", encoding="utf-8") as f:
+                content = json.load(f)
+            f.close()
+            return True, content
+
+        if any(document_path.endswith(ext) for ext in ["py"]):
+            with open(document_path, "r", encoding="utf-8") as f:
+                content = f.read()
+            f.close()
+            return True, content
+
+        if any(document_path.endswith(ext) for ext in ["xml"]):
+            data = None
+            with open(document_path, "r", encoding="utf-8") as f:
+                content = f.read()
+            f.close()
+
+            try:
+                data = xmltodict.parse(content)
+                logger.debug(f"The extracted xml data is: {data}")
+                return True, data
+
+            except Exception:
+                logger.debug(f"The raw xml data is: {content}")
+                return True, content
+
+        if self._is_webpage(document_path):
+            extracted_text = self._extract_webpage_content(document_path)
+            return True, extracted_text
+
+        else:
+            # judge if url
+            parsed_url = urlparse(document_path)
+            is_url = all([parsed_url.scheme, parsed_url.netloc])
+            if not is_url:
+                if not os.path.exists(document_path):
+                    return False, f"Document not found at path: {document_path}."
+
+            # if is docx file, use docx2markdown to convert it
+            if document_path.endswith(".docx"):
+                if is_url:
+                    tmp_path = self._download_file(document_path)
+                else:
+                    tmp_path = document_path
+
+                file_name = os.path.basename(tmp_path)
+                md_file_path = f"{file_name}.md"
+                docx_to_markdown(tmp_path, md_file_path)
+
+                # load content of md file
+                with open(md_file_path, "r") as f:
+                    extracted_text = f.read()
+                f.close()
+                return True, extracted_text
+            try:
+                result = asyncio.run(self._extract_content_with_chunkr(document_path))
+                raise ValueError("Chunkr is not available.")
+                return True, result
+
+            except Exception as e:
+                logger.warning(
+                    f"Error occurred while using chunkr to process document: {e}"
+                )
+                if document_path.endswith(".pdf"):
+                    # try using pypdf to extract text from pdf
+                    try:
+                        from PyPDF2 import PdfReader
+
+                        if is_url:
+                            tmp_path = self._download_file(document_path)
+                            document_path = tmp_path
+
+                        # Open file in binary mode for PdfReader
+                        f = open(document_path, "rb")
+                        reader = PdfReader(f)
+                        extracted_text = ""
+                        for page in reader.pages:
+                            extracted_text += page.extract_text()
+                        f.close()
+
+                        return True, extracted_text
+
+                    except Exception as pdf_error:
+                        logger.error(
+                            f"Error occurred while processing pdf: {pdf_error}"
+                        )
+                        return (
+                            False,
+                            f"Error occurred while processing pdf: {pdf_error}",
+                        )
+
+                # If we get here, either it's not a PDF or PDF processing failed
+                logger.error(f"Error occurred while processing document: {e}")
+                return False, f"Error occurred while processing document: {e}"
+
+    def _is_webpage(self, url: str) -> bool:
+        r"""Judge whether the given URL is a webpage."""
+        try:
+            parsed_url = urlparse(url)
+            is_url = all([parsed_url.scheme, parsed_url.netloc])
+            if not is_url:
+                return False
+
+            path = parsed_url.path
+            file_type, _ = mimetypes.guess_type(path)
+            if file_type is not None and "text/html" in file_type:
+                return True
+
+            response = requests.head(url, allow_redirects=True, timeout=10)
+            content_type = response.headers.get("Content-Type", "").lower()
+
+            if "text/html" in content_type:
+                return True
+            else:
+                return False
+
+        except requests.exceptions.RequestException as e:
+            # raise RuntimeError(f"Error while checking the URL: {e}")
+            logger.warning(f"Error while checking the URL: {e}")
+            return False
+
+        except TypeError:
+            return True
+
+    @retry_on_error()
+    async def _extract_content_with_chunkr(
+        self,
+        document_path: str,
+        output_format: Literal["json", "markdown"] = "markdown",
+    ) -> str:
+        chunkr = Chunkr(api_key=os.getenv("CHUNKR_API_KEY"))
+
+        result = await chunkr.upload(document_path)
+
+        # result = chunkr.upload(document_path)
+
+        if result.status == "Failed":
+            logger.error(
+                f"Error while processing document {document_path}: {result.message}"
+            )
+            return f"Error while processing document: {result.message}"
+
+        # extract document name
+        document_name = os.path.basename(document_path)
+        output_file_path: str
+
+        if output_format == "json":
+            output_file_path = f"{document_name}.json"
+            result.json(output_file_path)
+
+        elif output_format == "markdown":
+            output_file_path = f"{document_name}.md"
+            result.markdown(output_file_path)
+
+        else:
+            return "Invalid output format."
+
+        with open(output_file_path, "r") as f:
+            extracted_text = f.read()
+        f.close()
+        return extracted_text
+
+    @retry_on_error()
+    def _extract_webpage_content(self, url: str) -> str:
+        api_key = os.getenv("FIRECRAWL_API_KEY")
+        from firecrawl import FirecrawlApp
+
+        # Initialize the FirecrawlApp with your API key
+        app = FirecrawlApp(api_key=api_key)
+
+        data = app.crawl_url(
+            url, params={"limit": 1, "scrapeOptions": {"formats": ["markdown"]}}
+        )
+        logger.debug(f"Extractred data from {url}: {data}")
+        if len(data["data"]) == 0:
+            if data["success"]:
+                return "No content found on the webpage."
+            else:
+                return "Error while crawling the webpage."
+
+        return str(data["data"][0]["markdown"])
+
+    def _download_file(self, url: str):
+        r"""Download a file from a URL and save it to the cache directory."""
+        try:
+            response = requests.get(url, stream=True)
+            response.raise_for_status()
+            file_name = url.split("/")[-1]
+
+            file_path = os.path.join(self.cache_dir, file_name)
+
+            with open(file_path, "wb") as file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    file.write(chunk)
+
+            return file_path
+
+        except requests.exceptions.RequestException as e:
+            print(f"Error downloading the file: {e}")
+
+    def _get_formatted_time(self) -> str:
+        import time
+
+        return time.strftime("%m%d%H%M")
+
+    def _unzip_file(self, zip_path: str) -> List[str]:
+        if not zip_path.endswith(".zip"):
+            raise ValueError("Only .zip files are supported")
+
+        zip_name = os.path.splitext(os.path.basename(zip_path))[0]
+        extract_path = os.path.join(self.cache_dir, zip_name)
+        os.makedirs(extract_path, exist_ok=True)
+
+        try:
+            subprocess.run(["unzip", "-o", zip_path, "-d", extract_path], check=True)
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to unzip file: {e}")
+
+        extracted_files = []
+        for root, _, files in os.walk(extract_path):
+            for file in files:
+                extracted_files.append(os.path.join(root, file))
+
+        return extracted_files
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the functions in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects representing the functions in the toolkit.
+        """
+        return [
+            FunctionTool(self.extract_document_content),
+        ]  # Added closing triple quotes here

owl/utils/enhanced_role_playing.py

@@ -0,0 +1,431 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from typing import Dict, List, Optional, Tuple
+
+
+from camel.agents import ChatAgent
+from camel.responses import ChatAgentResponse
+from camel.messages.base import BaseMessage
+from camel.societies import RolePlaying
+from camel.logger import get_logger
+
+
+from copy import deepcopy
+
+logger = get_logger(__name__)
+
+
+class OwlRolePlaying(RolePlaying):
+    def __init__(self, **kwargs):
+        self.user_role_name = kwargs.get("user_role_name", "user")
+        self.assistant_role_name = kwargs.get("assistant_role_name", "assistant")
+
+        self.output_language = kwargs.get("output_language", None)
+
+        self.user_agent_kwargs: dict = kwargs.get("user_agent_kwargs", {})
+        self.assistant_agent_kwargs: dict = kwargs.get("assistant_agent_kwargs", {})
+
+        self.output_language = kwargs.get("output_language", None)
+
+        super().__init__(**kwargs)
+
+        init_user_sys_msg, init_assistant_sys_msg = self._construct_gaia_sys_msgs()
+
+        self.assistant_agent: ChatAgent
+        self.user_agent: ChatAgent
+        self.assistant_sys_msg: Optional[BaseMessage]
+        self.user_sys_msg: Optional[BaseMessage]
+
+        # self.is_reasoning_task = self._judge_if_reasoning_task(self.task_prompt)
+
+        # if self.is_reasoning_task:
+        #     logger.info("The task is judged as a reasoning or coding task. The assistant agent will use the reasoning model O3-MINI.")
+        # else:
+        #     logger.info("The assistant agent will use the default model.")
+
+        self._init_agents(
+            init_assistant_sys_msg,
+            init_user_sys_msg,
+            assistant_agent_kwargs=self.assistant_agent_kwargs,
+            user_agent_kwargs=self.user_agent_kwargs,
+            output_language=self.output_language,
+            # is_reasoning_task=self.is_reasoning_task
+        )
+
+    def _init_agents(
+        self,
+        init_assistant_sys_msg: BaseMessage,
+        init_user_sys_msg: BaseMessage,
+        assistant_agent_kwargs: Optional[Dict] = None,
+        user_agent_kwargs: Optional[Dict] = None,
+        output_language: Optional[str] = None,
+        is_reasoning_task: bool = False,
+    ) -> None:
+        r"""Initialize assistant and user agents with their system messages.
+
+        Args:
+            init_assistant_sys_msg (BaseMessage): Assistant agent's initial
+                system message.
+            init_user_sys_msg (BaseMessage): User agent's initial system
+                message.
+            assistant_agent_kwargs (Dict, optional): Additional arguments to
+                pass to the assistant agent. (default: :obj:`None`)
+            user_agent_kwargs (Dict, optional): Additional arguments to
+                pass to the user agent. (default: :obj:`None`)
+            output_language (str, optional): The language to be output by the
+                agents. (default: :obj:`None`)
+        """
+        if self.model is not None:
+            if assistant_agent_kwargs is None:
+                assistant_agent_kwargs = {"model": self.model}
+            elif "model" not in assistant_agent_kwargs:
+                assistant_agent_kwargs.update(dict(model=self.model))
+            if user_agent_kwargs is None:
+                user_agent_kwargs = {"model": self.model}
+            elif "model" not in user_agent_kwargs:
+                user_agent_kwargs.update(dict(model=self.model))
+
+        # # If the task is a reasoning task, the assistant agent should use the reasoning model O3-MINI
+        # if is_reasoning_task:
+        #     assistant_agent_kwargs['model'] = ModelFactory.create(
+        #         model_platform=ModelPlatformType.OPENAI,
+        #         model_type=ModelType.O3_MINI,
+        #     )
+
+        self.assistant_agent = ChatAgent(
+            init_assistant_sys_msg,
+            output_language=output_language,
+            **(assistant_agent_kwargs or {}),
+        )
+        self.assistant_sys_msg = self.assistant_agent.system_message
+
+        self.user_agent = ChatAgent(
+            init_user_sys_msg,
+            output_language=output_language,
+            **(user_agent_kwargs or {}),
+        )
+        self.user_sys_msg = self.user_agent.system_message
+
+    # def _judge_if_reasoning_task(self, question: str) -> bool:
+    #     r"""Judge if the question is a reasoning task."""
+
+    #     LLM = OpenAIModel(model_type=ModelType.O3_MINI)
+    #     prompt = f"""
+    #     Please judge whether the following question is a reasoning or coding task, which can be solved by reasoning without leveraging external resources, or is suitable for writing code to solve the task.
+    #     If it is a reasoning or coding task, please return only "yes".
+    #     If it is not a reasoning or coding task, please return only "no".
+    #     Note:
+    #     - If the question required some world knowledge to answer the question, please carefully judge it, because the model's own knowledge is often unreliable.
+    #     - If it is suitable for writing codes (e.g. process excel files, write simulation codes, etc.), in most cases, it can be considered as a coding task.
+    #     Question: <question>{question}</question>
+    #     """
+    #     messages = [{"role": "user", "content": prompt}]
+    #     resp = LLM.run(messages)
+    #     if 'yes' in resp.choices[0].message.content.lower():
+    #         return True
+    #     else:
+    #         return False
+
+    def _construct_gaia_sys_msgs(self):
+        user_system_prompt = f"""
+===== RULES OF USER =====
+Never forget you are a user and I am a assistant. Never flip roles! You will always instruct me. We share a common interest in collaborating to successfully complete a task.
+I must help you to complete a difficult task.
+You must instruct me based on my expertise and your needs to solve the task step by step. The format of your instruction is: `Instruction: [YOUR INSTRUCTION]`, where "Instruction" describes a sub-task or question.
+You must give me one instruction at a time.
+I must write a response that appropriately solves the requested instruction.
+You should instruct me not ask me questions.
+
+Please note that the task may be very complicated. Do not attempt to solve the task by single step. You must instruct me to find the answer step by step.
+Here are some tips that will help you to give more valuable instructions about our task to me:
+<tips>
+- I have various tools to use, such as search toolkit, web browser simulation toolkit, document relevant toolkit, code execution toolkit, etc. Thus, You must think how human will solve the task step-by-step, and give me instructions just like that. For example, one may first use google search to get some initial information and the target url, then retrieve the content of the url, or do some web browser interaction to find the answer.
+- Although the task is complex, the answer does exist. If you can’t find the answer using the current scheme, try to re-plan and use other ways to find the answer, e.g. using other tools or methods that can achieve similar results.
+- Always remind me to verify my final answer about the overall task. This work can be done by using multiple tools(e.g., screenshots, webpage analysis, etc.), or something else.
+- If I have written code, please remind me to run the code and get the result.
+- Search results typically do not provide precise answers. It is not likely to find the answer directly using search toolkit only, the search query should be concise and focuses on finding sources rather than direct answers, as it always need to use other tools to further process the url, e.g. interact with the webpage, extract webpage content, etc. 
+- If the question mentions youtube video, in most cases you have to process the content of the mentioned video.
+- For downloading files, you can either use the web browser simulation toolkit or write codes (for example, the github content can be downloaded via https://raw.githubusercontent.com/...).
+- Flexibly write codes to solve some problems, such as excel relevant tasks.
+</tips>
+
+Now, here is the overall task: <task>{self.task_prompt}</task>. Never forget our task!
+
+Now you must start to instruct me to solve the task step-by-step. Do not add anything else other than your instruction!
+Keep giving me instructions until you think the task is completed.
+When the task is completed, you must only reply with a single word <TASK_DONE>.
+Never say <TASK_DONE> unless my responses have solved your task.
+        """
+
+        assistant_system_prompt = f"""
+===== RULES OF ASSISTANT =====
+Never forget you are a assistant and I am a user. Never flip roles! Never instruct me! You have to utilize your available tools to solve the task I assigned.
+We share a common interest in collaborating to successfully complete a complex task.
+You must help me to complete the task.
+
+Here is our overall task: {self.task_prompt}. Never forget our task!
+
+I must instruct you based on your expertise and my needs to complete the task. An instruction is typically a sub-task or question.
+
+You must leverage your available tools, try your best to solve the problem, and explain your solutions.
+Unless I say the task is completed, you should always start with:
+Solution: [YOUR_SOLUTION]
+[YOUR_SOLUTION] should be specific, including detailed explanations and provide preferable detailed implementations and examples and lists for task-solving.
+
+Please note that our overall task may be very complicated. Here are some tips that may help you solve the task:
+<tips>
+- If one way fails to provide an answer, try other ways or methods. The answer does exists.
+- If the search snippet is unhelpful but the URL comes from an authoritative source, try visit the website for more details.  
+- When looking for specific numerical values (e.g., dollar amounts), prioritize reliable sources and avoid relying only on search snippets.  
+- When solving tasks that require web searches, check Wikipedia first before exploring other websites.  
+- When trying to solve math problems, you can try to write python code and use sympy library to solve the problem.
+- Always verify the accuracy of your final answers! Try cross-checking the answers by other ways. (e.g., screenshots, webpage analysis, etc.).  
+- Do not be overly confident in your own knowledge. Searching can provide a broader perspective and help validate existing knowledge.  
+- After writing codes, do not forget to run the code and get the result. If it encounters an error, try to debug it.
+- When a tool fails to run, or the code does not run correctly, never assume that it returns the correct result and continue to reason based on the assumption, because the assumed result cannot lead you to the correct answer. The right way is to think about the reason for the error and try again.
+- Search results typically do not provide precise answers. It is not likely to find the answer directly using search toolkit only, the search query should be concise and focuses on finding sources rather than direct answers, as it always need to use other tools to further process the url, e.g. interact with the webpage, extract webpage content, etc. 
+- For downloading files, you can either use the web browser simulation toolkit or write codes.
+</tips>
+
+        """
+
+        user_sys_msg = BaseMessage.make_user_message(
+            role_name=self.user_role_name, content=user_system_prompt
+        )
+
+        assistant_sys_msg = BaseMessage.make_assistant_message(
+            role_name=self.assistant_role_name, content=assistant_system_prompt
+        )
+
+        return user_sys_msg, assistant_sys_msg
+
+    def step(
+        self, assistant_msg: BaseMessage
+    ) -> Tuple[ChatAgentResponse, ChatAgentResponse]:
+        user_response = self.user_agent.step(assistant_msg)
+        if user_response.terminated or user_response.msgs is None:
+            return (
+                ChatAgentResponse(msgs=[], terminated=False, info={}),
+                ChatAgentResponse(
+                    msgs=[],
+                    terminated=user_response.terminated,
+                    info=user_response.info,
+                ),
+            )
+        user_msg = self._reduce_message_options(user_response.msgs)
+
+        modified_user_msg = deepcopy(user_msg)
+
+        if "TASK_DONE" not in user_msg.content:
+            modified_user_msg.content += f"""\n
+            Here are auxiliary information about the overall task, which may help you understand the intent of the current task:
+            <auxiliary_information>
+            {self.task_prompt}
+            </auxiliary_information>
+            If there are available tools and you want to call them, never say 'I will ...', but first call the tool and reply based on tool call's result, and tell me which tool you have called.
+            """
+
+        else:
+            # The task is done, and the assistant agent need to give the final answer about the original task
+            modified_user_msg.content += f"""\n
+            Now please make a final answer of the original task based on our conversation : <task>{self.task_prompt}</task>
+            """
+
+        # process assistant's response
+        assistant_response = self.assistant_agent.step(modified_user_msg)
+        if assistant_response.terminated or assistant_response.msgs is None:
+            return (
+                ChatAgentResponse(
+                    msgs=[],
+                    terminated=assistant_response.terminated,
+                    info=assistant_response.info,
+                ),
+                ChatAgentResponse(
+                    msgs=[user_msg], terminated=False, info=user_response.info
+                ),
+            )
+        assistant_msg = self._reduce_message_options(assistant_response.msgs)
+
+        modified_assistant_msg = deepcopy(assistant_msg)
+        if "TASK_DONE" not in user_msg.content:
+            modified_assistant_msg.content += f"""\n
+                Provide me with the next instruction and input (if needed) based on my response and our current task: <task>{self.task_prompt}</task>
+                Before producing the final answer, please check whether I have rechecked the final answer using different toolkit as much as possible. If not, please remind me to do that.
+                If I have written codes, remind me to run the codes.
+                If you think our task is done, reply with `TASK_DONE` to end our conversation.
+            """
+
+        # return the modified messages
+        return (
+            ChatAgentResponse(
+                msgs=[modified_assistant_msg],
+                terminated=assistant_response.terminated,
+                info=assistant_response.info,
+            ),
+            ChatAgentResponse(
+                msgs=[modified_user_msg],
+                terminated=user_response.terminated,
+                info=user_response.info,
+            ),
+        )
+
+
+class OwlGAIARolePlaying(OwlRolePlaying):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def step(
+        self, assistant_msg: BaseMessage
+    ) -> Tuple[ChatAgentResponse, ChatAgentResponse]:
+        user_response = self.user_agent.step(assistant_msg)
+        if user_response.terminated or user_response.msgs is None:
+            return (
+                ChatAgentResponse(msgs=[], terminated=False, info={}),
+                ChatAgentResponse(
+                    msgs=[],
+                    terminated=user_response.terminated,
+                    info=user_response.info,
+                ),
+            )
+        user_msg = self._reduce_message_options(user_response.msgs)
+        if (
+            "n" in self.user_agent.model_config_dict.keys()
+            and self.user_agent.model_config_dict["n"] > 1
+        ):
+            self.user_agent.record_message(user_msg)
+
+        modified_user_msg = deepcopy(user_msg)
+
+        if "TASK_DONE" not in user_msg.content:
+            modified_user_msg.content += f"""\n
+            Here are auxiliary information about the overall task, which may help you understand the intent of the current task:
+            <auxiliary_information>
+            {self.task_prompt}
+            </auxiliary_information>
+            If there are available tools and you want to call them, never say 'I will ...', but first call the tool and reply based on tool call's result, and tell me which tool you have called.
+            """
+
+        else:
+            # The task is done, and the assistant agent need to give the final answer about the original task
+            modified_user_msg.content += f"""\n
+            Now please make a final answer of the original task based on our conversation : <task>{self.task_prompt}</task>
+            Please pay special attention to the format in which the answer is presented.
+            You should first analyze the answer format required by the question and then output the final answer that meets the format requirements. 
+            Your response should include the following content:
+            - `analysis`: enclosed by <analysis> </analysis>, a detailed analysis of the reasoning result.
+            - `final_answer`: enclosed by <final_answer> </final_answer>, the final answer to the question.
+            Here are some hint about the final answer:
+            <hint>
+            Your final answer must be output exactly in the format specified by the question. It should be a number OR as few words as possible OR a comma separated list of numbers and/or strings:
+            - If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. 
+            - If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. 
+            - If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
+            </hint>
+            """
+
+        # process assistant's response
+        assistant_response = self.assistant_agent.step(modified_user_msg)
+        if assistant_response.terminated or assistant_response.msgs is None:
+            return (
+                ChatAgentResponse(
+                    msgs=[],
+                    terminated=assistant_response.terminated,
+                    info=assistant_response.info,
+                ),
+                ChatAgentResponse(
+                    msgs=[user_msg], terminated=False, info=user_response.info
+                ),
+            )
+        assistant_msg = self._reduce_message_options(assistant_response.msgs)
+
+        modified_assistant_msg = deepcopy(assistant_msg)
+        if "TASK_DONE" not in user_msg.content:
+            modified_assistant_msg.content += f"""\n
+                Provide me with the next instruction and input (if needed) based on my response and our current task: <task>{self.task_prompt}</task>
+                Before producing the final answer, please check whether I have rechecked the final answer using different toolkit as much as possible. If not, please remind me to do that.
+                If I have written codes, remind me to run the codes.
+                If you think our task is done, reply with `TASK_DONE` to end our conversation.
+            """
+
+        # return the modified messages
+        return (
+            ChatAgentResponse(
+                msgs=[modified_assistant_msg],
+                terminated=assistant_response.terminated,
+                info=assistant_response.info,
+            ),
+            ChatAgentResponse(
+                msgs=[modified_user_msg],
+                terminated=user_response.terminated,
+                info=user_response.info,
+            ),
+        )
+
+
+def run_society(
+    society: RolePlaying, round_limit: int = 15
+) -> Tuple[str, List[dict], dict]:
+    overall_completion_token_count = 0
+    overall_prompt_token_count = 0
+
+    chat_history = []
+    init_prompt = """
+Now please give me instructions to solve over overall task step by step. If the task requires some specific knowledge, please instruct me to use tools to complete the task.
+    """
+    input_msg = society.init_chat(init_prompt)
+    for _round in range(round_limit):
+        assistant_response, user_response = society.step(input_msg)
+        overall_completion_token_count += (
+            assistant_response.info["usage"]["completion_tokens"]
+            + user_response.info["usage"]["completion_tokens"]
+        )
+        overall_prompt_token_count += (
+            assistant_response.info["usage"]["prompt_tokens"]
+            + user_response.info["usage"]["prompt_tokens"]
+        )
+
+        # convert tool call to dict
+        tool_call_records: List[dict] = []
+        for tool_call in assistant_response.info["tool_calls"]:
+            tool_call_records.append(tool_call.as_dict())
+
+        _data = {
+            "user": user_response.msg.content,
+            "assistant": assistant_response.msg.content,
+            "tool_calls": tool_call_records,
+        }
+
+        chat_history.append(_data)
+        logger.info(f"Round #{_round} user_response:\n {user_response.msgs[0].content}")
+        logger.info(
+            f"Round #{_round} assistant_response:\n {assistant_response.msgs[0].content}"
+        )
+
+        if (
+            assistant_response.terminated
+            or user_response.terminated
+            or "TASK_DONE" in user_response.msg.content
+        ):
+            break
+
+        input_msg = assistant_response.msg
+
+    answer = chat_history[-1]["assistant"]
+    token_info = {
+        "completion_token_count": overall_completion_token_count,
+        "prompt_token_count": overall_prompt_token_count,
+    }
+
+    return answer, chat_history, token_info

owl/utils/gaia.py

@@ -0,0 +1,412 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import sys
+
+sys.path.append("../")
+
+import json
+import random
+import re
+import string
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Union, Tuple
+
+from tqdm import tqdm
+from camel.benchmarks import BaseBenchmark
+from camel.tasks import Task
+from camel.logger import get_logger
+
+from .common import extract_pattern
+from .enhanced_role_playing import run_society, OwlGAIARolePlaying
+
+logger = get_logger(__name__)
+
+
+class GAIABenchmark(BaseBenchmark):
+    r"""GAIA Benchmark adapted from `"GAIA: a benchmark for General AI
+    Assistants"
+    <https://huggingface.co/datasets/gaia-benchmark/GAIA>`_.
+
+    Args:
+        data_dir (str): The directory to save the data.
+        save_to (str): The file to save the results.
+        processes (int, optional): The number of processes to use.
+            (default: :obj:`1`)
+    """
+
+    def __init__(
+        self,
+        data_dir: str,
+        save_to: str,
+        processes: int = 1,
+    ):
+        r"""Initialize the GAIA benchmark.
+
+        Args:
+            data_dir (str): The directory to save the data.
+            save_to (str): The file to save the results.
+            processes (int, optional): The number of processes to use for
+                parallel processing. (default: :obj:`1`)
+        """
+        super().__init__("gaia", data_dir, save_to, processes)
+
+    def download(self):
+        r"""Download the GAIA dataset."""
+        from huggingface_hub import snapshot_download
+
+        snapshot_download(
+            repo_id="gaia-benchmark/GAIA",
+            repo_type="dataset",
+            local_dir=self.data_dir,
+            local_dir_use_symlinks=True,
+        )
+
+    def _check_task_completed(self, task_id: str) -> bool:
+        for data in self._results:
+            if data["task_id"] == task_id:
+                return True
+        return False
+
+    def dump_tasks(self, save_path: str, datas):
+        constructed_data = []
+        for idx, data in enumerate(datas):
+            tmp_dict = {
+                "idx": idx,
+                "task_id": data["task_id"],
+                "Question": data["Question"],
+                "Level": data["Level"],
+                "Final answer": data["Final answer"],
+                "Annotation Metadata": data["Annotator Metadata"],
+            }
+
+            constructed_data.append(tmp_dict)
+        with open(save_path, "w", encoding="utf-8") as f:
+            json.dump(constructed_data, f, indent=4)
+        f.close()
+
+        print(f"Successfully dumped tasks to {save_path}")
+
+    def load(self, force_download=False):
+        r"""Load the GAIA dataset.
+
+        Args:
+            force_download (bool, optional): Whether to
+                force download the data.
+        """
+        if force_download:
+            logger.info("Force downloading data.")
+            self.download()
+
+        # Define validation and test directories
+        valid_dir = self.data_dir / "2023/validation"
+        test_dir = self.data_dir / "2023/test"
+
+        # Check if directories exist; if not, download the data
+        if not valid_dir.is_dir() or not test_dir.is_dir():
+            logger.info("Data not found. Downloading data.")
+            self.download()
+
+        # Load metadata for both validation and test datasets
+        for path, label in zip([valid_dir, test_dir], ["valid", "test"]):
+            self._data[label] = []
+            with open(path / "metadata.jsonl", "r") as f:
+                lines = f.readlines()
+                for line in lines:
+                    data = json.loads(line)
+                    if data["task_id"] == "0-0-0-0-0":
+                        continue
+                    if data["file_name"]:
+                        data["file_name"] = path / data["file_name"]
+                    self._data[label].append(data)
+        return self
+
+    @property
+    def train(self):
+        r"""Get the training set."""
+        raise NotImplementedError("GAIA does not have a training set.")
+
+    def run(
+        self,
+        user_role_name: str,
+        assistant_role_name: str,
+        user_agent_kwargs: dict,
+        assistant_agent_kwargs: dict,
+        on: Literal["train", "valid", "test"],
+        level: Union[int, List[int], Literal["all"]],
+        randomize: bool = False,
+        subset: Optional[int] = None,
+        idx: Optional[List[int]] = None,
+        save_result: bool = False,
+    ) -> Dict[str, Any]:
+        # Validate inputs
+        if on not in ["valid", "test"]:
+            raise ValueError(
+                f"Invalid value for `on`: {on}, expected 'valid' or 'test'."
+            )
+
+        levels = (
+            [1, 2, 3]
+            if level == "all"
+            else [level]
+            if isinstance(level, int)
+            else level
+        )
+        if not all(isinstance(level, int) and level in [1, 2, 3] for level in levels):
+            raise ValueError(
+                f"Invalid value for `level`: {level}, expected 1, 2, 3 " "or 'all'."
+            )
+        logger.info(f"Running benchmark on {on} set at levels {levels}.")
+        datas = [data for data in self._data[on] if data["Level"] in levels]
+        # Shuffle and subset data if necessary
+        if randomize:
+            random.shuffle(datas)
+        if subset:
+            datas = datas[:subset]
+
+        if idx is not None:
+            # pick only the tasks with the specified idx
+            if len(idx) != 0:
+                datas = [datas[i] for i in idx]
+
+        logger.info(f"Number of tasks: {len(datas)}")
+
+        self._results = []
+
+        if save_result:
+            try:
+                with open(self.save_to, "r", encoding="utf-8") as f:
+                    self._results = json.load(f)
+                f.close()
+            except Exception as e:
+                logger.warning(e)
+                # raise FileNotFoundError(f"{self.save_to} does not exist.")
+
+        # Process tasks
+        for task in tqdm(datas, desc="Running"):
+            if self._check_task_completed(task["task_id"]):
+                logger.success(
+                    f"The following task is already completed:\n task id: {task['task_id']}, question: {task['Question']}"
+                )
+                continue
+
+            if_prepared_task, info = self._prepare_task(task)
+            if not if_prepared_task:
+                _result_info = {
+                    "task_id": task["task_id"],
+                    "question": task["Question"],
+                    "level": task["Level"],
+                    "model_answer": None,
+                    "ground_truth": None,
+                    "score": 0,
+                    "history": None,
+                }
+                self._results.append(_result_info)
+                continue
+            try:
+                logger.info(f"Task Question: {task['Question']}")
+                logger.info(f"Required tools: {task['Annotator Metadata']['Tools']}")
+
+                task_kwargs = {
+                    "task_prompt": task["Question"],
+                    "with_task_specify": False,
+                }
+
+                society = OwlGAIARolePlaying(
+                    **task_kwargs,
+                    user_role_name=user_role_name,
+                    user_agent_kwargs=user_agent_kwargs,
+                    assistant_role_name=assistant_role_name,
+                    assistant_agent_kwargs=assistant_agent_kwargs,
+                )
+
+                raw_answer, chat_history, token_info = run_society(society)
+                try:
+                    answer = extract_pattern(raw_answer, "final_answer")
+                except Exception as e:
+                    logger.error(
+                        f"Error in extracting final answer from text {raw_answer}: {e}"
+                    )
+                    answer = None
+
+                logger.info(
+                    f"Model answer: {answer}, Ground truth: {task['Final answer']}"
+                )
+
+                _result_info = {
+                    "task_id": task["task_id"],
+                    "question": task["Question"]
+                    + "Please decompose the task into several sub-tasks and find the answer step-by-step.",
+                    "level": task["Level"],
+                    "model_answer": answer,
+                    "ground_truth": task["Final answer"],
+                    "score": self.question_scorer(answer, task["Final answer"]),
+                    "token_info": token_info,
+                    "history": chat_history,
+                }
+                self._results.append(_result_info)
+
+            except Exception as e:
+                logger.error(f"Error in processing task: {e}")
+
+            if save_result:
+                with open(self.save_to, "w") as f:
+                    json.dump(self._results, f, indent=4, ensure_ascii=False)
+                f.close()
+
+        return self._generate_summary()
+
+    def _prepare_task(self, task: Dict[str, Any]) -> Tuple[bool, str]:
+        r"""Prepare the task by validating and enriching its data."""
+        if task["file_name"]:
+            if isinstance(task["file_name"], Path):
+                task["file_name"] = str(task["file_name"])
+
+            file_path = Path(task["file_name"])
+            if not file_path.exists():
+                logger.info(f"Skipping task because file not found: {file_path}")
+                return False, f"Skipping task because file not found: {file_path}"
+            if file_path.suffix in [".pdf", ".docx", ".doc", ".txt"]:
+                task["Question"] += (
+                    f" Here are the necessary document files: {file_path}"
+                )
+
+            elif file_path.suffix in [".jpg", ".jpeg", ".png"]:
+                task["Question"] += f" Here are the necessary image files: {file_path}"
+
+            elif file_path.suffix in [".xlsx", "xls", ".csv"]:
+                task["Question"] += (
+                    f" Here are the necessary table files: {file_path}, for processing excel file, you can write python code and leverage excel toolkit to process the file step-by-step and get the information."
+                )
+
+            elif file_path.suffix in [".py"]:
+                task["Question"] += f" Here are the necessary python files: {file_path}"
+
+            else:
+                task["Question"] += f" Here are the necessary files: {file_path}"
+
+        return True, None
+
+    def _create_task(self, task: Dict[str, Any]) -> Task:
+        r"""Create a user message from a task.
+
+        Args:
+            task (Dict[str, Any]): The task to create the message from.
+
+        Returns:
+            Task: The task created from the input.
+        """
+        return Task(id=str(task["task_id"]), content=task["Question"])
+
+    def _generate_summary(self) -> Dict[str, Any]:
+        r"""Generate and return a summary of the benchmark results."""
+        correct = sum(result["score"] for result in self._results)
+        return {
+            "total": len(self._results),
+            "correct": correct,
+            "results": self._results,
+            "accuracy": correct / len(self._results) if len(self._results) > 0 else 0,
+        }
+
+    def question_scorer(self, model_answer: str, ground_truth: str) -> bool:
+        r"""Scorer for the GAIA benchmark.
+        https://huggingface.co/spaces/gaia-benchmark/leaderboard/blob/main/
+        scorer.py
+
+        Args:
+            model_answer (str): The model answer.
+            ground_truth (str): The ground truth answer.
+
+        Returns:
+            bool: The score of the model
+        """
+
+        def is_float(element: Any) -> bool:
+            try:
+                float(element)
+                return True
+            except ValueError:
+                return False
+
+        if is_float(ground_truth):
+            logger.info(f"Evaluating {model_answer} as a number.")
+            normalized_answer = self.normalize_number_str(model_answer)
+            return normalized_answer == float(ground_truth)
+
+        elif any(char in ground_truth for char in [",", ";"]):
+            logger.info(f"Evaluating {model_answer} as a comma separated list.")
+            gt_elems = self.split_string(ground_truth)
+            ma_elems = self.split_string(model_answer)
+
+            if len(gt_elems) != len(ma_elems):
+                logger.warning(
+                    "Answer lists have different lengths, returning False.",
+                    UserWarning,
+                )
+                return False
+
+            comparisons = []
+            for ma_elem, gt_elem in zip(ma_elems, gt_elems):
+                if is_float(gt_elem):
+                    normalized_ma_elem = self.normalize_number_str(ma_elem)
+                    comparisons.append(normalized_ma_elem == float(gt_elem))
+                else:
+                    ma_elem = self.normalize_str(ma_elem, remove_punct=False)
+                    gt_elem = self.normalize_str(gt_elem, remove_punct=False)
+                    comparisons.append(ma_elem == gt_elem)
+            return all(comparisons)
+        else:
+            logger.info(f"Evaluating {model_answer} as a string.")
+            ma_elem = self.normalize_str(model_answer)
+            gt_elem = self.normalize_str(ground_truth)
+            return ma_elem == gt_elem
+
+    def normalize_number_str(self, number_str: str) -> float:
+        for char in ["$", "%", ","]:
+            number_str = number_str.replace(char, "")
+        try:
+            return float(number_str)
+        except ValueError:
+            logger.error(f"String {number_str} cannot be normalized to number str.")
+            return float("inf")
+
+    def split_string(self, s: str, char_list: Optional[List[str]] = None) -> list[str]:
+        r"""Split a string based on a list of characters.
+
+        Args:
+            s (str): The string to split.
+            char_list (Optional[List[str]], optional): T
+                he list of characters to split on.
+                (default: :obj:`None`)
+        """
+        if char_list is None:
+            char_list = [",", ";"]
+        pattern = f"[{''.join(char_list)}]"
+        return re.split(pattern, s)
+
+    def normalize_str(self, input_str, remove_punct=True) -> str:
+        r"""Normalize a string.
+
+        Args:
+            input_str: The input string to normalize.
+            remove_punct: Whether to remove punctuation.
+
+        Returns:
+            str: The normalized string.
+        """
+        no_spaces = re.sub(r"\s", "", input_str)
+        if remove_punct:
+            translator = str.maketrans("", "", string.punctuation)
+            return no_spaces.lower().translate(translator)
+        else:
+            return no_spaces.lower()

pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "owl"
+version = "0.0.1"
+description = "Optimized Workforce Learning for General Multi-Agent Assistance in Real-World Task Automation"
+authors = [{ name = "CAMEL-AI.org" }]
+requires-python = ">=3.10,<3.13"
+readme = "README.md"
+license = "Apache-2.0"
+keywords = [
+    "optimized-workforce-learning",
+    "multi-agent-assistance",
+    "task-automation",
+    "real-world-tasks",
+    "artificial-intelligence",
+    "agent-collaboration",
+    "workforce-optimization",
+    "learning-systems"
+]
+dependencies = [
+    "camel-ai[all]==0.2.23",
+    "chunkr-ai>=0.0.41",
+    "docx2markdown>=0.1.1",
+    "gradio>=3.50.2",
+]
+
+[project.urls]
+Homepage = "https://www.camel-ai.org/"
+Repository = "https://github.com/camel-ai/owl"
+Documentation = "https://docs.camel-ai.org"
+
+[tool.hatch.build.targets.wheel]
+packages = ["owl"]
+
+[tool.mypy]
+python_version = "3.11"
+warn_return_any = false
+warn_unused_configs = true
+disallow_untyped_defs = false
+disallow_incomplete_defs = false
+check_untyped_defs = false
+disallow_untyped_decorators = false
+no_implicit_optional = false
+strict_optional = false
+ignore_missing_imports = true
+allow_redefinition = true
+disable_error_code = ["assignment", "arg-type", "return-value"]
+
+[[tool.mypy.overrides]]
+module = "camel.*"
+ignore_missing_imports = true
+follow_imports = "skip"
+
+[[tool.mypy.overrides]]
+module = "utils"
+ignore_missing_imports = true

requirements.txt

@@ -1 +1,4 @@
-huggingface_hub==0.25.2
+camel-ai[all]==0.2.23
+chunkr-ai>=0.0.41
+docx2markdown>=0.1.1
+gradio>=3.50.2

run_app.py

@@ -0,0 +1,60 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+OWL 智能助手运行平台启动脚本
+"""
+
+import os
+import sys
+from pathlib import Path
+
+
+def main():
+    """主函数，启动OWL智能助手运行平台"""
+    # 确保当前目录是项目根目录
+    project_root = Path(__file__).resolve().parent
+    os.chdir(project_root)
+
+    # 创建日志目录
+    log_dir = project_root / "logs"
+    log_dir.mkdir(exist_ok=True)
+
+    # 导入并运行应用
+    sys.path.insert(0, str(project_root))
+
+    try:
+        from owl.app import create_ui
+
+        # 创建并启动应用
+        app = create_ui()
+        app.queue().launch(share=True)
+
+    except ImportError as e:
+        print(f"错误: 无法导入必要的模块。请确保已安装所有依赖项: {e}")
+        print("提示: 运行 'pip install -r requirements.txt' 安装所有依赖项")
+        sys.exit(1)
+    except Exception as e:
+        print(f"启动应用程序时出错: {e}")
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
+

run_app.py.bak

@@ -0,0 +1,59 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# 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.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+OWL 智能助手运行平台启动脚本
+"""
+
+import os
+import sys
+from pathlib import Path
+
+
+def main():
+    """主函数，启动OWL智能助手运行平台"""
+    # 确保当前目录是项目根目录
+    project_root = Path(__file__).resolve().parent
+    os.chdir(project_root)
+
+    # 创建日志目录
+    log_dir = project_root / "logs"
+    log_dir.mkdir(exist_ok=True)
+
+    # 导入并运行应用
+    sys.path.insert(0, str(project_root))
+
+    try:
+        from owl.app import create_ui
+
+        # 创建并启动应用
+        app = create_ui()
+        app.queue().launch(share=True)
+
+    except ImportError as e:
+        print(f"错误: 无法导入必要的模块。请确保已安装所有依赖项: {e}")
+        print("提示: 运行 'pip install -r requirements.txt' 安装所有依赖项")
+        sys.exit(1)
+    except Exception as e:
+        print(f"启动应用程序时出错: {e}")
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()