Upload 302 files

.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/Dockerfile

@@ -0,0 +1,106 @@
+# 使用ARG定义可配置的构建参数
+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
+
+# 第一阶段：构建依赖
+FROM python:${PYTHON_VERSION}-slim AS builder
+
+# 设置工作目录
+WORKDIR /build
+
+# 设置pip镜像源以加速下载
+ARG PIP_INDEX_URL
+RUN pip config set global.index-url ${PIP_INDEX_URL}
+
+# 安装构建依赖
+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 requirements.txt .
+RUN pip install --no-cache-dir --prefix=/install -r requirements.txt
+
+# 第二阶段：运行时环境
+FROM python:${PYTHON_VERSION}-slim
+
+# 添加构建信息标签
+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"
+
+# 设置工作目录
+WORKDIR /app
+
+# 设置pip镜像源以加速下载
+ARG PIP_INDEX_URL
+RUN pip config set global.index-url ${PIP_INDEX_URL}
+
+# 从builder阶段复制已安装的Python包
+COPY --from=builder /install /usr/local
+
+# 优化apt安装，减少层数
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    git \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    # 添加xvfb和相关依赖
+    xvfb \
+    xauth \
+    x11-utils \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# 安装 Playwright 依赖（使用国内镜像源）
+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用户
+RUN groupadd -r owl && useradd -r -g owl -m owl
+
+# 复制项目文件
+COPY owl/ ./owl/
+COPY licenses/ ./licenses/
+COPY assets/ ./assets/
+COPY README.md .
+COPY README_zh.md .
+
+# 设置环境变量文件
+COPY owl/.env_template ./owl/.env
+
+# 创建启动脚本
+RUN echo '#!/bin/bash\nxvfb-run --auto-servernum --server-args="-screen 0 1280x960x24" python "$@"' > /usr/local/bin/xvfb-python && \
+    chmod +x /usr/local/bin/xvfb-python
+
+# 创建欢迎脚本
+RUN echo '#!/bin/bash\necho "欢迎使用OWL项目Docker环境！"\necho ""\necho "可用的脚本:"\nls -1 *.py | grep -v "__" | sed "s/^/- /"\necho ""\necho "运行示例:"\necho "  xvfb-python run.py                     # 运行默认脚本"\necho "  xvfb-python run_deepseek_example.py      # 运行DeepSeek示例"\necho ""\necho "或者使用自定义查询:"\necho "  xvfb-python run.py \"你的问题\""\necho ""' > /usr/local/bin/owl-welcome && \
+    chmod +x /usr/local/bin/owl-welcome
+
+# 设置工作目录
+WORKDIR /app/owl
+
+# 设置适当的权限
+RUN chown -R owl:owl /app
+RUN mkdir -p /root/.cache && chown -R owl:owl /root/.cache
+
+# 切换到非root用户
+# 注意：如果需要访问/dev/shm，可能仍需要root用户
+# USER owl
+
+# 添加健康检查
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import sys; sys.exit(0 if __import__('os').path.exists('/app/owl') else 1)"
+
+# 容器启动命令
+CMD ["/bin/bash", "-c", "owl-welcome && /bin/bash"] 

.container/build_docker.bat

@@ -0,0 +1,147 @@
+@echo off
+setlocal enabledelayedexpansion
+
+echo 在Windows上构建Docker镜像...
+
+REM 设置配置变量
+set CACHE_DIR=.docker-cache\pip
+set BUILD_ARGS=--build-arg BUILDKIT_INLINE_CACHE=1
+set COMPOSE_FILE=docker-compose.yml
+
+REM 解析命令行参数
+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 用法: build_docker.bat [选项]
+    echo 选项:
+    echo   --clean     清理缓存目录
+    echo   --rebuild   强制重新构建镜像
+    echo   --service   指定要构建的服务名称
+    echo   --help      显示此帮助信息
+    exit /b 0
+)
+shift
+goto :parse_args
+:end_parse_args
+
+REM 检查Docker是否安装
+where docker >nul 2>nul
+if %ERRORLEVEL% NEQ 0 (
+    echo 错误: Docker未安装
+    echo 请先安装Docker Desktop: https://docs.docker.com/desktop/install/windows-install/
+    pause
+    exit /b 1
+)
+
+REM 检查Docker是否运行
+docker info >nul 2>nul
+if %ERRORLEVEL% NEQ 0 (
+    echo 错误: Docker未运行
+    echo 请启动Docker Desktop应用程序
+    pause
+    exit /b 1
+)
+
+REM 检查docker-compose.yml文件是否存在
+if not exist "%COMPOSE_FILE%" (
+    echo 错误: 未找到%COMPOSE_FILE%文件
+    echo 请确保在正确的目录中运行此脚本
+    pause
+    exit /b 1
+)
+
+REM 检查Docker Compose命令
+where docker-compose >nul 2>nul
+if %ERRORLEVEL% EQU 0 (
+    set COMPOSE_CMD=docker-compose
+) else (
+    echo 尝试使用新的docker compose命令...
+    docker compose version >nul 2>nul
+    if %ERRORLEVEL% EQU 0 (
+        set COMPOSE_CMD=docker compose
+    ) else (
+        echo 错误: 未找到Docker Compose命令
+        echo 请确保Docker Desktop已正确安装
+        pause
+        exit /b 1
+    )
+)
+
+REM 设置Docker BuildKit环境变量
+set DOCKER_BUILDKIT=1
+set COMPOSE_DOCKER_CLI_BUILD=1
+
+echo 启用Docker BuildKit加速构建...
+
+REM 清理缓存（如果指定）
+if %CLEAN_CACHE% EQU 1 (
+    echo 清理缓存目录...
+    if exist "%CACHE_DIR%" rmdir /s /q "%CACHE_DIR%"
+)
+
+REM 创建缓存目录
+if not exist "%CACHE_DIR%" (
+    echo 创建缓存目录...
+    mkdir "%CACHE_DIR%"
+)
+
+REM 添加构建时间标记
+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镜像
+echo 开始构建Docker镜像...
+
+if "%SERVICE%"=="" (
+    if %REBUILD% EQU 1 (
+        echo 强制重新构建所有服务...
+        %COMPOSE_CMD% build --no-cache %BUILD_ARGS%
+    ) else (
+        %COMPOSE_CMD% build %BUILD_ARGS%
+    )
+) else (
+    if %REBUILD% EQU 1 (
+        echo 强制重新构建服务 %SERVICE%...
+        %COMPOSE_CMD% build --no-cache %BUILD_ARGS% %SERVICE%
+    ) else (
+        echo 构建服务 %SERVICE%...
+        %COMPOSE_CMD% build %BUILD_ARGS% %SERVICE%
+    )
+)
+
+if %ERRORLEVEL% EQU 0 (
+    echo Docker镜像构建成功！
+    echo 构建时间: %BUILD_TIME%
+    echo 可以使用以下命令启动容器：
+    echo %COMPOSE_CMD% up -d
+) else (
+    echo Docker镜像构建失败，请检查错误信息。
+)
+
+pause 

.container/build_docker.sh

@@ -0,0 +1,150 @@
+#!/bin/bash
+
+# 设置配置变量
+CACHE_DIR=".docker-cache/pip"
+BUILD_ARGS="--build-arg BUILDKIT_INLINE_CACHE=1"
+COMPOSE_FILE="docker-compose.yml"
+CLEAN_CACHE=0
+REBUILD=0
+SERVICE=""
+
+# 解析命令行参数
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --clean)
+            CLEAN_CACHE=1
+            shift
+            ;;
+        --rebuild)
+            REBUILD=1
+            shift
+            ;;
+        --service)
+            SERVICE="$2"
+            shift 2
+            ;;
+        --help)
+            echo "用法: ./build_docker.sh [选项]"
+            echo "选项:"
+            echo "  --clean     清理缓存目录"
+            echo "  --rebuild   强制重新构建镜像"
+            echo "  --service   指定要构建的服务名称"
+            echo "  --help      显示此帮助信息"
+            exit 0
+            ;;
+        *)
+            echo "未知选项: $1"
+            echo "使用 --help 查看帮助"
+            exit 1
+            ;;
+    esac
+done
+
+# 检测操作系统类型
+OS_TYPE=$(uname -s)
+echo "检测到操作系统: $OS_TYPE"
+
+# 检查Docker是否安装
+if ! command -v docker &> /dev/null; then
+    echo "错误: Docker未安装"
+    echo "请先安装Docker: https://docs.docker.com/get-docker/"
+    exit 1
+fi
+
+# 检查Docker是否运行
+if ! docker info &> /dev/null; then
+    echo "错误: Docker未运行"
+    echo "请启动Docker服务"
+    exit 1
+fi
+
+# 检查docker-compose.yml文件是否存在
+if [ ! -f "$COMPOSE_FILE" ]; then
+    echo "错误: 未找到$COMPOSE_FILE文件"
+    echo "请确保在正确的目录中运行此脚本"
+    exit 1
+fi
+
+# 设置Docker BuildKit环境变量
+export DOCKER_BUILDKIT=1
+export COMPOSE_DOCKER_CLI_BUILD=1
+
+echo "启用Docker BuildKit加速构建..."
+
+# 清理缓存（如果指定）
+if [ $CLEAN_CACHE -eq 1 ]; then
+    echo "清理缓存目录..."
+    rm -rf "$CACHE_DIR"
+fi
+
+# 创建缓存目录
+mkdir -p "$CACHE_DIR"
+
+# 添加构建时间标记
+BUILD_TIME=$(date +"%Y%m%d_%H%M%S")
+BUILD_ARGS="$BUILD_ARGS --build-arg BUILD_TIME=$BUILD_TIME"
+
+# 获取脚本所在目录
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# 获取项目根目录（脚本所在目录的父目录）
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+
+echo "脚本目录: $SCRIPT_DIR"
+echo "项目根目录: $PROJECT_ROOT"
+
+# 切换到项目根目录
+cd "$PROJECT_ROOT"
+
+# 检查Docker Compose命令
+if command -v docker-compose &> /dev/null; then
+    COMPOSE_CMD="docker-compose"
+    echo "使用 docker-compose 命令"
+elif docker compose version &> /dev/null; then
+    COMPOSE_CMD="docker compose"
+    echo "使用 docker compose 命令"
+else
+    echo "错误: 未找到Docker Compose命令"
+    echo "请安装Docker Compose: https://docs.docker.com/compose/install/"
+    exit 1
+fi
+
+# 检测CPU核心数，用于并行构建
+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核心，启用并行构建..."
+else
+    PARALLEL_FLAG=""
+fi
+
+# 构建命令基础部分
+BUILD_CMD="$COMPOSE_CMD -f \"$SCRIPT_DIR/docker-compose.yml\" build $PARALLEL_FLAG --build-arg BUILDKIT_INLINE_CACHE=1"
+
+# 根据操作系统类型执行不同的命令
+if [[ "$OS_TYPE" == "Darwin" ]]; then
+    # macOS
+    echo "在macOS上构建Docker镜像..."
+    eval $BUILD_CMD
+elif [[ "$OS_TYPE" == "Linux" ]]; then
+    # Linux
+    echo "在Linux上构建Docker镜像..."
+    eval $BUILD_CMD
+elif [[ "$OS_TYPE" == MINGW* ]] || [[ "$OS_TYPE" == CYGWIN* ]] || [[ "$OS_TYPE" == MSYS* ]]; then
+    # Windows
+    echo "在Windows上构建Docker镜像..."
+    eval $BUILD_CMD
+else
+    echo "未知操作系统，尝试使用标准命令构建..."
+    eval $BUILD_CMD
+fi
+
+# 检查构建结果
+if [ $? -eq 0 ]; then
+    echo "Docker镜像构建成功！"
+    echo "构建时间: $BUILD_TIME"
+    echo "可以使用以下命令启动容器："
+    echo "$COMPOSE_CMD -f \"$SCRIPT_DIR/docker-compose.yml\" up -d"
+else
+    echo "Docker镜像构建失败，请检查错误信息。"
+    exit 1
+fi 

.container/check_docker.bat

@@ -0,0 +1,62 @@
+@echo off
+echo 检查Docker环境...
+
+REM 检查Docker是否安装
+where docker >nul 2>nul
+if %ERRORLEVEL% NEQ 0 (
+    echo 错误: Docker未安装
+    echo 在Windows上安装Docker的方法:
+    echo 1. 访问 https://docs.docker.com/desktop/install/windows-install/ 下载Docker Desktop
+    echo 2. 安装并启动Docker Desktop
+    pause
+    exit /b 1
+)
+
+echo Docker已安装
+
+REM 检查Docker Compose是否安装
+where docker-compose >nul 2>nul
+if %ERRORLEVEL% NEQ 0 (
+    echo 警告: Docker-Compose未找到，尝试使用新的docker compose命令
+    docker compose version >nul 2>nul
+    if %ERRORLEVEL% NEQ 0 (
+        echo 错误: Docker Compose未安装
+        echo Docker Desktop for Windows应该已包含Docker Compose
+        echo 请确保Docker Desktop已正确安装
+        pause
+        exit /b 1
+    ) else (
+        echo 使用新的docker compose命令
+        set COMPOSE_CMD=docker compose
+    )
+) else (
+    echo Docker-Compose已安装
+    set COMPOSE_CMD=docker-compose
+)
+
+REM 检查Docker是否正在运行
+docker info >nul 2>nul
+if %ERRORLEVEL% NEQ 0 (
+    echo 错误: Docker未运行
+    echo 请启动Docker Desktop应用程序
+    pause
+    exit /b 1
+)
+
+echo Docker正在运行
+
+REM 检查是否有.env文件
+if not exist "owl\.env" (
+    echo 警告: 未找到owl\.env文件
+    echo 请运行以下命令创建环境变量文件:
+    echo copy owl\.env_template owl\.env
+    echo 然后编辑owl\.env文件，填写必要的API密钥
+) else (
+    echo 环境变量文件已存在
+)
+
+echo 所有检查完成，您的系统已准备好构建和运行OWL项目的Docker容器
+echo 请运行以下命令构建Docker镜像:
+echo %COMPOSE_CMD% build
+
+pause 

.container/check_docker.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+
+# 检测操作系统类型
+OS_TYPE=$(uname -s)
+echo "检测到操作系统: $OS_TYPE"
+
+# 检查Docker是否安装
+if ! command -v docker &> /dev/null; then
+    echo "错误: Docker未安装"
+    
+    if [[ "$OS_TYPE" == "Darwin" ]]; then
+        echo "在macOS上安装Docker的方法:"
+        echo "1. 访问 https://docs.docker.com/desktop/install/mac-install/ 下载Docker Desktop"
+        echo "2. 安装并启动Docker Desktop"
+    elif [[ "$OS_TYPE" == "Linux" ]]; then
+        echo "在Linux上安装Docker的方法:"
+        echo "1. 运行以下命令:"
+        echo "   sudo apt-get update"
+        echo "   sudo apt-get install docker.io docker-compose"
+        echo "2. 启动Docker服务:"
+        echo "   sudo systemctl start docker"
+        echo "   sudo systemctl enable docker"
+    elif [[ "$OS_TYPE" == MINGW* ]] || [[ "$OS_TYPE" == CYGWIN* ]] || [[ "$OS_TYPE" == MSYS* ]]; then
+        echo "在Windows上安装Docker的方法:"
+        echo "1. 访问 https://docs.docker.com/desktop/install/windows-install/ 下载Docker Desktop"
+        echo "2. 安装并启动Docker Desktop"
+    fi
+    
+    exit 1
+fi
+
+echo "Docker已安装"
+
+# 检查Docker Compose是否安装
+if ! command -v docker-compose &> /dev/null; then
+    echo "错误: Docker Compose未安装"
+    
+    if [[ "$OS_TYPE" == "Darwin" ]]; then
+        echo "Docker Desktop for Mac已包含Docker Compose"
+    elif [[ "$OS_TYPE" == "Linux" ]]; then
+        echo "在Linux上安装Docker Compose的方法:"
+        echo "1. 运行以下命令:"
+        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"
+    fi
+    
+    exit 1
+fi
+
+echo "Docker Compose已安装"
+
+# 检查Docker是否正在运行
+if ! docker info &> /dev/null; then
+    echo "错误: Docker未运行"
+    
+    if [[ "$OS_TYPE" == "Darwin" ]]; then
+        echo "请启动Docker Desktop应用程序"
+    elif [[ "$OS_TYPE" == "Linux" ]]; then
+        echo "请运行以下命令启动Docker服务:"
+        echo "sudo systemctl start docker"
+    elif [[ "$OS_TYPE" == MINGW* ]] || [[ "$OS_TYPE" == CYGWIN* ]] || [[ "$OS_TYPE" == MSYS* ]]; then
+        echo "请启动Docker Desktop应用程序"
+    fi
+    
+    exit 1
+fi
+
+echo "Docker正在运行"
+
+# 检查是否有足够的磁盘空间
+FREE_SPACE=$(df -h . | awk 'NR==2 {print $4}')
+echo "可用磁盘空间: $FREE_SPACE"
+
+# 检查是否有.env文件
+if [ ! -f "owl/.env" ]; then
+    echo "警告: 未找到owl/.env文件"
+    echo "请运行以下命令创建环境变量文件:"
+    echo "cp owl/.env_template owl/.env"
+    echo "然后编辑owl/.env文件，填写必要的API密钥"
+else
+    echo "环境变量文件已存在"
+fi
+
+echo "所有检查完成，您的系统已准备好构建和运行OWL项目的Docker容器"
+echo "请运行以下命令构建Docker镜像:"
+
+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:
+        # 构建参数
+        BUILDKIT_INLINE_CACHE: 1
+      # 使用BuildKit加速构建
+      cache_from:
+        - python:3.10-slim
+    volumes:
+      # 挂载.env文件，方便配置API密钥
+      - ./owl/.env:/app/owl/.env
+      # 可选：挂载数据目录
+      - ./data:/app/data
+      # 挂载缓存目录，避免重复下载
+      - playwright-cache:/root/.cache/ms-playwright
+      - pip-cache:/root/.pip/cache
+    environment:
+      # 可以在这里设置环境变量，覆盖.env文件中的设置
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      # 添加显示相关的环境变量
+      - DISPLAY=:99
+      - PLAYWRIGHT_BROWSERS_PATH=/root/.cache/ms-playwright
+      # 设置Python不生成.pyc文件，减少磁盘IO
+      - PYTHONDONTWRITEBYTECODE=1
+      # 设置Python不缓冲输出，方便查看日志
+      - PYTHONUNBUFFERED=1
+      # 设置终端颜色
+      - TERM=xterm-256color
+      # 启用pip缓存
+      - PIP_CACHE_DIR=/root/.pip/cache
+    ports:
+      # 如果项目有Web界面，可以映射端口
+      - "8000:8000"
+    # 使用交互模式运行容器
+    stdin_open: true
+    tty: true
+    # 添加共享内存大小，提高浏览器性能
+    shm_size: 2gb
+    # 设置资源限制
+    deploy:
+      resources:
+        limits:
+          cpus: '2'
+          memory: 4G
+
+# 定义持久化卷，用于缓存
+volumes:
+  playwright-cache:
+  pip-cache: 

.container/run_in_docker.bat

@@ -0,0 +1,116 @@
+@echo off
+setlocal enabledelayedexpansion
+
+REM 定义配置变量
+set SERVICE_NAME=owl
+set PYTHON_CMD=xvfb-python
+set MAX_WAIT_SECONDS=60
+set CHECK_INTERVAL_SECONDS=2
+
+REM 检查参数
+if "%~1"=="" (
+    echo 用法: run_in_docker.bat [脚本名称] "你的问题"
+    echo 例如: run_in_docker.bat run.py "什么是人工智能？"
+    echo 或者: run_in_docker.bat run_deepseek_example.py "什么是人工智能？"
+    echo 如果不指定脚本名称，默认使用 run.py
+    exit /b 1
+)
+
+REM 判断第一个参数是否是脚本名称
+set SCRIPT_NAME=%~1
+set QUERY=%~2
+
+if "!SCRIPT_NAME:~-3!"==".py" (
+    REM 如果提供了第二个参数，则为查询内容
+    if "!QUERY!"=="" (
+        echo 请提供查询参数，例如: run_in_docker.bat !SCRIPT_NAME! "你的问题"
+        exit /b 1
+    )
+) else (
+    REM 如果第一个参数不是脚本名称，则默认使用 run.py
+    set QUERY=!SCRIPT_NAME!
+    set SCRIPT_NAME=run.py
+)
+
+REM 检查脚本是否存在
+if not exist "owl\!SCRIPT_NAME!" (
+    echo 错误: 脚本 'owl\!SCRIPT_NAME!' 不存在
+    echo 可用的脚本有:
+    dir /b owl\*.py | findstr /v "__"
+    exit /b 1
+)
+
+echo 使用脚本: !SCRIPT_NAME!
+echo 查询内容: !QUERY!
+
+REM 从docker-compose.yml获取服务名称（如果文件存在）
+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 使用第一个找到的服务名称
+            set SERVICE_NAME=!service!
+            echo 从docker-compose.yml检测到服务名称: !SERVICE_NAME!
+            goto :found_service
+        )
+    )
+)
+:found_service
+
+REM 确保Docker容器正在运行
+docker-compose ps | findstr "!SERVICE_NAME!.*Up" > nul
+if errorlevel 1 (
+    echo 启动Docker容器...
+    docker-compose up -d
+    
+    REM 使用循环检查容器是否就绪
+    echo 等待容器启动...
+    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!秒，继续等待...
+            goto :wait_loop
+        ) else (
+            echo 错误：容器启动超时，已等待!MAX_WAIT_SECONDS!秒
+            echo 请检查Docker容器状态：docker-compose ps
+            exit /b 1
+        )
+    ) else (
+        echo 容器已就绪，共等待了!total_wait!秒
+    )
+)
+
+REM 检查容器中是否存在xvfb-python命令
+echo 检查容器中的命令...
+docker-compose exec -T !SERVICE_NAME! which !PYTHON_CMD! > nul 2>&1
+if errorlevel 1 (
+    echo 警告：容器中未找到!PYTHON_CMD!命令，尝试使用python替代
+    set PYTHON_CMD=python
+    
+    REM 检查python命令是否存在
+    docker-compose exec -T !SERVICE_NAME! which python > nul 2>&1
+    if errorlevel 1 (
+        echo 错误：容器中未找到python命令
+        echo 请检查容器配置
+        exit /b 1
+    )
+)
+
+REM 在容器中运行指定的脚本，传递查询参数
+echo 在Docker容器中使用!PYTHON_CMD!运行脚本...
+docker-compose exec -T !SERVICE_NAME! !PYTHON_CMD! !SCRIPT_NAME! "!QUERY!"
+
+if errorlevel 0 (
+    echo 查询完成！
+) else (
+    echo 查询执行失败，请检查错误信息。
+)
+
+pause 

.container/run_in_docker.sh

@@ -0,0 +1,135 @@
+#!/bin/bash
+
+# 定义配置变量
+SERVICE_NAME="owl"
+PYTHON_CMD="xvfb-python"
+MAX_WAIT_SECONDS=60
+CHECK_INTERVAL_SECONDS=2
+
+# 检测操作系统类型
+OS_TYPE=$(uname -s)
+echo "检测到操作系统: $OS_TYPE"
+
+# 检查是否提供了查询参数
+if [ $# -lt 1 ]; then
+    echo "用法: ./run_in_docker.sh [脚本名称] '你的问题'"
+    echo "例如: ./run_in_docker.sh run.py '什么是人工智能？'"
+    echo "或者: ./run_in_docker.sh run_deepseek_example.py '什么是人工智能？'"
+    echo "如果不指定脚本名称，默认使用 run.py"
+    exit 1
+fi
+
+# 判断第一个参数是否是脚本名称
+if [[ $1 == *.py ]]; then
+    SCRIPT_NAME="$1"
+    # 如果提供了第二个参数，则为查询内容
+    if [ $# -ge 2 ]; then
+        QUERY="$2"
+    else
+        echo "请提供查询参数，例如: ./run_in_docker.sh $SCRIPT_NAME '你的问题'"
+        exit 1
+    fi
+else
+    # 如果第一个参数不是脚本名称，则默认使用 run.py
+    SCRIPT_NAME="run.py"
+    QUERY="$1"
+fi
+
+# 检查脚本是否存在
+if [ ! -f "owl/$SCRIPT_NAME" ]; then
+    echo "错误: 脚本 'owl/$SCRIPT_NAME' 不存在"
+    echo "可用的脚本有:"
+    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 "使用脚本: $SCRIPT_NAME"
+echo "查询内容: $QUERY"
+
+# 从docker-compose.yml获取服务名称（如果文件存在）
+if [ -f ".container/docker-compose.yml" ]; then
+    DETECTED_SERVICE=$(grep -E "^  [a-zA-Z0-9_-]*:" .container/docker-compose.yml | head -1 | sed 's/^  \(.*\):.*/\1/')
+    if [ ! -z "$DETECTED_SERVICE" ]; then
+        SERVICE_NAME="$DETECTED_SERVICE"
+        echo "从docker-compose.yml检测到服务名称: $SERVICE_NAME"
+    fi
+fi
+
+# 检查Docker Compose命令
+if command -v docker-compose &> /dev/null; then
+    COMPOSE_CMD="docker-compose"
+elif docker compose version &> /dev/null; then
+    COMPOSE_CMD="docker compose"
+else
+    echo "错误: 未找到Docker Compose命令"
+    exit 1
+fi
+
+# 确保Docker容器正在运行
+CONTAINER_RUNNING=$($COMPOSE_CMD ps | grep -c "$SERVICE_NAME.*Up" || true)
+if [ "$CONTAINER_RUNNING" -eq 0 ]; then
+    echo "启动Docker容器..."
+    $COMPOSE_CMD up -d
+    
+    # 使用循环检查容器是否就绪
+    echo "等待容器启动..."
+    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 秒"
+            break
+        else
+            echo "容器尚未就绪，已等待 $TOTAL_WAIT 秒，继续等待..."
+        fi
+    done
+    
+    if [ "$CONTAINER_RUNNING" -eq 0 ]; then
+        echo "错误：容器启动超时，已等待 $MAX_WAIT_SECONDS 秒"
+        echo "请检查Docker容器状态：$COMPOSE_CMD ps"
+        exit 1
+    fi
+fi
+
+# 检查容器中是否存在指定的Python命令
+echo "检查容器中的命令..."
+if ! $COMPOSE_CMD exec -T $SERVICE_NAME which $PYTHON_CMD &> /dev/null; then
+    echo "警告：容器中未找到 $PYTHON_CMD 命令，尝试使用python替代"
+    PYTHON_CMD="python"
+    
+    # 检查python命令是否存在
+    if ! $COMPOSE_CMD exec -T $SERVICE_NAME which python &> /dev/null; then
+        echo "错误：容器中未找到python命令"
+        echo "请检查容器配置"
+        exit 1
+    fi
+fi
+
+# 在容器中运行指定的脚本，传递查询参数
+echo "在Docker容器中使用 $PYTHON_CMD 运行脚本..."
+
+# 根据操作系统类型执行不同的命令
+if [[ "$OS_TYPE" == MINGW* ]] || [[ "$OS_TYPE" == CYGWIN* ]] || [[ "$OS_TYPE" == MSYS* ]]; then
+    # Windows可能需要特殊处理引号
+    winpty $COMPOSE_CMD exec -T $SERVICE_NAME $PYTHON_CMD $SCRIPT_NAME "$QUERY"
+    RESULT=$?
+else
+    # macOS 或 Linux
+    $COMPOSE_CMD exec -T $SERVICE_NAME $PYTHON_CMD $SCRIPT_NAME "$QUERY"
+    RESULT=$?
+fi
+
+# 检查命令执行结果
+if [ $RESULT -eq 0 ]; then
+    echo "查询完成！"
+else
+    echo "查询执行失败，请检查错误信息。"
+fi 

.gitattributes

@@ -6,3 +6,11 @@ owl-main/assets/community.png filter=lfs diff=lfs merge=lfs -text
 owl-main/assets/meetup.jpg filter=lfs diff=lfs merge=lfs -text
 owl-main/assets/owl_architecture.png filter=lfs diff=lfs merge=lfs -text
 owl-main/assets/qr_code.jpg 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.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_/

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
+```

README.md

@@ -0,0 +1,311 @@
+<h1 align="center">
+	🦉 OWL: Optimized Workforce Learning for General Multi-Agent Assistance in Real-World Task Automation
+</h1>
+
+
+<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)
+- [🧪 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.
+
+# 🛠️ Installation
+
+## **Clone the Github repository**
+
+```bash
+git clone https://github.com/camel-ai/owl.git
+cd owl
+```
+
+## **Set up Environment**
+
+Using Conda (recommended):
+```bash
+conda create -n owl python=3.11
+conda activate owl
+```
+
+Using venv (alternative):
+```bash
+python -m venv owl_env
+# On Windows
+owl_env\Scripts\activate
+# On Unix or MacOS
+source owl_env/bin/activate
+```
+
+
+## **Install Dependencies**
+
+```bash
+python -m pip install -r requirements.txt
+playwright install
+```
+
+## **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_example` 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**
+
+If you prefer to run the OWL project using Docker, we provide full Docker support:
+
+```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
+
+# Build and run the Docker container
+docker-compose up -d
+
+# Run OWL inside the container
+docker-compose exec owl bash -c "xvfb-python run.py"
+```
+
+For more detailed Docker usage instructions, including cross-platform support, optimized configurations, and troubleshooting, please refer to [DOCKER_README.md](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"Answer: {answer}")
+```
+
+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"Answer: {answer}")
+```
+
+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]"
+
+# 🧪 Experiments
+
+We provided a script to reproduce the results on GAIA. 
+You can check the `run_gaia_roleplaying.py` file and run the following command:
+
+```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_5.jpg)
+<!-- ![](./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,296 @@
+<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 -->
+# 📋 目录
+
+- [📋 目录](#-目录)
+- [🔥 新闻](#-新闻)
+- [🎬 演示视频](#-演示视频)
+- [✨️ 核心功能](#-核心功能)
+- [🛠️ 安装](#️-安装)
+  - [**克隆 Github 仓库**](#克隆-github-仓库)
+  - [**设置环境**](#设置环境)
+  - [**安装依赖**](#安装依赖)
+  - [**设置环境变量**](#设置环境变量)
+  - [**使用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代码，并使用解释器运行
+
+# 🛠️ 安装
+
+## **克隆 Github 仓库**
+
+```bash
+git clone https://github.com/camel-ai/owl.git
+cd owl
+```
+
+## **设置环境**
+
+使用 Conda（推荐）：
+```bash
+conda create -n owl python=3.11
+conda activate owl
+```
+
+使用 venv（备用）：
+```bash
+python -m venv owl_env
+# Windows 系统
+owl_env\Scripts\activate
+# Unix 或 MacOS 系统
+source owl_env/bin/activate
+```
+
+## **安装依赖**
+
+```bash
+python -m pip install -r requirements.txt
+```
+
+## **设置环境变量**  
+
+在 `owl/.env_template` 文件中，你可以找到所有必要的 API 密钥以及各服务的注册网址。要使用这些 API 服务，请按照以下步骤操作：
+
+1. *复制并重命名*: 复制 `.env_example` 文件，并将副本重命名为 `.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密钥
+
+# 构建并运行Docker容器
+docker-compose up -d
+
+# 在容器中���行OWL
+docker-compose exec owl bash -c "xvfb-python run.py"
+```
+
+更多详细的Docker使用说明，包括跨平台支持、优化配置和故障排除，请参阅 [DOCKER_README.md](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"Answer: {answer}")
+```
+
+上传文件时，只需提供文件路径和问题：
+
+```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]"
+
+# 🧪 实验
+
+我们提供了一个脚本用于复现 GAIA 上的实验结果。  
+你可以查看 `run_gaia_roleplaying.py` 文件，并运行以下命令：
+
+```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_5.jpg)
+<!-- ![](./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,132 @@
+# ========= 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/camel/__init__.py

@@ -0,0 +1,25 @@
+# ========= 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.logger import disable_logging, enable_logging, set_log_level
+
+__version__ = '0.2.11'
+
+__all__ = [
+    '__version__',
+    'camel',
+    'disable_logging',
+    'enable_logging',
+    'set_log_level',
+]

owl/camel/agents/__init__.py

@@ -0,0 +1,44 @@
+# ========= 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 .base import BaseAgent
+from .chat_agent import ChatAgent
+from .critic_agent import CriticAgent
+from .embodied_agent import EmbodiedAgent
+from .knowledge_graph_agent import KnowledgeGraphAgent
+from .role_assignment_agent import RoleAssignmentAgent
+from .search_agent import SearchAgent
+from .task_agent import (
+    TaskCreationAgent,
+    TaskPlannerAgent,
+    TaskPrioritizationAgent,
+    TaskSpecifyAgent,
+)
+from .tool_agents.base import BaseToolAgent
+from .tool_agents.hugging_face_tool_agent import HuggingFaceToolAgent
+
+__all__ = [
+    'BaseAgent',
+    'ChatAgent',
+    'TaskSpecifyAgent',
+    'TaskPlannerAgent',
+    'TaskCreationAgent',
+    'TaskPrioritizationAgent',
+    'CriticAgent',
+    'BaseToolAgent',
+    'HuggingFaceToolAgent',
+    'EmbodiedAgent',
+    'RoleAssignmentAgent',
+    'SearchAgent',
+    'KnowledgeGraphAgent',
+]

owl/camel/agents/base.py

@@ -0,0 +1,29 @@
+# ========= 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 abc import ABC, abstractmethod
+from typing import Any
+
+
+class BaseAgent(ABC):
+    r"""An abstract base class for all CAMEL agents."""
+
+    @abstractmethod
+    def reset(self, *args: Any, **kwargs: Any) -> Any:
+        r"""Resets the agent to its initial state."""
+        pass
+
+    @abstractmethod
+    def step(self, *args: Any, **kwargs: Any) -> Any:
+        r"""Performs a single step of the agent."""
+        pass

owl/camel/agents/chat_agent.py

@@ -0,0 +1,1411 @@
+# ========= 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 __future__ import annotations
+
+import json
+# import logging
+import re
+import uuid
+from collections import defaultdict
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
+
+from loguru import logger
+
+from openai.types.chat import ChatCompletionMessageToolCall
+from openai.types.chat.chat_completion_message_tool_call import Function
+from pydantic import BaseModel
+
+from camel.agents.base import BaseAgent
+from camel.memories import (
+    AgentMemory,
+    ChatHistoryMemory,
+    MemoryRecord,
+    ScoreBasedContextCreator,
+)
+from camel.messages import BaseMessage, FunctionCallingMessage, OpenAIMessage
+from camel.models import (
+    BaseModelBackend,
+    ModelFactory,
+    ModelManager,
+    ModelProcessingError,
+)
+from camel.responses import ChatAgentResponse
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelPlatformType,
+    ModelType,
+    OpenAIBackendRole,
+    RoleType,
+)
+from camel.utils import (
+    func_string_to_callable,
+    get_model_encoding,
+    get_pydantic_object_schema,
+    json_to_function_code,
+)
+
+if TYPE_CHECKING:
+    from openai import Stream
+
+    from camel.terminators import ResponseTerminator
+    from camel.toolkits import FunctionTool
+
+
+# logger = logging.getLogger(__name__)
+
+# AgentOps decorator setting
+try:
+    import os
+
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+class FunctionCallingRecord(BaseModel):
+    r"""Historical records of functions called in the conversation.
+
+    Attributes:
+        func_name (str): The name of the function being called.
+        args (Dict[str, Any]): The dictionary of arguments passed to
+            the function.
+        result (Any): The execution result of calling this function.
+    """
+
+    func_name: str
+    args: Dict[str, Any]
+    result: Any
+
+    def __str__(self) -> str:
+        r"""Overridden version of the string function.
+
+        Returns:
+            str: Modified string to represent the function calling.
+        """
+        return (
+            f"Function Execution: {self.func_name}\n"
+            f"\tArgs: {self.args}\n"
+            f"\tResult: {self.result}"
+        )
+
+    def as_dict(self) -> dict[str, Any]:
+        r"""Returns the function calling record as a dictionary.
+
+        Returns:
+            dict[str, Any]: The function calling record as a dictionary.
+        """
+        return self.model_dump()
+
+
+@track_agent(name="ChatAgent")
+class ChatAgent(BaseAgent):
+    r"""Class for managing conversations of CAMEL Chat Agents.
+
+    Args:
+        system_message (Union[BaseMessage, str], optional): The system message
+            for the chat agent.
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`ModelPlatformType.DEFAULT`
+            with `ModelType.DEFAULT`)
+        memory (AgentMemory, optional): The agent memory for managing chat
+            messages. If `None`, a :obj:`ChatHistoryMemory` will be used.
+            (default: :obj:`None`)
+        message_window_size (int, optional): The maximum number of previous
+            messages to include in the context window. If `None`, no windowing
+            is performed. (default: :obj:`None`)
+        token_limit (int, optional): The maximum number of tokens in a context.
+            The context will be automatically pruned to fulfill the limitation.
+            If `None`, it will be set according to the backend model.
+            (default: :obj:`None`)
+        output_language (str, optional): The language to be output by the
+            agent. (default: :obj:`None`)
+        tools (List[FunctionTool], optional): List of available
+            :obj:`FunctionTool`. (default: :obj:`None`)
+        external_tools (List[FunctionTool], optional): List of external tools
+            (:obj:`FunctionTool`) bind to one chat agent. When these tools
+            are called, the agent will directly return the request instead of
+            processing it. (default: :obj:`None`)
+        response_terminators (List[ResponseTerminator], optional): List of
+            :obj:`ResponseTerminator` bind to one chat agent.
+            (default: :obj:`None`)
+        scheduling_strategy (str): name of function that defines how to select
+            the next model in ModelManager. (default: :str:`round_robin`)
+    """
+
+    def __init__(
+        self,
+        system_message: Optional[Union[BaseMessage, str]] = None,
+        model: Optional[
+            Union[BaseModelBackend, List[BaseModelBackend]]
+        ] = None,
+        memory: Optional[AgentMemory] = None,
+        message_window_size: Optional[int] = None,
+        token_limit: Optional[int] = None,
+        output_language: Optional[str] = None,
+        tools: Optional[List[FunctionTool]] = None,
+        external_tools: Optional[List[FunctionTool]] = None,
+        response_terminators: Optional[List[ResponseTerminator]] = None,
+        scheduling_strategy: str = "round_robin",
+    ) -> None:
+        from copy import deepcopy
+        if isinstance(system_message, str):
+            system_message = BaseMessage.make_assistant_message(
+                role_name='Assistant', content=system_message
+            )
+
+        self.orig_sys_message: Optional[BaseMessage] = system_message
+        self._system_message: Optional[BaseMessage] = system_message
+        self.role_name: str = (
+            getattr(system_message, 'role_name', None) or "assistant"
+        )
+        self.role_type: RoleType = (
+            getattr(system_message, 'role_type', None) or RoleType.ASSISTANT
+        )
+        self.model_backend = ModelManager(
+            model
+            if model is not None
+            else ModelFactory.create(
+                model_platform=ModelPlatformType.DEFAULT,
+                model_type=ModelType.DEFAULT,
+            ),
+            scheduling_strategy=scheduling_strategy,
+        )
+
+        self.model_type = self.model_backend.model_type
+
+        # Tool registration
+        external_tools = external_tools or []
+        tools = tools or []
+        all_tools = tools + external_tools
+        self.external_tool_names = [
+            tool.get_function_name() for tool in external_tools
+        ]
+        self.func_dict = {
+            tool.get_function_name(): tool.func for tool in all_tools
+        }
+        self.tool_dict = {tool.get_function_name(): tool for tool in all_tools}
+        self._all_tools = all_tools
+
+        # If the user set tools from `ChatAgent`, it will override the
+        # configured tools in `BaseModelBackend`.
+        if all_tools:
+            # logger.warning(
+            #     "Overriding the configured tools in `BaseModelBackend` with the tools from `ChatAgent`."
+            # )
+            tool_schema_list = [
+                tool.get_openai_tool_schema() for tool in all_tools
+            ]
+            self.model_backend.model_config_dict['tools'] = tool_schema_list
+            self.tool_schema_list = tool_schema_list
+            
+        from copy import deepcopy
+        self.model_config_dict = deepcopy(self.model_backend.model_config_dict)
+
+        self.model_token_limit = token_limit or self.model_backend.token_limit
+        context_creator = ScoreBasedContextCreator(
+            self.model_backend.token_counter,
+            self.model_token_limit,
+        )
+        self.memory: AgentMemory = memory or ChatHistoryMemory(
+            context_creator, window_size=message_window_size
+        )
+
+        self.output_language: Optional[str] = output_language
+        if self.output_language is not None:
+            self.set_output_language(self.output_language)
+
+        self.terminated: bool = False
+        self.response_terminators = response_terminators or []
+        self.init_messages()
+
+        self.tool_prompt_added = False
+
+    # ruff: noqa: E501
+    def _generate_tool_prompt(self, tool_schema_list: List[Dict]) -> str:
+        r"""Generates a tool prompt based on the provided tool schema list.
+
+        Args:
+            tool_schema_list (List[Dict]): A list of dictionaries, each
+                containing a tool schema.
+
+        Returns:
+            str: A string representing the tool prompt.
+        """
+        tool_prompts = []
+
+        for tool in tool_schema_list:
+            tool_info = tool['function']
+            tool_name = tool_info['name']
+            tool_description = tool_info['description']
+            tool_json = json.dumps(tool_info, indent=4)
+
+            prompt = f"Use the function '{tool_name}' to '{tool_description}':\n{tool_json}\n"
+            tool_prompts.append(prompt)
+
+        tool_prompt_str = "\n".join(tool_prompts)
+
+        final_prompt = f'''
+    # Tool prompt
+    TOOL_PROMPT = f"""
+    You have access to the following functions:
+
+    {tool_prompt_str}
+
+    If you choose to call a function ONLY reply in the following format with no
+    prefix or suffix:
+
+    <function=example_function_name>{{"example_name": "example_value"}}
+    </function>
+
+    Reminder:
+    - Function calls MUST follow the specified format, start with <function=
+      and end with </function>
+    - Required parameters MUST be specified
+    - Only call one function at a time
+    - Put the entire function call reply on one line
+    - If there is no function call available, answer the question like normal 
+      with your current knowledge and do not tell the user about function calls
+    """
+    '''
+        return final_prompt
+
+    def _parse_tool_response(self, response: str):
+        r"""Parses the tool response to extract the function name and
+        arguments.
+
+        Args:
+            response (str): The response from the model containing the
+                function call.
+
+        Returns:
+            Optional[Dict[str, Any]]: The parsed function name and arguments
+                if found, otherwise :obj:`None`.
+        """
+        function_regex = r"<function=(\w+)>(.*?)</function>"
+        match = re.search(function_regex, response)
+
+        if match:
+            function_name, args_string = match.groups()
+            try:
+                args = json.loads(args_string)
+                return {"function": function_name, "arguments": args}
+            except json.JSONDecodeError as error:
+                print(f"Error parsing function arguments: {error}")
+                return None
+        return None
+
+    def reset(self):
+        r"""Resets the :obj:`ChatAgent` to its initial state."""
+        self.terminated = False
+        self.init_messages()
+        for terminator in self.response_terminators:
+            terminator.reset()
+
+    @property
+    def system_message(self) -> Optional[BaseMessage]:
+        r"""The getter method for the property :obj:`system_message`.
+
+        Returns:
+            Optional[BaseMessage]: The system message of this agent if set,
+                else :obj:`None`.
+        """
+        return self._system_message
+
+    @system_message.setter
+    def system_message(self, message: BaseMessage) -> None:
+        r"""The setter method for the property :obj:`system_message`.
+
+        Args:
+            message (BaseMessage): The message to be set as the
+                new system message of this agent.
+        """
+        self._system_message = message
+
+    def is_tools_added(self) -> bool:
+        r"""Whether OpenAI function calling is enabled for this agent.
+
+        Returns:
+            bool: Whether OpenAI function calling is enabled for this
+                agent, determined by whether the dictionary of tools
+                is empty.
+        """
+        return len(self.func_dict) > 0
+
+    def update_memory(
+        self, message: BaseMessage, role: OpenAIBackendRole
+    ) -> None:
+        r"""Updates the agent memory with a new message.
+
+        Args:
+            message (BaseMessage): The new message to add to the stored
+                messages.
+            role (OpenAIBackendRole): The backend role type.
+        """
+        self.memory.write_record(
+            MemoryRecord(message=message, role_at_backend=role)
+        )
+
+    def set_output_language(self, output_language: str) -> BaseMessage:
+        r"""Sets the output language for the system message. This method
+        updates the output language for the system message. The output
+        language determines the language in which the output text should be
+        generated.
+
+        Args:
+            output_language (str): The desired output language.
+
+        Returns:
+            BaseMessage: The updated system message object.
+        """
+        self.output_language = output_language
+        language_prompt = (
+            "\nRegardless of the input language, "
+            f"you must output text in {output_language}."
+        )
+        if self.orig_sys_message is not None:
+            content = self.orig_sys_message.content + language_prompt
+            self._system_message = self.orig_sys_message.create_new_instance(
+                content
+            )
+        else:
+            self._system_message = BaseMessage.make_assistant_message(
+                role_name="Assistant",
+                content=language_prompt,
+            )
+
+        system_record = MemoryRecord(
+            message=self._system_message,
+            role_at_backend=OpenAIBackendRole.SYSTEM,
+        )
+        self.memory.clear()
+        self.memory.write_record(system_record)
+        return self._system_message
+
+    def get_info(
+        self,
+        session_id: Optional[str],
+        usage: Optional[Dict[str, int]],
+        termination_reasons: List[str],
+        num_tokens: int,
+        tool_calls: List[FunctionCallingRecord],
+        external_tool_request: Optional[ChatCompletionMessageToolCall] = None,
+    ) -> Dict[str, Any]:
+        r"""Returns a dictionary containing information about the chat session.
+
+        Args:
+            session_id (str, optional): The ID of the chat session.
+            usage (Dict[str, int], optional): Information about the usage of
+                the LLM model.
+            termination_reasons (List[str]): The reasons for the termination
+                of the chat session.
+            num_tokens (int): The number of tokens used in the chat session.
+            tool_calls (List[FunctionCallingRecord]): The list of function
+                calling records, containing the information of called tools.
+            external_tool_request
+                (Optional[ChatCompletionMessageToolCall], optional):
+                The tool calling request of external tools from the model.
+                These requests are directly returned to the user instead of
+                being processed by the agent automatically.
+                (default: :obj:`None`)
+
+        Returns:
+            Dict[str, Any]: The chat session information.
+        """
+        return {
+            "id": session_id,
+            "usage": usage,
+            "termination_reasons": termination_reasons,
+            "num_tokens": num_tokens,
+            "tool_calls": tool_calls,
+            "external_tool_request": external_tool_request,
+        }
+
+    def init_messages(self) -> None:
+        r"""Initializes the stored messages list with the current system
+        message.
+        """
+        if self._system_message is not None:
+            system_record = MemoryRecord(
+                message=self._system_message,
+                role_at_backend=OpenAIBackendRole.SYSTEM,
+            )
+            self.memory.clear()
+            self.memory.write_record(system_record)
+        else:
+            self.memory.clear()
+    
+    def _transform_function_calling_format(self, openai_messages: List[dict]):
+        r"""Used in deepseek-chat backend. It can modify function calling records' format to match the deepseek-chat backend's format."""
+        from copy import deepcopy
+        _messages = deepcopy(openai_messages)
+        modified_messages = []
+        for message in _messages:
+            if message['role'] == 'function':
+                new_message = {
+                    'role': 'tool',
+                    'tool_call_id': message['name'],
+                    'content': message['content']
+                }
+                modified_messages.append(new_message)
+            else:
+                modified_messages.append(message)
+
+        return modified_messages
+
+
+    def record_message(self, message: BaseMessage) -> None:
+        r"""Records the externally provided message into the agent memory as if
+        it were an answer of the :obj:`ChatAgent` from the backend. Currently,
+        the choice of the critic is submitted with this method.
+
+        Args:
+            message (BaseMessage): An external message to be recorded in the
+                memory.
+        """
+        self.update_memory(message, OpenAIBackendRole.ASSISTANT)
+
+    def step(
+        self,
+        input_message: Union[BaseMessage, str],
+        response_format: Optional[Type[BaseModel]] = None,
+    ) -> ChatAgentResponse:
+        r"""Performs a single step in the chat session by generating a response
+        to the input message.
+
+        Args:
+            input_message (Union[BaseMessage, str]): The input message to the
+                agent. For BaseMessage input, its `role` field that specifies
+                the role at backend may be either `user` or `assistant` but it
+                will be set to `user` anyway since for the self agent any
+                incoming message is external. For str input, the `role_name` would be `User`.
+            response_format (Optional[Type[BaseModel]], optional): A pydantic
+                model class that includes value types and field descriptions
+                used to generate a structured response by LLM. This schema
+                helps in defining the expected output format. (default:
+                :obj:`None`)
+
+        Returns:
+            ChatAgentResponse: A struct containing the output messages,
+                a boolean indicating whether the chat session has terminated,
+                and information about the chat session.
+        """
+        from copy import deepcopy
+        self.model_backend.model_config_dict = deepcopy(self.model_config_dict)
+        self.tool_dict = {tool.get_function_name(): tool for tool in self._all_tools}
+        if (
+            self.model_backend.model_config_dict.get("response_format")
+            and response_format
+        ):
+            raise ValueError(
+                "The `response_format` parameter cannot be set both in "
+                "the model configuration and in the ChatAgent step."
+            )
+
+        if isinstance(input_message, str):
+            input_message = BaseMessage.make_user_message(
+                role_name='User', content=input_message
+            )
+
+        if "llama" in self.model_type.lower():
+            if (
+                self.model_backend.model_config_dict.get("tools", None)
+                and not self.tool_prompt_added
+            ):
+                tool_prompt = self._generate_tool_prompt(self.tool_schema_list)
+
+                tool_sys_msg = BaseMessage.make_assistant_message(
+                    role_name="Assistant",
+                    content=tool_prompt,
+                )
+
+                self.update_memory(tool_sys_msg, OpenAIBackendRole.SYSTEM)
+                self.tool_prompt_added = True
+
+            self.update_memory(input_message, OpenAIBackendRole.USER)
+
+            tool_call_records: List[FunctionCallingRecord] = []
+            while True:
+                # Check if token has exceeded
+                try:
+                    openai_messages, num_tokens = self.memory.get_context()
+                except RuntimeError as e:
+                    return self._step_token_exceed(
+                        e.args[1], tool_call_records, "max_tokens_exceeded"
+                    )
+                (
+                    response,
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                ) = self._step_model_response(openai_messages, num_tokens)
+                # If the model response is not a function call, meaning the
+                # model has generated a message response, break the loop
+                if (
+                    not self.is_tools_added()
+                    or not isinstance(response, ChatCompletion)
+                    or "</function>" not in response.choices[0].message.content  # type: ignore[operator]
+                ):
+                    break
+
+                parsed_content = self._parse_tool_response(
+                    response.choices[0].message.content  # type: ignore[arg-type]
+                )
+
+                response.choices[0].message.tool_calls = [
+                    ChatCompletionMessageToolCall(
+                        id=str(uuid.uuid4()),
+                        function=Function(
+                            arguments=str(parsed_content["arguments"]).replace(
+                                "'", '"'
+                            ),
+                            name=str(parsed_content["function"]),
+                        ),
+                        type="function",
+                    )
+                ]
+
+                # Check for external tool call
+                tool_call_request = response.choices[0].message.tool_calls[0]
+                if tool_call_request.function.name in self.external_tool_names:
+                    # if model calls an external tool, directly return the
+                    # request
+                    info = self._step_get_info(
+                        output_messages,
+                        finish_reasons,
+                        usage_dict,
+                        response_id,
+                        tool_call_records,
+                        num_tokens,
+                        tool_call_request,
+                    )
+                    return ChatAgentResponse(
+                        msgs=output_messages,
+                        terminated=self.terminated,
+                        info=info,
+                    )
+
+                # Normal function calling
+                tool_call_records.append(
+                    self._step_tool_call_and_update(response)
+                )
+
+            if response_format is not None:
+                (
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                    tool_call,
+                    num_tokens,
+                ) = self._structure_output_with_function(response_format)
+                tool_call_records.append(tool_call)
+
+            info = self._step_get_info(
+                output_messages,
+                finish_reasons,
+                usage_dict,
+                response_id,
+                tool_call_records,
+                num_tokens,
+            )
+
+            if len(output_messages) == 1:
+                # Auto record if the output result is a single message
+                self.record_message(output_messages[0])
+            else:
+                logger.warning(
+                    "Multiple messages returned in `step()`, message won't be "
+                    "recorded automatically. Please call `record_message()` "
+                    "to record the selected message manually."
+                )
+
+            return ChatAgentResponse(
+                msgs=output_messages, terminated=self.terminated, info=info
+            )
+
+        else:
+            self.update_memory(input_message, OpenAIBackendRole.USER)
+            # try:
+
+            tool_call_records: List[FunctionCallingRecord] = []  # type: ignore[no-redef]
+            while True:
+                # Check if token has exceeded
+                try:
+                    openai_messages, num_tokens = self.memory.get_context()
+                except RuntimeError as e:
+                    return self._step_token_exceed(
+                        e.args[1], tool_call_records, "max_tokens_exceeded"
+                    )
+
+                (
+                    response,
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                ) = self._step_model_response(openai_messages, num_tokens)
+                # If the model response is not a function call, meaning the
+                # model has generated a message response, break the loop
+                if (
+                    not self.is_tools_added()
+                    or not isinstance(response, ChatCompletion)
+                    or not response.choices[0].message.tool_calls
+                ):
+                    break
+
+                # Check for external tool call
+                tool_call_request = response.choices[0].message.tool_calls[0]
+
+                if tool_call_request.function.name in self.external_tool_names:
+                    # if model calls an external tool, directly return the
+                    # request
+                    info = self._step_get_info(
+                        output_messages,
+                        finish_reasons,
+                        usage_dict,
+                        response_id,
+                        tool_call_records,
+                        num_tokens,
+                        tool_call_request,
+                    )
+                    return ChatAgentResponse(
+                        msgs=output_messages,
+                        terminated=self.terminated,
+                        info=info,
+                    )
+
+                # Normal function calling
+                tool_call_records.append(
+                    self._step_tool_call_and_update(response)
+                )
+
+            if (
+                response_format is not None
+                and self.model_type.support_native_tool_calling
+            ):
+                (
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                    tool_call,
+                    num_tokens,
+                ) = self._structure_output_with_function(response_format)
+                tool_call_records.append(tool_call)
+
+            info = self._step_get_info(
+                output_messages,
+                finish_reasons,
+                usage_dict,
+                response_id,
+                tool_call_records,
+                num_tokens,
+            )
+
+            if len(output_messages) == 1:
+                # Auto record if the output result is a single message
+                self.record_message(output_messages[0])
+            else:
+                logger.warning(
+                    "Multiple messages returned in `step()`, message won't be "
+                    "recorded automatically. Please call `record_message()` "
+                    "to record the selected message manually."
+                )
+
+            return ChatAgentResponse(
+                msgs=output_messages, terminated=self.terminated, info=info
+            )
+
+            # except Exception as e:
+            #     logger.error(e)
+            #     breakpoint()
+            #     raise e
+
+    async def step_async(
+        self,
+        input_message: Union[BaseMessage, str],
+        response_format: Optional[Type[BaseModel]] = None,
+    ) -> ChatAgentResponse:
+        r"""Performs a single step in the chat session by generating a response
+        to the input message. This agent step can call async function calls.
+
+        Args:
+            input_message (Union[BaseMessage, str]): The input message to the
+                agent. For BaseMessage input, its `role` field that specifies
+                the role at backend may be either `user` or `assistant` but it
+                will be set to `user` anyway since for the self agent any
+                incoming message is external. For str input, the `role_name` would be `User`.
+            response_format (Optional[Type[BaseModel]], optional): A pydantic
+                model class that includes value types and field descriptions
+                used to generate a structured response by LLM. This schema
+                helps in defining the expected output format. (default:
+                :obj:`None`)
+
+        Returns:
+            ChatAgentResponse: A struct containing the output messages,
+                a boolean indicating whether the chat session has terminated,
+                and information about the chat session.
+        """
+        if isinstance(input_message, str):
+            input_message = BaseMessage.make_user_message(
+                role_name='User', content=input_message
+            )
+
+        self.update_memory(input_message, OpenAIBackendRole.USER)
+
+        tool_call_records: List[FunctionCallingRecord] = []
+        while True:
+            try:
+                openai_messages, num_tokens = self.memory.get_context()
+            except RuntimeError as e:
+                return self._step_token_exceed(
+                    e.args[1], tool_call_records, "max_tokens_exceeded"
+                )
+
+            (
+                response,
+                output_messages,
+                finish_reasons,
+                usage_dict,
+                response_id,
+            ) = self._step_model_response(openai_messages, num_tokens)
+
+            if (
+                not self.is_tools_added()
+                or not isinstance(response, ChatCompletion)
+                or response.choices[0].message.tool_calls is None
+            ):
+                break
+
+            # Check for external tool call
+            tool_call_request = response.choices[0].message.tool_calls[0]
+            if tool_call_request.function.name in self.external_tool_names:
+                # if model calls an external tool, directly return the request
+                info = self._step_get_info(
+                    output_messages,
+                    finish_reasons,
+                    usage_dict,
+                    response_id,
+                    tool_call_records,
+                    num_tokens,
+                    tool_call_request,
+                )
+                return ChatAgentResponse(
+                    msgs=output_messages, terminated=self.terminated, info=info
+                )
+
+            # Normal function calling
+            tool_call_records.append(
+                await self._step_tool_call_and_update_async(response)
+            )
+
+        if (
+            response_format is not None
+            and self.model_type.support_native_tool_calling
+        ):
+            (
+                output_messages,
+                finish_reasons,
+                usage_dict,
+                response_id,
+                tool_call_record,
+                num_tokens,
+            ) = self._structure_output_with_function(response_format)
+            tool_call_records.append(tool_call_record)
+
+        info = self._step_get_info(
+            output_messages,
+            finish_reasons,
+            usage_dict,
+            response_id,
+            tool_call_records,
+            num_tokens,
+        )
+
+        if len(output_messages) == 1:
+            # Auto record if the output result is a single message
+            self.record_message(output_messages[0])
+        else:
+            logger.warning(
+                "Multiple messages returned in `step()`, message won't be "
+                "recorded automatically. Please call `record_message()` to "
+                "record the selected message manually."
+            )
+
+        return ChatAgentResponse(
+            msgs=output_messages, terminated=self.terminated, info=info
+        )
+
+    def _step_tool_call_and_update(
+        self, response: ChatCompletion
+    ) -> FunctionCallingRecord:
+        r"""Processes a function call within the chat completion response,
+        records the function call in the provided list of tool calls and
+        updates the memory of the current agent.
+
+        Args:
+            response (ChatCompletion): The response object from the chat
+                completion.
+
+        Returns:
+            FunctionCallingRecord: The record of calling the function.
+        """
+
+        # Perform function calling
+        func_assistant_msg, func_result_msg, tool_call_record = (
+            self.step_tool_call(response)
+        )
+
+        # Update the messages
+        self.update_memory(func_assistant_msg, OpenAIBackendRole.ASSISTANT)
+        self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
+
+        return tool_call_record
+
+    async def _step_tool_call_and_update_async(
+        self, response: ChatCompletion
+    ) -> FunctionCallingRecord:
+        (
+            func_assistant_msg,
+            func_result_msg,
+            func_record,
+        ) = await self.step_tool_call_async(response)
+
+        self.update_memory(func_assistant_msg, OpenAIBackendRole.ASSISTANT)
+        self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
+
+        return func_record
+
+    def _structure_output_with_function(
+        self, response_format: Type[BaseModel]
+    ) -> Tuple[
+        List[BaseMessage],
+        List[str],
+        Dict[str, int],
+        str,
+        FunctionCallingRecord,
+        int,
+    ]:
+        r"""Internal function of structuring the output of the agent based on
+        the given output schema.
+
+        Args:
+            response_format (Type[BaseModel]): The output schema to use for
+                structuring the output.
+
+        Returns:
+            Tuple[List[BaseMessage], List[str], Dict[str, int], str,
+                FunctionCallingRecord, int]:
+                A tuple containing the output messages, finish reasons, usage
+                dictionary, response ID, function calling record, and number of
+                tokens.
+        """
+        from camel.toolkits import FunctionTool
+
+        schema_json = get_pydantic_object_schema(response_format)
+        func_str = json_to_function_code(schema_json)
+        func_callable = func_string_to_callable(func_str)
+        func = FunctionTool(func_callable)
+
+        original_func_dict = self.func_dict
+        original_model_dict = self.model_backend.model_config_dict
+
+        # Replace the original tools with the structuring function
+        self.func_dict = {func.get_function_name(): func.func}
+        self.tool_dict = {func.get_function_name(): func}
+        self.model_backend.model_config_dict = original_model_dict.copy()
+        self.model_backend.model_config_dict["tools"] = [
+            func.get_openai_tool_schema()
+        ]
+        self.model_backend.model_config_dict["tool_choice"] = "required"
+
+        openai_messages, num_tokens = self.memory.get_context()
+        (
+            response,
+            output_messages,
+            finish_reasons,
+            usage_dict,
+            response_id,
+        ) = self._step_model_response(openai_messages, num_tokens)
+
+        if isinstance(response, ChatCompletion):
+            tool_call_record = self._step_tool_call_and_update(response)
+        else:
+            raise ValueError(
+                "Structured output is not supported for stream responses."
+            )
+
+        for base_message_item in output_messages:
+            base_message_item.content = str(tool_call_record.result)
+
+        # Recover the original tools
+        self.func_dict = original_func_dict
+        self.model_backend.model_config_dict = original_model_dict
+
+        return (
+            output_messages,
+            finish_reasons,
+            usage_dict,
+            response_id,
+            tool_call_record,
+            num_tokens,
+        )
+
+    def _step_model_response(
+        self,
+        openai_messages: List[OpenAIMessage],
+        num_tokens: int,
+    ) -> tuple[
+        Union[ChatCompletion, Stream],
+        List[BaseMessage],
+        List[str],
+        Dict[str, int],
+        str,
+    ]:
+        r"""Internal function for agent step model response."""
+
+        response = None
+        # Obtain the model's response
+        for _ in range(len(self.model_backend.models)):
+            try:
+                response = self.model_backend.run(openai_messages)
+                break
+            except Exception as exc:
+                logger.error(
+                    f"An error occurred while running model "
+                    f"{self.model_backend.model_type}, "
+                    f"index: {self.model_backend.current_model_index}",
+                    exc_info=exc,
+                )
+                continue
+        if not response:
+            raise ModelProcessingError(
+                "Unable to process messages: none of the provided models "
+                "run succesfully."
+            )
+
+        # logger.debug(
+        #     f"Model {self.model_backend.model_type}, "
+        #     f"index {self.model_backend.current_model_index}, "
+        #     f"processed these messages: {openai_messages}"
+        # )
+
+        if isinstance(response, ChatCompletion):
+            output_messages, finish_reasons, usage_dict, response_id = (
+                self.handle_batch_response(response)
+            )
+        else:
+            output_messages, finish_reasons, usage_dict, response_id = (
+                self.handle_stream_response(response, num_tokens)
+            )
+        return (
+            response,
+            output_messages,
+            finish_reasons,
+            usage_dict,
+            response_id,
+        )
+
+    def _step_get_info(
+        self,
+        output_messages: List[BaseMessage],
+        finish_reasons: List[str],
+        usage_dict: Dict[str, int],
+        response_id: str,
+        tool_calls: List[FunctionCallingRecord],
+        num_tokens: int,
+        external_tool_request: Optional[ChatCompletionMessageToolCall] = None,
+    ) -> Dict[str, Any]:
+        r"""Process the output of a chat step and gather information about the
+        step.
+
+        This method checks for termination conditions, updates the agent's
+        state, and collects information about the chat step, including tool
+        calls and termination reasons.
+
+        Args:
+            output_messages (List[BaseMessage]): The messages generated in
+                this step.
+            finish_reasons (List[str]): The reasons for finishing the
+                generation for each message.
+            usage_dict (Dict[str, int]): Dictionary containing token usage
+                information.
+            response_id (str): The ID of the response from the model.
+            tool_calls (List[FunctionCallingRecord]): Records of function calls
+                made during this step.
+            num_tokens (int): The number of tokens used in this step.
+            external_tool_request (Optional[ChatCompletionMessageToolCall]):
+                Any external tool request made during this step.
+                (default::obj:`None`)
+
+        Returns:
+            Dict[str, Any]: A dictionary containing information about the chat
+                step, including termination status, reasons, and tool call
+                information.
+
+        Note:
+            This method iterates over all response terminators and checks if
+            any of them signal termination. If a terminator signals
+            termination, the agent's state is updated accordingly, and the
+            termination reason is recorded.
+        """
+        termination = [
+            terminator.is_terminated(output_messages)
+            for terminator in self.response_terminators
+        ]
+        # Terminate the agent if any of the terminator terminates
+        self.terminated, termination_reason = next(
+            (
+                (terminated, termination_reason)
+                for terminated, termination_reason in termination
+                if terminated
+            ),
+            (False, None),
+        )
+        # For now only retain the first termination reason
+        if self.terminated and termination_reason is not None:
+            finish_reasons = [termination_reason] * len(finish_reasons)
+
+        info = self.get_info(
+            response_id,
+            usage_dict,
+            finish_reasons,
+            num_tokens,
+            tool_calls,
+            external_tool_request,
+        )
+        return info
+
+    def handle_batch_response(
+        self, response: ChatCompletion
+    ) -> Tuple[List[BaseMessage], List[str], Dict[str, int], str]:
+        r"""Process a batch response from the model and extract the necessary
+        information.
+
+        Args:
+            response (dict): Model response.
+
+        Returns:
+            tuple: A tuple of list of output `ChatMessage`, list of
+                finish reasons, usage dictionary, and response id.
+        """
+        output_messages: List[BaseMessage] = []
+        for choice in response.choices:
+            chat_message = BaseMessage(
+                role_name=self.role_name,
+                role_type=self.role_type,
+                meta_dict=dict(),
+                content=choice.message.content or "",
+                parsed=getattr(choice.message, 'parsed', None),
+            )
+            # Process log probabilities and append to the message meta information
+            if choice.logprobs is not None:
+                tokens_logprobs = choice.logprobs.content
+
+                if tokens_logprobs is not None:
+                    # Extract and structure logprob information
+                    logprobs_info = [
+                        {
+                            "token": token_logprob.token,
+                            "logprob": token_logprob.logprob,
+                            "top_logprobs": [
+                                (top_logprob.token, top_logprob.logprob)
+                                for top_logprob in token_logprob.top_logprobs
+                            ],
+                        }
+                        for token_logprob in tokens_logprobs
+                    ]
+                # Ensure meta_dict exists before adding logprobs info
+                if chat_message.meta_dict is None:
+                    chat_message.meta_dict = {}
+                chat_message.meta_dict["logprobs_info"] = logprobs_info
+            # Append the processed chat message to output
+            output_messages.append(chat_message)
+
+        finish_reasons = [
+            str(choice.finish_reason) for choice in response.choices
+        ]
+        usage = (
+            self._safe_model_dump(response.usage)
+            if response.usage is not None
+            else {}
+        )
+        return (
+            output_messages,
+            finish_reasons,
+            usage,
+            response.id,
+        )
+
+    def _safe_model_dump(self, obj) -> dict:
+        r"""Safely dump a Pydantic model to a dictionary.
+
+        This method attempts to use the `model_dump` method if available,
+        otherwise it falls back to the `dict` method.
+
+        Args:
+            obj: The Pydantic model instance to be dumped.
+
+        Returns:
+            dict: A dictionary representation of the Pydantic model.
+        """
+        # Check if the `model_dump` method exists (Pydantic v2)
+        if hasattr(obj, 'model_dump'):
+            return obj.model_dump()
+        # Fallback to `dict()` method (Pydantic v1)
+        elif hasattr(obj, 'dict'):
+            return obj.dict()
+        else:
+            raise TypeError("The object is not a Pydantic model")
+
+    def handle_stream_response(
+        self,
+        response: Stream[ChatCompletionChunk],
+        prompt_tokens: int,
+    ) -> Tuple[List[BaseMessage], List[str], Dict[str, int], str]:
+        r"""Process a stream response from the model and extract the necessary
+        information.
+
+        Args:
+            response (dict): Model response.
+            prompt_tokens (int): Number of input prompt tokens.
+
+        Returns:
+            tuple: A tuple of list of output `ChatMessage`, list of
+                finish reasons, usage dictionary, and response id.
+        """
+        content_dict: defaultdict = defaultdict(lambda: "")
+        finish_reasons_dict: defaultdict = defaultdict(lambda: "")
+        output_messages: List[BaseMessage] = []
+        response_id: str = ""
+        # All choices in one response share one role
+        for chunk in response:
+            response_id = chunk.id
+            for choice in chunk.choices:
+                index = choice.index
+                delta = choice.delta
+                if delta.content is not None:
+                    # When response has not been stopped
+                    # Notice that only the first chunk_dict has the "role"
+                    content_dict[index] += delta.content
+                if choice.finish_reason:
+                    finish_reasons_dict[index] = choice.finish_reason
+                    chat_message = BaseMessage(
+                        role_name=self.role_name,
+                        role_type=self.role_type,
+                        meta_dict=dict(),
+                        content=content_dict[index],
+                    )
+                    output_messages.append(chat_message)
+        finish_reasons = [
+            finish_reasons_dict[i] for i in range(len(finish_reasons_dict))
+        ]
+        usage_dict = self.get_usage_dict(output_messages, prompt_tokens)
+        return output_messages, finish_reasons, usage_dict, response_id
+
+    def _step_token_exceed(
+        self,
+        num_tokens: int,
+        tool_calls: List[FunctionCallingRecord],
+        termination_reason: str,
+    ) -> ChatAgentResponse:
+        r"""Return trivial response containing number of tokens and information
+        of called functions when the number of tokens exceeds.
+
+        Args:
+            num_tokens (int): Number of tokens in the messages.
+            tool_calls (List[FunctionCallingRecord]): List of information
+                objects of functions called in the current step.
+            termination_reason (str): String of termination reason.
+
+        Returns:
+            ChatAgentResponse: The struct containing trivial outputs and
+                information about token number and called functions.
+        """
+        self.terminated = True
+        output_messages: List[BaseMessage] = []
+
+        info = self.get_info(
+            None,
+            None,
+            [termination_reason],
+            num_tokens,
+            tool_calls,
+        )
+
+        return ChatAgentResponse(
+            msgs=output_messages,
+            terminated=self.terminated,
+            info=info,
+        )
+
+    def step_tool_call(
+        self,
+        response: ChatCompletion,
+    ) -> Tuple[
+        FunctionCallingMessage, FunctionCallingMessage, FunctionCallingRecord
+    ]:
+        r"""Execute the function with arguments following the model's response.
+
+        Args:
+            response (Dict[str, Any]): The response obtained by calling the
+                model.
+
+        Returns:
+            tuple: A tuple consisting of two obj:`FunctionCallingMessage`,
+                one about the arguments and the other about the execution
+                result, and a struct for logging information about this
+                function call.
+        """
+        choice = response.choices[0]
+        if choice.message.tool_calls is None:
+            raise RuntimeError("Tool call is None")
+        func_name = choice.message.tool_calls[0].function.name
+
+        args = json.loads(choice.message.tool_calls[0].function.arguments)
+        tool = self.tool_dict[func_name]
+
+        result = tool(**args)
+
+        assist_msg = FunctionCallingMessage(
+            role_name=self.role_name,
+            role_type=self.role_type,
+            meta_dict=None,
+            content="",
+            func_name=func_name,
+            args=args,
+        )
+        func_msg = FunctionCallingMessage(
+            role_name=self.role_name,
+            role_type=self.role_type,
+            meta_dict=None,
+            content="",
+            func_name=func_name,
+            result=result,
+        )
+
+        # Record information about this function call
+        func_record = FunctionCallingRecord(
+            func_name=func_name, args=args, result=result
+        )
+        return assist_msg, func_msg, func_record
+
+    async def step_tool_call_async(
+        self,
+        response: ChatCompletion,
+    ) -> Tuple[
+        FunctionCallingMessage, FunctionCallingMessage, FunctionCallingRecord
+    ]:
+        r"""Execute the async function with arguments following the model's
+        response.
+
+        Args:
+            response (Dict[str, Any]): The response obtained by calling the
+                model.
+
+        Returns:
+            tuple: A tuple consisting of two obj:`FunctionCallingMessage`,
+                one about the arguments and the other about the execution
+                result, and a struct for logging information about this
+                function call.
+        """
+        # Note that when function calling is enabled, `n` is set to 1.
+        choice = response.choices[0]
+        if choice.message.tool_calls is None:
+            raise RuntimeError("Tool call is None")
+        func_name = choice.message.tool_calls[0].function.name
+
+        args = json.loads(choice.message.tool_calls[0].function.arguments)
+        tool = self.tool_dict[func_name]
+        result = await tool(**args)
+
+        assist_msg = FunctionCallingMessage(
+            role_name=self.role_name,
+            role_type=self.role_type,
+            meta_dict=None,
+            content="",
+            func_name=func_name,
+            args=args,
+        )
+        func_msg = FunctionCallingMessage(
+            role_name=self.role_name,
+            role_type=self.role_type,
+            meta_dict=None,
+            content="",
+            func_name=func_name,
+            result=result,
+        )
+
+        # Record information about this function call
+        func_record = FunctionCallingRecord(
+            func_name=func_name, args=args, result=result
+        )
+        return assist_msg, func_msg, func_record
+
+    def get_usage_dict(
+        self, output_messages: List[BaseMessage], prompt_tokens: int
+    ) -> Dict[str, int]:
+        r"""Get usage dictionary when using the stream mode.
+
+        Args:
+            output_messages (list): List of output messages.
+            prompt_tokens (int): Number of input prompt tokens.
+
+        Returns:
+            dict: Usage dictionary.
+        """
+        encoding = get_model_encoding(self.model_type.value_for_tiktoken)
+        completion_tokens = 0
+        for message in output_messages:
+            completion_tokens += len(encoding.encode(message.content))
+        usage_dict = dict(
+            completion_tokens=completion_tokens,
+            prompt_tokens=prompt_tokens,
+            total_tokens=completion_tokens + prompt_tokens,
+        )
+        return usage_dict
+
+    def add_model_scheduling_strategy(self, name: str, strategy_fn: Callable):
+        r"""Add a scheduling strategy method provided by user to ModelManger.
+
+        Args:
+            name (str): The name of the strategy.
+            strategy_fn (Callable): The scheduling strategy function.
+        """
+        self.model_backend.add_strategy(name, strategy_fn)
+
+    def __repr__(self) -> str:
+        r"""Returns a string representation of the :obj:`ChatAgent`.
+
+        Returns:
+            str: The string representation of the :obj:`ChatAgent`.
+        """
+        return (
+            f"ChatAgent({self.role_name}, {self.role_type}, {self.model_type})"
+        )

owl/camel/agents/critic_agent.py

@@ -0,0 +1,202 @@
+# ========= 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 random
+import warnings
+from typing import Any, Dict, Optional, Sequence
+
+from colorama import Fore
+
+from camel.agents.chat_agent import ChatAgent
+from camel.memories import AgentMemory
+from camel.messages import BaseMessage
+from camel.models import BaseModelBackend
+from camel.responses import ChatAgentResponse
+from camel.utils import get_first_int, print_text_animated
+
+# AgentOps decorator setting
+try:
+    import os
+
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="CriticAgent")
+class CriticAgent(ChatAgent):
+    r"""A class for the critic agent that assists in selecting an option.
+
+    Args:
+        system_message (BaseMessage): The system message for the critic
+            agent.
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
+        message_window_size (int, optional): The maximum number of previous
+            messages to include in the context window. If `None`, no windowing
+            is performed. (default: :obj:`6`)
+        retry_attempts (int, optional): The number of retry attempts if the
+            critic fails to return a valid option. (default: :obj:`2`)
+        verbose (bool, optional): Whether to print the critic's messages.
+        logger_color (Any): The color of the menu options displayed to the
+            user. (default: :obj:`Fore.MAGENTA`)
+    """
+
+    def __init__(
+        self,
+        system_message: BaseMessage,
+        model: Optional[BaseModelBackend] = None,
+        memory: Optional[AgentMemory] = None,
+        message_window_size: int = 6,
+        retry_attempts: int = 2,
+        verbose: bool = False,
+        logger_color: Any = Fore.MAGENTA,
+    ) -> None:
+        super().__init__(
+            system_message,
+            model=model,
+            memory=memory,
+            message_window_size=message_window_size,
+        )
+        self.options_dict: Dict[str, str] = dict()
+        self.retry_attempts = retry_attempts
+        self.verbose = verbose
+        self.logger_color = logger_color
+
+    def flatten_options(self, messages: Sequence[BaseMessage]) -> str:
+        r"""Flattens the options to the critic.
+
+        Args:
+            messages (Sequence[BaseMessage]): A list of `BaseMessage` objects.
+
+        Returns:
+            str: A string containing the flattened options to the critic.
+        """
+        options = [message.content for message in messages]
+        flatten_options = (
+            f"> Proposals from "
+            f"{messages[0].role_name} ({messages[0].role_type}). "
+            "Please choose an option:\n"
+        )
+        for index, option in enumerate(options):
+            flatten_options += f"Option {index + 1}:\n{option}\n\n"
+            self.options_dict[str(index + 1)] = option
+        format = (
+            f"Please first enter your choice ([1-{len(self.options_dict)}]) "
+            "and then your explanation and comparison: "
+        )
+        return flatten_options + format
+
+    def get_option(self, input_message: BaseMessage) -> str:
+        r"""Gets the option selected by the critic.
+
+        Args:
+            input_message (BaseMessage): A `BaseMessage` object representing
+                the input message.
+
+        Returns:
+            str: The option selected by the critic.
+        """
+        # TODO: Add support for editing options by the critic.
+        msg_content = input_message.content
+        i = 0
+        while i < self.retry_attempts:
+            critic_response = self.step(input_message)
+
+            if critic_response.msgs is None or len(critic_response.msgs) == 0:
+                raise RuntimeError("Got None critic messages.")
+            if critic_response.terminated:
+                raise RuntimeError("Critic step failed.")
+
+            critic_msg = critic_response.msg
+            if self.verbose:
+                print_text_animated(
+                    self.logger_color + "\n> Critic response: "
+                    f"\x1b[3m{critic_msg.content}\x1b[0m\n"
+                )
+            choice = self.parse_critic(critic_msg)
+
+            if choice in self.options_dict:
+                return self.options_dict[choice]
+            else:
+                input_message = BaseMessage(
+                    role_name=input_message.role_name,
+                    role_type=input_message.role_type,
+                    meta_dict=input_message.meta_dict,
+                    content="> Invalid choice. Please choose again.\n"
+                    + msg_content,
+                )
+                i += 1
+        warnings.warn(
+            "Critic failed to get a valid option. "
+            f"After {self.retry_attempts} attempts. "
+            "Returning a random option."
+        )
+        return random.choice(list(self.options_dict.values()))
+
+    def parse_critic(self, critic_msg: BaseMessage) -> Optional[str]:
+        r"""Parses the critic's message and extracts the choice.
+
+        Args:
+            critic_msg (BaseMessage): A `BaseMessage` object representing the
+                critic's response.
+
+        Returns:
+            Optional[str]: The critic's choice as a string, or None if the
+                message could not be parsed.
+        """
+        choice = str(get_first_int(critic_msg.content))
+        return choice
+
+    def reduce_step(
+        self,
+        input_messages: Sequence[BaseMessage],
+    ) -> ChatAgentResponse:
+        r"""Performs one step of the conversation by flattening options to the
+        critic, getting the option, and parsing the choice.
+
+        Args:
+            input_messages (Sequence[BaseMessage]): A list of BaseMessage
+                objects.
+
+        Returns:
+            ChatAgentResponse: A `ChatAgentResponse` object includes the
+                critic's choice.
+        """
+        meta_chat_message = BaseMessage(
+            role_name=input_messages[0].role_name,
+            role_type=input_messages[0].role_type,
+            meta_dict=input_messages[0].meta_dict,
+            content="",
+        )
+
+        flatten_options = self.flatten_options(input_messages)
+        if self.verbose:
+            print_text_animated(
+                self.logger_color + f"\x1b[3m{flatten_options}\x1b[0m\n"
+            )
+        input_msg = meta_chat_message.create_new_instance(flatten_options)
+
+        option = self.get_option(input_msg)
+        output_msg = meta_chat_message.create_new_instance(option)
+
+        # TODO: The return `info` can be improved.
+        return ChatAgentResponse(
+            msgs=[output_msg],
+            terminated=False,
+            info={},
+        )

owl/camel/agents/deductive_reasoner_agent.py

@@ -0,0 +1,303 @@
+# ========= 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 re
+from typing import Dict, List, Optional, Union
+
+from camel.agents.chat_agent import ChatAgent
+from camel.logger import get_logger
+from camel.messages import BaseMessage
+from camel.models import BaseModelBackend
+from camel.prompts import TextPrompt
+from camel.types import RoleType
+
+logger = get_logger(__name__)
+
+# AgentOps decorator setting
+try:
+    import os
+
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="DeductiveReasonerAgent")
+class DeductiveReasonerAgent(ChatAgent):
+    r"""An agent responsible for deductive reasoning. Model of deductive
+    reasoning:
+        - L: A ⊕ C -> q * B
+        - A represents the known starting state.
+        - B represents the known target state.
+        - C represents the conditions required to transition from A to B.
+        - Q represents the quality or effectiveness of the transition from
+        A to B.
+        - L represents the path or process from A to B.
+
+    Args:
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
+    """
+
+    def __init__(
+        self,
+        model: Optional[BaseModelBackend] = None,
+    ) -> None:
+        system_message = BaseMessage(
+            role_name="Insight Agent",
+            role_type=RoleType.ASSISTANT,
+            meta_dict=None,
+            content="You assign roles based on tasks.",
+        )
+        super().__init__(system_message, model=model)
+
+    def deduce_conditions_and_quality(
+        self,
+        starting_state: str,
+        target_state: str,
+        role_descriptions_dict: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Union[List[str], Dict[str, str]]]:
+        r"""Derives the conditions and quality from the starting state and the
+        target state based on the model of the deductive reasoning and the
+        knowledge base. It can optionally consider the roles involved in the
+        scenario, which allows tailoring the output more closely to the AI
+        agent's environment.
+
+        Args:
+            starting_state (str): The initial or starting state from which
+                conditions are deduced.
+            target_state (str): The target state of the task.
+            role_descriptions_dict (Optional[Dict[str, str]], optional): The
+                descriptions of the roles. (default: :obj:`None`)
+            role_descriptions_dict (Optional[Dict[str, str]], optional): A
+                dictionary describing the roles involved in the scenario. This
+                is optional and can be used to provide a context for the
+                CAMEL's role-playing, enabling the generation of more relevant
+                and tailored conditions and quality assessments. This could be
+                generated using a `RoleAssignmentAgent()` or defined manually
+                by the user.
+
+        Returns:
+            Dict[str, Union[List[str], Dict[str, str]]]: A dictionary with the
+                extracted data from the message. The dictionary contains three
+                keys:
+                - 'conditions': A list where each key is a condition ID and
+                    each value is the corresponding condition text.
+                - 'labels': A list of label strings extracted from the message.
+                - 'quality': A string of quality assessment strings extracted
+                    from the message.
+        """
+        self.reset()
+
+        deduce_prompt = """You are a deductive reasoner. You are tasked to 
+        complete the TASK based on the THOUGHT OF DEDUCTIVE REASONING, the 
+        STARTING STATE A and the TARGET STATE B. You are given the CONTEXT 
+        CONTENT to help you complete the TASK.
+Your answer MUST strictly adhere to the structure of ANSWER TEMPLATE, ONLY 
+fill in the BLANKs, and DO NOT alter or modify any other part of the template
+
+===== MODELING OF DEDUCTIVE REASONING =====
+You are tasked with understanding a mathematical model based on the components 
+${A, B, C, Q, L}$. In this model: ``L: A ⊕ C -> q * B``.
+- $A$ represents the known starting state.
+- $B$ represents the known target state.
+- $C$ represents the conditions required to transition from $A$ to $B$.
+- $Q$ represents the quality or effectiveness of the transition from $A$ to 
+$B$.
+- $L$ represents the path or process from $A$ to $B$.
+
+===== THOUGHT OF DEDUCTIVE REASONING =====
+1. Define the Parameters of A and B:
+    - Characterization: Before delving into transitions, thoroughly understand 
+    the nature and boundaries of both $A$ and $B$. This includes the type, 
+    properties, constraints, and possible interactions between the two.
+    - Contrast and Compare: Highlight the similarities and differences between 
+    $A$ and $B$. This comparative analysis will give an insight into what 
+    needs changing and what remains constant.
+2. Historical & Empirical Analysis:
+    - Previous Transitions according to the Knowledge Base of GPT: (if 
+    applicable) Extract conditions and patterns from the historical instances 
+    where a similar transition from a state comparable to $A$ moved towards 
+    $B$.
+    - Scientific Principles: (if applicable) Consider the underlying 
+    scientific principles governing or related to the states and their 
+    transition. For example, if $A$ and $B$ are physical states, laws of 
+    physics might apply.
+3. Logical Deduction of Conditions ($C$):
+    - Direct Path Analysis: What are the immediate and direct conditions 
+    required to move from $A$ to $B$?
+    - Intermediate States: Are there states between $A$ and $B$ that must be 
+    traversed or can be used to make the transition smoother or more 
+    efficient? If yes, what is the content?
+    - Constraints & Limitations: Identify potential barriers or restrictions 
+    in moving from $A$ to $B$. These can be external (e.g., environmental 
+    factors) or internal (properties of $A$ or $B$).
+    - Resource and Information Analysis: What resources and information are 
+    required for the transition? This could be time, entity, factor, code 
+    language, software platform, unknowns, etc.
+    - External Influences: Consider socio-economic, political, or 
+    environmental factors (if applicable) that could influence the transition 
+    conditions.
+    - Creative/Heuristic Reasoning: Open your mind to multiple possible $C$'s, 
+    no matter how unconventional they might seem. Utilize analogies, 
+    metaphors, or brainstorming techniques to envision possible conditions or 
+    paths from $A$ to $B$.
+    - The conditions $C$ should be multiple but in one sentence. And each 
+    condition should be concerned with one aspect/entity.
+4. Entity/Label Recognition of Conditions ($C$):
+    - Identify and categorize entities of Conditions ($C$) such as the names, 
+    locations, dates, specific technical terms or contextual parameters that 
+    might be associated with events, innovations post-2022.
+    - The output of the entities/labels will be used as tags or labels for 
+    semantic similarity searches. The entities/labels may be the words, or 
+    phrases, each of them should contain valuable, high information entropy 
+    information, and should be independent.
+    - Ensure that the identified entities are formatted in a manner suitable 
+    for database indexing and retrieval. Organize the entities into 
+    categories, and combine the category with its instance into a continuous 
+    phrase, without using colons or other separators.
+    - Format these entities for database indexing: output the category rather 
+    than its instance/content into a continuous phrase. For example, instead 
+    of "Jan. 02", identify it as "Event time".
+5. Quality Assessment ($Q$):
+    - Efficiency: How efficient is the transition from $A$ to $B$, which 
+    measures the resources used versus the desired outcome?
+    - Effectiveness: Did the transition achieve the desired outcome or was the 
+    target state achieved as intended?
+    - Safety & Risks: Assess any risks associated with the transition and the 
+    measures to mitigate them.
+    - Feedback Mechanisms: Incorporate feedback loops to continuously monitor 
+    and adjust the quality of transition, making it more adaptive.
+6. Iterative Evaluation:
+    - Test & Refine: Based on the initially deduced conditions and assessed 
+    quality, iterate the process to refine and optimize the transition. This 
+    might involve tweaking conditions, employing different paths, or changing 
+    resources.
+    - Feedback Integration: Use feedback to make improvements and increase the 
+    quality of the transition.
+7. Real-world scenarios often present challenges that may not be captured by 
+models and frameworks. While using the model, maintain an adaptive mindset:
+    - Scenario Exploration: Continuously imagine various possible scenarios, 
+    both positive and negative, to prepare for unexpected events.
+    - Flexibility: Be prepared to modify conditions ($C$) or alter the path/
+    process ($L$) if unforeseen challenges arise.
+    - Feedback Integration: Rapidly integrate feedback from actual 
+    implementations to adjust the model's application, ensuring relevancy and 
+    effectiveness.
+
+===== TASK =====
+Given the starting state $A$ and the target state $B$, assuming that a path 
+$L$ always exists between $A$ and $B$, how can one deduce or identify the 
+necessary conditions $C$ and the quality $Q$ of the transition?
+
+===== STARTING STATE $A$ =====
+{starting_state}
+
+===== TARGET STATE $B$ =====
+{target_state}
+
+{role_with_description_prompt}
+===== ANSWER TEMPLATE =====
+- Characterization and comparison of $A$ and $B$:\n<BLANK>
+- Historical & Empirical Analysis:\n<BLANK>/None
+- Logical Deduction of Conditions ($C$) (multiple conditions can be deduced):
+    condition <NUM>:
+        <BLANK>.
+- Entity/Label Recognition of Conditions:\n[<BLANK>, <BLANK>, ...] (include 
+square brackets)
+- Quality Assessment ($Q$) (do not use symbols):
+    <BLANK>.
+- Iterative Evaluation:\n<BLANK>/None"""
+
+        if role_descriptions_dict is not None:
+            role_names = role_descriptions_dict.keys()
+            role_with_description_prompt = (
+                "===== ROLES WITH DESCRIPTIONS =====\n"
+                + "\n".join(
+                    f"{role_name}:\n{role_descriptions_dict[role_name]}\n"
+                    for role_name in role_names
+                )
+                + "\n\n"
+            )
+        else:
+            role_with_description_prompt = ""
+        deduce_prompt = TextPrompt(deduce_prompt)
+
+        deduce = deduce_prompt.format(
+            starting_state=starting_state,
+            target_state=target_state,
+            role_with_description_prompt=role_with_description_prompt,
+        )
+
+        conditions_and_quality_generation_msg = BaseMessage.make_user_message(
+            role_name="Deductive Reasoner", content=deduce
+        )
+
+        response = self.step(
+            input_message=conditions_and_quality_generation_msg
+        )
+
+        if response.terminated:
+            raise RuntimeError(
+                "Deduction failed. Error:\n" + f"{response.info}"
+            )
+        msg: BaseMessage = response.msg
+        logger.info(f"Message content:\n{msg.content}")
+
+        # Extract the conditions from the message
+        conditions_dict = {
+            f"condition {i}": cdt.replace("<", "")
+            .replace(">", "")
+            .strip()
+            .strip('\n')
+            for i, cdt in re.findall(
+                r"condition (\d+):\s*(.+?)(?=condition \d+|- Entity)",
+                msg.content,
+                re.DOTALL,
+            )
+        }
+
+        # Extract the labels from the message
+        labels = [
+            label.strip().strip('\n').strip("\"'")
+            for label in re.findall(
+                r"Entity/Label Recognition of Conditions:\n\[(.+?)\]",
+                msg.content,
+                re.DOTALL,
+            )[0].split(",")
+        ]
+
+        # Extract the quality from the message
+        quality = next(
+            q.strip().strip('\n')
+            for q in re.findall(
+                r"Quality Assessment \(\$Q\$\) \(do not use symbols\):"
+                r"\n(.+?)- Iterative",
+                msg.content,
+                re.DOTALL,
+            )
+        )
+
+        # Convert them into JSON format
+        conditions_and_quality_json: Dict[
+            str, Union[List[str], Dict[str, str]]
+        ] = {}
+        conditions_and_quality_json["conditions"] = conditions_dict
+        conditions_and_quality_json["labels"] = labels
+        conditions_and_quality_json["evaluate_quality"] = quality
+
+        return conditions_and_quality_json

owl/camel/agents/embodied_agent.py

@@ -0,0 +1,201 @@
+# ========= 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 Any, List, Optional
+
+from colorama import Fore
+
+from camel.agents.chat_agent import ChatAgent
+from camel.agents.tool_agents.base import BaseToolAgent
+from camel.interpreters import (
+    BaseInterpreter,
+    InternalPythonInterpreter,
+    SubprocessInterpreter,
+)
+from camel.messages import BaseMessage
+from camel.models import BaseModelBackend
+from camel.responses import ChatAgentResponse
+from camel.utils import print_text_animated
+
+# AgentOps decorator setting
+try:
+    import os
+
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="EmbodiedAgent")
+class EmbodiedAgent(ChatAgent):
+    r"""Class for managing conversations of CAMEL Embodied Agents.
+
+    Args:
+        system_message (BaseMessage): The system message for the chat agent.
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
+        message_window_size (int, optional): The maximum number of previous
+            messages to include in the context window. If `None`, no windowing
+            is performed. (default: :obj:`None`)
+        tool_agents (List[BaseToolAgent], optional): The tools agents to use in
+            the embodied agent. (default: :obj:`None`)
+        code_interpreter (BaseInterpreter, optional): The code interpreter to
+            execute codes. If `code_interpreter` and `tool_agent` are both
+            `None`, default to `SubProcessInterpreter`. If `code_interpreter`
+            is `None` and `tool_agents` is not `None`, default to
+            `InternalPythonInterpreter`.  (default: :obj:`None`)
+        verbose (bool, optional): Whether to print the critic's messages.
+        logger_color (Any): The color of the logger displayed to the user.
+            (default: :obj:`Fore.MAGENTA`)
+    """
+
+    def __init__(
+        self,
+        system_message: BaseMessage,
+        model: Optional[BaseModelBackend] = None,
+        message_window_size: Optional[int] = None,
+        tool_agents: Optional[List[BaseToolAgent]] = None,
+        code_interpreter: Optional[BaseInterpreter] = None,
+        verbose: bool = False,
+        logger_color: Any = Fore.MAGENTA,
+    ) -> None:
+        self.tool_agents = tool_agents
+        self.code_interpreter: BaseInterpreter
+        if code_interpreter is not None:
+            self.code_interpreter = code_interpreter
+        elif self.tool_agents:
+            self.code_interpreter = InternalPythonInterpreter()
+        else:
+            self.code_interpreter = SubprocessInterpreter()
+
+        if self.tool_agents:
+            system_message = self._set_tool_agents(system_message)
+        self.verbose = verbose
+        self.logger_color = logger_color
+        super().__init__(
+            system_message=system_message,
+            model=model,
+            message_window_size=message_window_size,
+        )
+
+    def _set_tool_agents(self, system_message: BaseMessage) -> BaseMessage:
+        action_space_prompt = self._get_tool_agents_prompt()
+        result_message = system_message.create_new_instance(
+            content=system_message.content.format(
+                action_space=action_space_prompt
+            )
+        )
+        if self.tool_agents is not None:
+            self.code_interpreter.update_action_space(
+                {tool.name: tool for tool in self.tool_agents}
+            )
+        return result_message
+
+    def _get_tool_agents_prompt(self) -> str:
+        r"""Returns the action space prompt.
+
+        Returns:
+            str: The action space prompt.
+        """
+        if self.tool_agents is not None:
+            return "\n".join(
+                [
+                    f"*** {tool.name} ***:\n {tool.description}"
+                    for tool in self.tool_agents
+                ]
+            )
+        else:
+            return ""
+
+    def get_tool_agent_names(self) -> List[str]:
+        r"""Returns the names of tool agents.
+
+        Returns:
+            List[str]: The names of tool agents.
+        """
+        if self.tool_agents is not None:
+            return [tool.name for tool in self.tool_agents]
+        else:
+            return []
+
+    # ruff: noqa: E501
+    def step(self, input_message: BaseMessage) -> ChatAgentResponse:  # type: ignore[override]
+        r"""Performs a step in the conversation.
+
+        Args:
+            input_message (BaseMessage): The input message.
+
+        Returns:
+            ChatAgentResponse: A struct containing the output messages,
+                a boolean indicating whether the chat session has terminated,
+                and information about the chat session.
+        """
+        response = super().step(input_message)
+
+        if response.msgs is None or len(response.msgs) == 0:
+            raise RuntimeError("Got None output messages.")
+        if response.terminated:
+            raise RuntimeError(f"{self.__class__.__name__} step failed.")
+
+        # NOTE: Only single output messages are supported
+        explanations, codes = response.msg.extract_text_and_code_prompts()
+
+        if self.verbose:
+            for explanation, code in zip(explanations, codes):
+                print_text_animated(
+                    self.logger_color + f"> Explanation:\n{explanation}"
+                )
+                print_text_animated(self.logger_color + f"> Code:\n{code}")
+
+            if len(explanations) > len(codes):
+                print_text_animated(
+                    self.logger_color + f"> Explanation:\n{explanations[-1]}"
+                )
+
+        content = response.msg.content
+
+        if codes is not None:
+            try:
+                content = "\n> Executed Results:\n"
+                for block_idx, code in enumerate(codes):
+                    executed_output = self.code_interpreter.run(
+                        code, code.code_type
+                    )
+                    content += (
+                        f"Executing code block {block_idx}: {{\n"
+                        + executed_output
+                        + "}\n"
+                    )
+            except InterruptedError as e:
+                content = (
+                    f"\n> Running code fail: {e}\n"
+                    "Please regenerate the code."
+                )
+
+        # TODO: Handle errors
+        content = input_message.content + f"\n> Embodied Actions:\n{content}"
+        message = BaseMessage(
+            input_message.role_name,
+            input_message.role_type,
+            input_message.meta_dict,
+            content,
+        )
+        return ChatAgentResponse(
+            msgs=[message],
+            terminated=response.terminated,
+            info=response.info,
+        )

owl/camel/agents/knowledge_graph_agent.py

@@ -0,0 +1,259 @@
+# ========= 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 TYPE_CHECKING, Optional, Union
+
+if TYPE_CHECKING:
+    from unstructured.documents.elements import Element
+
+from camel.agents import ChatAgent
+from camel.messages import BaseMessage
+from camel.models import BaseModelBackend
+from camel.prompts import TextPrompt
+from camel.storages.graph_storages.graph_element import (
+    GraphElement,
+    Node,
+    Relationship,
+)
+from camel.types import RoleType
+
+# AgentOps decorator setting
+try:
+    import os
+
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+text_prompt = """
+You are tasked with extracting nodes and relationships from given content and 
+structures them into Node and Relationship objects. Here's the outline of what 
+you needs to do:
+
+Content Extraction:
+You should be able to process input content and identify entities mentioned 
+within it.
+Entities can be any noun phrases or concepts that represent distinct entities 
+in the context of the given content.
+
+Node Extraction:
+For each identified entity, you should create a Node object.
+Each Node object should have a unique identifier (id) and a type (type).
+Additional properties associated with the node can also be extracted and 
+stored.
+
+Relationship Extraction:
+You should identify relationships between entities mentioned in the content.
+For each relationship, create a Relationship object.
+A Relationship object should have a subject (subj) and an object (obj) which 
+are Node objects representing the entities involved in the relationship.
+Each relationship should also have a type (type), and additional properties if 
+applicable.
+
+Output Formatting:
+The extracted nodes and relationships should be formatted as instances of the 
+provided Node and Relationship classes.
+Ensure that the extracted data adheres to the structure defined by the classes.
+Output the structured data in a format that can be easily validated against 
+the provided code.
+
+Instructions for you:
+Read the provided content thoroughly.
+Identify distinct entities mentioned in the content and categorize them as 
+nodes.
+Determine relationships between these entities and represent them as directed 
+relationships.
+Provide the extracted nodes and relationships in the specified format below.
+Example for you:
+
+Example Content:
+"John works at XYZ Corporation. He is a software engineer. The company is 
+located in New York City."
+
+Expected Output:
+
+Nodes:
+
+Node(id='John', type='Person')
+Node(id='XYZ Corporation', type='Organization')
+Node(id='New York City', type='Location')
+
+Relationships:
+
+Relationship(subj=Node(id='John', type='Person'), obj=Node(id='XYZ 
+Corporation', type='Organization'), type='WorksAt')
+Relationship(subj=Node(id='John', type='Person'), obj=Node(id='New York City', 
+type='Location'), type='ResidesIn')
+
+===== TASK =====
+Please extracts nodes and relationships from given content and structures them 
+into Node and Relationship objects. 
+
+{task}
+"""
+
+
+@track_agent(name="KnowledgeGraphAgent")
+class KnowledgeGraphAgent(ChatAgent):
+    r"""An agent that can extract node and relationship information for
+    different entities from given `Element` content.
+
+    Attributes:
+        task_prompt (TextPrompt): A prompt for the agent to extract node and
+            relationship information for different entities.
+    """
+
+    def __init__(
+        self,
+        model: Optional[BaseModelBackend] = None,
+    ) -> None:
+        r"""Initialize the `KnowledgeGraphAgent`.
+
+        Args:
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
+        """
+        system_message = BaseMessage(
+            role_name="Graphify",
+            role_type=RoleType.ASSISTANT,
+            meta_dict=None,
+            content="Your mission is to transform unstructured content "
+            "into structured graph data. Extract nodes and relationships with "
+            "precision, and let the connections unfold. Your graphs will "
+            "illuminate the hidden connections within the chaos of "
+            "information.",
+        )
+        super().__init__(system_message, model=model)
+
+    def run(
+        self,
+        element: "Element",
+        parse_graph_elements: bool = False,
+    ) -> Union[str, GraphElement]:
+        r"""Run the agent to extract node and relationship information.
+
+        Args:
+            element (Element): The input element.
+            parse_graph_elements (bool, optional): Whether to parse into
+                `GraphElement`. Defaults to `False`.
+
+        Returns:
+            Union[str, GraphElement]: The extracted node and relationship
+                information. If `parse_graph_elements` is `True` then return
+                `GraphElement`, else return `str`.
+        """
+        self.reset()
+        self.element = element
+
+        knowledge_graph_prompt = TextPrompt(text_prompt)
+        knowledge_graph_generation = knowledge_graph_prompt.format(
+            task=str(element)
+        )
+
+        knowledge_graph_generation_msg = BaseMessage.make_user_message(
+            role_name="Graphify", content=knowledge_graph_generation
+        )
+
+        response = self.step(input_message=knowledge_graph_generation_msg)
+
+        content = response.msg.content
+
+        if parse_graph_elements:
+            content = self._parse_graph_elements(content)
+
+        return content
+
+    def _validate_node(self, node: Node) -> bool:
+        r"""Validate if the object is a valid Node.
+
+        Args:
+            node (Node): Object to be validated.
+
+        Returns:
+            bool: True if the object is a valid Node, False otherwise.
+        """
+        return (
+            isinstance(node, Node)
+            and isinstance(node.id, (str, int))
+            and isinstance(node.type, str)
+        )
+
+    def _validate_relationship(self, relationship: Relationship) -> bool:
+        r"""Validate if the object is a valid Relationship.
+
+        Args:
+            relationship (Relationship): Object to be validated.
+
+        Returns:
+            bool: True if the object is a valid Relationship, False otherwise.
+        """
+        return (
+            isinstance(relationship, Relationship)
+            and self._validate_node(relationship.subj)
+            and self._validate_node(relationship.obj)
+            and isinstance(relationship.type, str)
+        )
+
+    def _parse_graph_elements(self, input_string: str) -> GraphElement:
+        r"""Parses graph elements from given content.
+
+        Args:
+            input_string (str): The input content.
+
+        Returns:
+            GraphElement: The parsed graph elements.
+        """
+        import re
+
+        # Regular expressions to extract nodes and relationships
+        node_pattern = r"Node\(id='(.*?)', type='(.*?)'\)"
+        rel_pattern = (
+            r"Relationship\(subj=Node\(id='(.*?)', type='(.*?)'\), "
+            r"obj=Node\(id='(.*?)', type='(.*?)'\), type='(.*?)'\)"
+        )
+
+        nodes = {}
+        relationships = []
+
+        # Extract nodes
+        for match in re.finditer(node_pattern, input_string):
+            id, type = match.groups()
+            properties = {'source': 'agent_created'}
+            if id not in nodes:
+                node = Node(id=id, type=type, properties=properties)
+                if self._validate_node(node):
+                    nodes[id] = node
+
+        # Extract relationships
+        for match in re.finditer(rel_pattern, input_string):
+            subj_id, subj_type, obj_id, obj_type, rel_type = match.groups()
+            properties = {'source': 'agent_created'}
+            if subj_id in nodes and obj_id in nodes:
+                subj = nodes[subj_id]
+                obj = nodes[obj_id]
+                relationship = Relationship(
+                    subj=subj, obj=obj, type=rel_type, properties=properties
+                )
+                if self._validate_relationship(relationship):
+                    relationships.append(relationship)
+
+        return GraphElement(
+            nodes=list(nodes.values()),
+            relationships=relationships,
+            source=self.element,
+        )

owl/camel/agents/role_assignment_agent.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. =========
+import re
+from typing import Dict, Optional, Union
+
+from camel.agents.chat_agent import ChatAgent
+from camel.messages import BaseMessage
+from camel.models import BaseModelBackend
+from camel.prompts import TextPrompt
+from camel.types import RoleType
+
+# AgentOps decorator setting
+try:
+    import os
+
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="RoleAssignmentAgent")
+class RoleAssignmentAgent(ChatAgent):
+    r"""An agent that generates role names based on the task prompt.
+
+    Args:
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
+
+    Attributes:
+        role_assignment_prompt (TextPrompt): A prompt for the agent to generate
+        role names.
+    """
+
+    def __init__(
+        self,
+        model: Optional[BaseModelBackend] = None,
+    ) -> None:
+        system_message = BaseMessage(
+            role_name="Role Assigner",
+            role_type=RoleType.ASSISTANT,
+            meta_dict=None,
+            content="You assign roles based on tasks.",
+        )
+        super().__init__(system_message, model=model)
+
+    def run(
+        self,
+        task_prompt: Union[str, TextPrompt],
+        num_roles: int = 2,
+    ) -> Dict[str, str]:
+        r"""Generate role names based on the input task prompt.
+
+        Args:
+            task_prompt (Union[str, TextPrompt]): The prompt
+                for the task based on which the roles are to be generated.
+            num_roles (int, optional): The number of roles to generate.
+                (default: :obj:`2`)
+
+        Returns:
+            Dict[str, str]: A dictionary mapping role names to their
+                descriptions.
+        """
+        self.reset()
+
+        expert_prompt = "===== ANSWER PROMPT =====\n" + "\n".join(
+            f"Domain expert {i + 1}: <BLANK>\n"
+            f"Associated competencies, characteristics, duties "
+            f"and workflows: <BLANK>. End."
+            for i in range(num_roles or 0)
+        )
+        role_assignment_generation_prompt = TextPrompt(
+            "You are a role assignment agent, and you're in charge of "
+            + "recruiting {num_roles} experts for the following task."
+            + "\n==== TASK =====\n {task}\n\n"
+            + "Identify the domain experts you'd recruit and detail their "
+            + "associated competencies, characteristics, duties and workflows "
+            + "to complete the task.\n "
+            + "Your answer MUST adhere to the format of ANSWER PROMPT, and "
+            + "ONLY answer the BLANKs.\n"
+            + expert_prompt
+        )
+        role_assignment_generation = role_assignment_generation_prompt.format(
+            num_roles=num_roles, task=task_prompt
+        )
+
+        role_assignment_generation_msg = BaseMessage.make_user_message(
+            role_name="Role Assigner", content=role_assignment_generation
+        )
+
+        response = self.step(input_message=role_assignment_generation_msg)
+
+        msg = response.msg  # type: BaseMessage
+        terminated = response.terminated
+
+        # Distribute the output completions into role names and descriptions
+        role_names = [
+            desc.replace("<|", "").replace("|>", "")
+            for desc in re.findall(
+                r"Domain expert \d: (.+?)\nAssociated competencies,",
+                msg.content,
+                re.DOTALL,
+            )
+        ]
+        role_descriptions = [
+            desc.replace("<|", "").replace("|>", "")
+            for desc in re.findall(
+                r"Associated competencies, characteristics, "
+                r"duties and workflows: (.+?) End.",
+                msg.content,
+                re.DOTALL,
+            )
+        ]
+
+        if len(role_names) != num_roles or len(role_descriptions) != num_roles:
+            raise RuntimeError(
+                "Got None or insufficient information of roles."
+            )
+        if terminated:
+            raise RuntimeError("Role assignment failed.")
+
+        role_descriptions_dict = {
+            role_name: description
+            for role_name, description in zip(role_names, role_descriptions)
+        }
+
+        return role_descriptions_dict

owl/camel/agents/search_agent.py

@@ -0,0 +1,133 @@
+# ========= 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 Optional
+
+from camel.agents.chat_agent import ChatAgent
+from camel.messages import BaseMessage
+from camel.models import BaseModelBackend
+from camel.prompts import TextPrompt
+from camel.types import RoleType
+from camel.utils import create_chunks
+
+# AgentOps decorator setting
+try:
+    import os
+
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="SearchAgent")
+class SearchAgent(ChatAgent):
+    r"""An agent that summarizes text based on a query and evaluates the
+    relevance of an answer.
+
+    Args:
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
+    """
+
+    def __init__(
+        self,
+        model: Optional[BaseModelBackend] = None,
+    ) -> None:
+        system_message = BaseMessage(
+            role_name="Assistant",
+            role_type=RoleType.ASSISTANT,
+            meta_dict=None,
+            content="You are a helpful assistant.",
+        )
+        super().__init__(system_message, model=model)
+
+    def summarize_text(self, text: str, query: str) -> str:
+        r"""Summarize the information from the text, base on the query.
+
+        Args:
+            text (str): Text to summarize.
+            query (str): What information you want.
+
+        Returns:
+            str: Strings with information.
+        """
+        self.reset()
+
+        summary_prompt = TextPrompt(
+            '''Gather information from this text that relative to the
+            question, but do not directly answer the question.\nquestion:
+            {query}\ntext '''
+        )
+        summary_prompt = summary_prompt.format(query=query)
+        # Max length of each chunk
+        max_len = 3000
+        results = ""
+        chunks = create_chunks(text, max_len)
+        # Summarize
+        for i, chunk in enumerate(chunks, start=1):
+            prompt = summary_prompt + str(i) + ": " + chunk
+            user_msg = BaseMessage.make_user_message(
+                role_name="User",
+                content=prompt,
+            )
+            result = self.step(user_msg).msg.content
+            results += result + "\n"
+
+        # Final summarization
+        final_prompt = TextPrompt(
+            '''Here are some summarized texts which split from one text. Using
+            the information to answer the question. If can't find the answer,
+            you must answer "I can not find the answer to the query" and
+            explain why.\n Query:\n{query}.\n\nText:\n'''
+        )
+        final_prompt = final_prompt.format(query=query)
+        prompt = final_prompt + results
+
+        user_msg = BaseMessage.make_user_message(
+            role_name="User",
+            content=prompt,
+        )
+        response = self.step(user_msg).msg.content
+
+        return response
+
+    def continue_search(self, query: str, answer: str) -> bool:
+        r"""Ask whether to continue search or not based on the provided answer.
+
+        Args:
+            query (str): The question.
+            answer (str): The answer to the question.
+
+        Returns:
+            bool: `True` if the user want to continue search, `False`
+            otherwise.
+        """
+        prompt = TextPrompt(
+            "Do you think the ANSWER can answer the QUERY? "
+            "Use only 'yes' or 'no' to answer.\n"
+            "===== QUERY =====\n{query}\n\n"
+            "===== ANSWER =====\n{answer}"
+        )
+        prompt = prompt.format(query=query, answer=answer)
+        user_msg = BaseMessage.make_user_message(
+            role_name="User",
+            content=prompt,
+        )
+        response = self.step(user_msg).msg.content
+        if "yes" in str(response).lower():
+            return False
+        return True

owl/camel/agents/task_agent.py

@@ -0,0 +1,410 @@
+# ========= 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 Any, Dict, List, Optional, Union
+
+from camel.agents.chat_agent import ChatAgent
+from camel.messages import BaseMessage
+from camel.models import BaseModelBackend
+from camel.prompts import PromptTemplateGenerator, TextPrompt
+from camel.types import RoleType, TaskType
+from camel.utils import get_task_list
+
+# AgentOps decorator setting
+try:
+    import os
+
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import track_agent
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    from camel.utils import track_agent
+
+
+@track_agent(name="TaskSpecifyAgent")
+class TaskSpecifyAgent(ChatAgent):
+    r"""An agent that specifies a given task prompt by prompting the user to
+    provide more details.
+
+    Attributes:
+        DEFAULT_WORD_LIMIT (int): The default word limit for the task prompt.
+        task_specify_prompt (TextPrompt): The prompt for specifying the task.
+
+    Args:
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
+        task_type (TaskType, optional): The type of task for which to generate
+            a prompt. (default: :obj:`TaskType.AI_SOCIETY`)
+        task_specify_prompt (Union[str, TextPrompt], optional): The prompt for
+            specifying the task. (default: :obj:`None`)
+        word_limit (int, optional): The word limit for the task prompt.
+            (default: :obj:`50`)
+        output_language (str, optional): The language to be output by the
+            agent. (default: :obj:`None`)
+    """
+
+    DEFAULT_WORD_LIMIT = 50
+
+    def __init__(
+        self,
+        model: Optional[BaseModelBackend] = None,
+        task_type: TaskType = TaskType.AI_SOCIETY,
+        task_specify_prompt: Optional[Union[str, TextPrompt]] = None,
+        word_limit: int = DEFAULT_WORD_LIMIT,
+        output_language: Optional[str] = None,
+    ) -> None:
+        self.task_specify_prompt: Union[str, TextPrompt]
+        if task_specify_prompt is None:
+            task_specify_prompt_template = (
+                PromptTemplateGenerator().get_task_specify_prompt(task_type)
+            )
+
+            self.task_specify_prompt = task_specify_prompt_template.format(
+                word_limit=word_limit
+            )
+        else:
+            self.task_specify_prompt = TextPrompt(task_specify_prompt)
+
+        system_message = BaseMessage(
+            role_name="Task Specifier",
+            role_type=RoleType.ASSISTANT,
+            meta_dict=None,
+            content="You can make a task more specific.",
+        )
+
+        super().__init__(
+            system_message,
+            model=model,
+            output_language=output_language,
+        )
+
+    def run(
+        self,
+        task_prompt: Union[str, TextPrompt],
+        meta_dict: Optional[Dict[str, Any]] = None,
+    ) -> TextPrompt:
+        r"""Specify the given task prompt by providing more details.
+
+        Args:
+            task_prompt (Union[str, TextPrompt]): The original task
+                prompt.
+            meta_dict (Dict[str, Any], optional): A dictionary containing
+                additional information to include in the prompt.
+                (default: :obj:`None`)
+
+        Returns:
+            TextPrompt: The specified task prompt.
+        """
+        self.reset()
+        task_specify_prompt = self.task_specify_prompt.format(task=task_prompt)
+
+        if meta_dict is not None:
+            task_specify_prompt = task_specify_prompt.format(**meta_dict)
+        task_msg = BaseMessage.make_user_message(
+            role_name="Task Specifier", content=task_specify_prompt
+        )
+        specifier_response = self.step(task_msg)
+
+        if specifier_response.terminated:
+            raise RuntimeError("Task specification failed.")
+        if len(specifier_response.msgs) == 0:
+            raise RuntimeError("Got no specification message.")
+
+        specified_task_msg = specifier_response.msgs[0]
+
+        return TextPrompt(specified_task_msg.content)
+
+
+@track_agent(name="TaskPlannerAgent")
+class TaskPlannerAgent(ChatAgent):
+    r"""An agent that helps divide a task into subtasks based on the input
+    task prompt.
+
+    Attributes:
+        task_planner_prompt (TextPrompt): A prompt for the agent to divide
+            the task into subtasks.
+
+    Args:
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
+        output_language (str, optional): The language to be output by the
+            agent. (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        model: Optional[BaseModelBackend] = None,
+        output_language: Optional[str] = None,
+    ) -> None:
+        self.task_planner_prompt = TextPrompt(
+            "Divide this task into subtasks: {task}. Be concise."
+        )
+        system_message = BaseMessage(
+            role_name="Task Planner",
+            role_type=RoleType.ASSISTANT,
+            meta_dict=None,
+            content="You are a helpful task planner.",
+        )
+
+        super().__init__(
+            system_message,
+            model=model,
+            output_language=output_language,
+        )
+
+    def run(
+        self,
+        task_prompt: Union[str, TextPrompt],
+    ) -> TextPrompt:
+        r"""Generate subtasks based on the input task prompt.
+
+        Args:
+            task_prompt (Union[str, TextPrompt]): The prompt for the task to
+                be divided into subtasks.
+
+        Returns:
+            TextPrompt: A prompt for the subtasks generated by the agent.
+        """
+        # TODO: Maybe include roles information.
+        self.reset()
+        task_planner_prompt = self.task_planner_prompt.format(task=task_prompt)
+
+        task_msg = BaseMessage.make_user_message(
+            role_name="Task Planner", content=task_planner_prompt
+        )
+
+        task_response = self.step(task_msg)
+
+        if task_response.terminated:
+            raise RuntimeError("Task planning failed.")
+        if len(task_response.msgs) == 0:
+            raise RuntimeError("Got no task planning message.")
+
+        sub_tasks_msg = task_response.msgs[0]
+        return TextPrompt(sub_tasks_msg.content)
+
+
+@track_agent(name="TaskCreationAgent")
+class TaskCreationAgent(ChatAgent):
+    r"""An agent that helps create new tasks based on the objective
+    and last completed task. Compared to :obj:`TaskPlannerAgent`,
+    it's still a task planner, but it has more context information
+    like last task and incomplete task list. Modified from
+    `BabyAGI <https://github.com/yoheinakajima/babyagi>`_.
+
+    Attributes:
+        task_creation_prompt (TextPrompt): A prompt for the agent to
+            create new tasks.
+
+    Args:
+        role_name (str): The role name of the Agent to create the task.
+        objective (Union[str, TextPrompt]): The objective of the Agent to
+            perform the task.
+        model (BaseModelBackend, optional): The LLM backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
+        output_language (str, optional): The language to be output by the
+            agent. (default: :obj:`None`)
+        message_window_size (int, optional): The maximum number of previous
+            messages to include in the context window. If `None`, no windowing
+            is performed. (default: :obj:`None`)
+        max_task_num (int, optional): The maximum number of planned
+            tasks in one round. (default: :obj:3)
+    """
+
+    def __init__(
+        self,
+        role_name: str,
+        objective: Union[str, TextPrompt],
+        model: Optional[BaseModelBackend] = None,
+        output_language: Optional[str] = None,
+        message_window_size: Optional[int] = None,
+        max_task_num: Optional[int] = 3,
+    ) -> None:
+        task_creation_prompt = TextPrompt(
+            """Create new a task with the following objective: {objective}.
+Never forget you are a Task Creator of {role_name}.
+You must instruct me based on my expertise and your needs to solve the task.
+You should consider past solved tasks and in-progress tasks: {task_list}.
+The new created tasks must not overlap with these past tasks.
+The result must be a numbered list in the format:
+
+    #. First Task
+    #. Second Task
+    #. Third Task
+
+You can only give me up to {max_task_num} tasks at a time. \
+Each task should be concise, concrete and doable for a {role_name}.
+You should make task plan and not ask me questions.
+If you think no new tasks are needed right now, write "No tasks to add."
+Now start to give me new tasks one by one. No more than three tasks.
+Be concrete.
+"""
+        )
+
+        self.task_creation_prompt = task_creation_prompt.format(
+            objective=objective, role_name=role_name, max_task_num=max_task_num
+        )
+        self.objective = objective
+
+        system_message = BaseMessage(
+            role_name="Task Creator",
+            role_type=RoleType.ASSISTANT,
+            meta_dict=None,
+            content="You are a helpful task creator.",
+        )
+
+        super().__init__(
+            system_message,
+            model=model,
+            output_language=output_language,
+            message_window_size=message_window_size,
+        )
+
+    def run(
+        self,
+        task_list: List[str],
+    ) -> List[str]:
+        r"""Generate subtasks based on the previous task results and
+        incomplete task list.
+
+        Args:
+            task_list (List[str]): The completed or in-progress
+                tasks which should not overlap with new created tasks.
+
+        Returns:
+            List[str]: The new task list generated by the Agent.
+        """
+
+        if len(task_list) > 0:
+            task_creation_prompt = self.task_creation_prompt.format(
+                task_list=task_list
+            )
+        else:
+            task_creation_prompt = self.task_creation_prompt.format(
+                task_list=""
+            )
+
+        task_msg = BaseMessage.make_user_message(
+            role_name="Task Creator", content=task_creation_prompt
+        )
+        task_response = self.step(task_msg)
+
+        if task_response.terminated:
+            raise RuntimeError("Task creation failed.")
+        if len(task_response.msgs) == 0:
+            raise RuntimeError("Got no task creation message.")
+
+        sub_tasks_msg = task_response.msgs[0]
+        return get_task_list(sub_tasks_msg.content)
+
+
+@track_agent(name="TaskPrioritizationAgent")
+class TaskPrioritizationAgent(ChatAgent):
+    r"""An agent that helps re-prioritize the task list and
+    returns numbered prioritized list. Modified from
+    `BabyAGI <https://github.com/yoheinakajima/babyagi>`_.
+
+    Attributes:
+        task_prioritization_prompt (TextPrompt): A prompt for the agent to
+            prioritize tasks.
+
+    Args:
+        objective (Union[str, TextPrompt]): The objective of the Agent to
+            perform the task.
+        model (BaseModelBackend, optional): The LLM backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
+        output_language (str, optional): The language to be output by the
+            agent. (default: :obj:`None`)
+        message_window_size (int, optional): The maximum number of previous
+            messages to include in the context window. If `None`, no windowing
+            is performed. (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        objective: Union[str, TextPrompt],
+        model: Optional[BaseModelBackend] = None,
+        output_language: Optional[str] = None,
+        message_window_size: Optional[int] = None,
+    ) -> None:
+        task_prioritization_prompt = TextPrompt(
+            """Prioritize the following tasks : {task_list}.
+Consider the ultimate objective of you: {objective}.
+Tasks should be sorted from highest to lowest priority, where higher-priority \
+tasks are those that act as pre-requisites or are more essential for meeting \
+the objective. Return one task per line in your response.
+Do not remove or modify any tasks.
+The result must be a numbered list in the format:
+
+    #. First task
+    #. Second task
+
+The entries must be consecutively numbered, starting with 1.
+The number of each entry must be followed by a period.
+Do not include any headers before your ranked list or follow your list \
+with any other output."""
+        )
+
+        self.task_prioritization_prompt = task_prioritization_prompt.format(
+            objective=objective
+        )
+        self.objective = objective
+
+        system_message = BaseMessage(
+            role_name="Task Prioritizer",
+            role_type=RoleType.ASSISTANT,
+            meta_dict=None,
+            content="You are a helpful task prioritizer.",
+        )
+
+        super().__init__(
+            system_message,
+            model=model,
+            output_language=output_language,
+            message_window_size=message_window_size,
+        )
+
+    def run(
+        self,
+        task_list: List[str],
+    ) -> List[str]:
+        r"""Prioritize the task list given the agent objective.
+
+        Args:
+            task_list (List[str]): The unprioritized tasks of agent.
+
+        Returns:
+            List[str]: The new prioritized task list generated by the Agent.
+        """
+        task_prioritization_prompt = self.task_prioritization_prompt.format(
+            task_list=task_list
+        )
+
+        task_msg = BaseMessage.make_user_message(
+            role_name="Task Prioritizer", content=task_prioritization_prompt
+        )
+
+        task_response = self.step(task_msg)
+
+        if task_response.terminated:
+            raise RuntimeError("Task prioritization failed.")
+        if len(task_response.msgs) == 0:
+            raise RuntimeError("Got no task prioritization message.")
+
+        sub_tasks_msg = task_response.msgs[0]
+        return get_task_list(sub_tasks_msg.content)

owl/camel/agents/tool_agents/__init__.py

@@ -0,0 +1,20 @@
+# ========= 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 .base import BaseToolAgent
+from .hugging_face_tool_agent import HuggingFaceToolAgent
+
+__all__ = [
+    'BaseToolAgent',
+    'HuggingFaceToolAgent',
+]

owl/camel/agents/tool_agents/base.py

@@ -0,0 +1,39 @@
+# ========= 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.agents import BaseAgent
+
+
+class BaseToolAgent(BaseAgent):
+    r"""Creates a :obj:`BaseToolAgent` object with the specified name and
+        description.
+
+    Args:
+        name (str): The name of the tool agent.
+        description (str): The description of the tool agent.
+    """
+
+    def __init__(self, name: str, description: str) -> None:
+        self.name = name
+        self.description = description
+
+    def reset(self) -> None:
+        r"""Resets the agent to its initial state."""
+        pass
+
+    def step(self) -> None:
+        r"""Performs a single step of the agent."""
+        pass
+
+    def __str__(self) -> str:
+        return f"{self.name}: {self.description}"

owl/camel/agents/tool_agents/hugging_face_tool_agent.py

@@ -0,0 +1,206 @@
+# ========= 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 Any, Optional
+
+from camel.agents.tool_agents.base import BaseToolAgent
+
+
+# flake8: noqa :E501
+class HuggingFaceToolAgent(BaseToolAgent):
+    r"""Tool agent for calling HuggingFace models. This agent is a wrapper
+        around agents from the `transformers` library. For more information
+        about the available models, please see the `transformers` documentation
+        at https://huggingface.co/docs/transformers/transformers_agents.
+
+    Args:
+        name (str): The name of the agent.
+        *args (Any): Additional positional arguments to pass to the underlying
+            Agent class.
+        remote (bool, optional): Flag indicating whether to run the agent
+            remotely. (default: :obj:`True`)
+        **kwargs (Any): Additional keyword arguments to pass to the underlying
+            Agent class.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        *args: Any,
+        remote: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        try:
+            # TODO: Support other tool agents
+            import transformers
+            from packaging import version
+
+            if version.parse(transformers.__version__) < version.parse(
+                "4.31.0"
+            ):
+                raise ValueError(
+                    "The version of \"transformers\" package should >= 4.31.0"
+                )
+
+            from transformers.tools import OpenAiAgent
+            from transformers.tools.agent_types import AgentImage
+        except (ImportError, ValueError):
+            raise ValueError(
+                "Could not import transformers tool agents. "
+                "Please setup the environment with "
+                "pip install huggingface_hub==0.14.1 transformers==4.31.0 diffusers accelerate==0.20.3 datasets torch soundfile sentencepiece opencv-python"
+            )
+        self.agent_image_type = AgentImage
+        self.agent = OpenAiAgent(*args, **kwargs)
+        description = f"""The `{name}` is a tool agent that can perform a variety of tasks including:
+- Document question answering: given a document (such as a PDF) in image format, answer a question on this document
+- Text question answering: given a long text and a question, answer the question in the text
+- Unconditional image captioning: Caption the image!
+- Image question answering: given an image, answer a question on this image
+- Image segmentation: given an image and a prompt, output the segmentation mask of that prompt
+- Speech to text: given an audio recording of a person talking, transcribe the speech into text
+- Text to speech: convert text to speech
+- Zero-shot text classification: given a text and a list of labels, identify to which label the text corresponds the most
+- Text summarization: summarize a long text in one or a few sentences
+- Translation: translate the text into a given language
+- Text downloading: to download a text from a web URL
+- Text to image: generate an image according to a prompt, leveraging stable diffusion
+- Image transformation: modify an image given an initial image and a prompt, leveraging instruct pix2pix stable diffusion
+- Text to video: generate a small video according to a prompt
+
+Here are some python code examples of what you can do with this agent:
+
+Single execution (step) mode, the single execution method is when using the step() method of the agent:
+```
+# Text to image
+rivers_and_lakes_image = {name}.step("Draw me a picture of rivers and lakes.")
+rivers_and_lakes_image.save("./rivers_and_lakes_image.png")
+
+# Text to image -> Image transformation
+sea_add_island_image = {name}.step("Draw me a picture of the sea then transform the picture to add an island")
+sea_add_island_image.save("./sea_add_island_image.png")
+
+# If you'd like to keep a state across executions or to pass non-text objects to the agent, 
+# you can do so by specifying variables that you would like the agent to use. For example,
+# you could generate the first image of rivers and lakes, and ask the model to update that picture to add an island by doing the following:
+picture = {name}.step("Generate a picture of rivers and lakes.")
+picture.save("./picture.png")
+updated_picture = {name}.step("Transform the image in `picture` to add an island to it.", picture=picture)
+updated_picture.save("./updated_picture.png")
+
+capybara_sea_image = {name}.step("Draw me a picture of the `prompt`", prompt="a capybara swimming in the sea")
+capybara_sea_image.save("./capybara_sea_image.png")
+
+# Document question answering
+answer = {name}.step(
+    "In the following `document`, where will the TRRF Scientific Advisory Council Meeting take place?",
+    document=document,
+)
+print(answer)
+
+
+# Text to image
+boat_image = {name}.step("Generate an image of a boat in the water")
+boat_image.save("./boat_image.png")
+
+# Unconditional image captioning
+boat_image_caption = {name}.step("Can you caption the `boat_image`?", boat_image=boat_image)
+print(boat_image_caption)
+
+# Text to image -> Unconditional image captioning -> Text to speech
+boat_audio = {name}.step("Can you generate an image of a boat? Please read out loud the contents of the image afterwards")
+
+# Text downloading
+document = {name}.step("Download the text from http://hf.co")
+print(document)
+
+# Text summarization
+summary = {name}.step("Summarize the following text: `document`", document=document)
+print(summary)
+
+# Text downloading -> Text summarization -> Text to speech
+audio = {name}.step("Read out loud the summary of http://hf.co")
+```
+
+Chat-based execution (chat), the agent also has a chat-based approach, using the chat() method:
+```
+# Clean the chat history
+{name}.reset()
+
+# Text to image
+capybara_image = {name}.chat("Show me an an image of a capybara")
+capybara_image.save("./capybara_image.png")
+
+# Image transformation
+transformed_capybara_image = {name}.chat("Transform the image so that it snows")
+transformed_capybara_image.save("./transformed_capybara_image.png")
+
+# Image segmentation
+segmented_transformed_capybara_image = {name}.chat("Show me a mask of the snowy capybaras")
+segmented_transformed_capybara_image.save("./segmented_transformed_capybara_image.png")
+```
+"""
+        super(HuggingFaceToolAgent, self).__init__(name, description)
+        self.remote = remote
+
+    def reset(self) -> None:
+        r"""Resets the chat history of the agent."""
+        self.agent.prepare_for_new_chat()
+
+    def step(
+        self,
+        *args: Any,
+        remote: Optional[bool] = None,
+        **kwargs: Any,
+    ) -> Any:
+        r"""Runs the agent in single execution mode.
+
+        Args:
+            *args (Any): Positional arguments to pass to the agent.
+            remote (bool, optional): Flag indicating whether to run the agent
+                remotely. Overrides the default setting. (default: :obj:`None`)
+            **kwargs (Any): Keyword arguments to pass to the agent.
+
+        Returns:
+            str: The response from the agent.
+        """
+        if remote is None:
+            remote = self.remote
+        agent_output = self.agent.run(*args, remote=remote, **kwargs)
+        if isinstance(agent_output, self.agent_image_type):
+            agent_output = agent_output.to_raw()
+        return agent_output
+
+    def chat(
+        self,
+        *args: Any,
+        remote: Optional[bool] = None,
+        **kwargs: Any,
+    ) -> Any:
+        r"""Runs the agent in a chat conversation mode.
+
+        Args:
+            *args (Any): Positional arguments to pass to the agent.
+            remote (bool, optional): Flag indicating whether to run the agent
+                remotely. Overrides the default setting. (default: :obj:`None`)
+            **kwargs (Any): Keyword arguments to pass to the agent.
+
+        Returns:
+            str: The response from the agent.
+        """
+        if remote is None:
+            remote = self.remote
+        agent_output = self.agent.chat(*args, remote=remote, **kwargs)
+        if isinstance(agent_output, self.agent_image_type):
+            agent_output = agent_output.to_raw()
+        return agent_output

owl/camel/benchmarks/__init__.py

@@ -0,0 +1,17 @@
+# ========= 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 .base import BaseBenchmark
+
+__all__ = ["BaseBenchmark"]

owl/camel/benchmarks/base.py

@@ -0,0 +1,152 @@
+# ========= 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 logging
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional
+
+from camel.agents import ChatAgent
+
+logger = logging.getLogger(__name__)
+
+
+class BaseBenchmark(ABC):
+    r"""Base class for benchmarks.
+
+    Attributes:
+        name (str): Name of the benchmark.
+        data_dir (str): Path to the data directory.
+        save_to (str): Path to save the results.
+        processes (int): Number of processes to use for parallel
+            processing. :(default: :obj:`1`)
+    """
+
+    def __init__(
+        self, name: str, data_dir: str, save_to: str, processes: int = 1
+    ):
+        r"""Initialize the benchmark.
+
+        Args:
+            name (str): Name of the benchmark.
+            data_dir (str): Path to the data directory.
+            save_to (str): Path to save the results.
+            processes (int): Number of processes to use for parallel
+                processing. :(default: :obj:`1`)
+
+        """
+        self.name = name
+        self.data_dir = Path(data_dir)
+        self.processes = processes
+        self.save_to = save_to
+        if not self.data_dir.exists():
+            logger.info(
+                f"Data directory {data_dir} does not exist. Creating it."
+            )
+            self.data_dir.mkdir(parents=True, exist_ok=True)
+        if not self.data_dir.is_dir():
+            raise NotADirectoryError(
+                f"Data directory {data_dir} is not a directory"
+            )
+        self._data: Dict[str, List[Dict[str, Any]]] = dict()
+        self._results: List[Dict[str, Any]] = []
+
+    @abstractmethod
+    def download(self) -> "BaseBenchmark":
+        r"""Download the benchmark data.
+
+        Returns:
+            BaseBenchmark: The benchmark instance.
+        """
+        pass
+
+    @abstractmethod
+    def load(self, force_download: bool = False) -> "BaseBenchmark":
+        r"""Load the benchmark data.
+
+        Args:
+            force_download (bool): Whether to force download the data.
+
+        Returns:
+            BaseBenchmark: The benchmark instance.
+        """
+        pass
+
+    @property
+    def train(self) -> List[Dict[str, Any]]:
+        r"""Get the training data.
+
+        Returns:
+            List[Dict[str, Any]]: The training data.
+        """
+        if not self._data:
+            logger.info("Data not loaded. Loading data.")
+            self.load()
+        return self._data["train"]
+
+    @property
+    def valid(self) -> List[Dict[str, Any]]:
+        r"""Get the validation data.
+
+        Returns:
+            List[Dict[str, Any]]: The validation data.
+        """
+        if not self._data:
+            logger.info("Data not loaded. Loading data.")
+            self.load()
+        return self._data["valid"]
+
+    @property
+    def test(self) -> List[Dict[str, Any]]:
+        r"""Get the test data.
+
+        Returns:
+            List[Dict[str, Any]]: The test data.
+        """
+        if not self._data:
+            logger.info("Data not loaded. Loading data.")
+            self.load()
+        return self._data["test"]
+
+    @abstractmethod
+    def run(
+        self,
+        agent: ChatAgent,
+        on: Literal["train", "valid", "test"],
+        randomize: bool = False,
+        subset: Optional[int] = None,
+        *args,
+        **kwargs,
+    ) -> "BaseBenchmark":
+        r"""Run the benchmark.
+
+        Args:
+            agent (ChatAgent): The chat agent.
+            on (str): The data split to run the benchmark on.
+            randomize (bool): Whether to randomize the data.
+            subset (int): The subset of the data to run the benchmark on.
+
+        Returns:
+            BaseBenchmark: The benchmark instance.
+        """
+        pass
+
+    @property
+    def results(self) -> List[Dict[str, Any]]:
+        r"""Get the results.
+
+        Returns:
+            List[Dict[str, Any]]: The results.
+        """
+        return self._results

owl/camel/bots/__init__.py

@@ -0,0 +1,34 @@
+# ========= 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 .discord_app import DiscordApp
+from .slack.models import (
+    SlackAppMentionEventBody,
+    SlackAppMentionEventProfile,
+    SlackAuthProfile,
+    SlackEventBody,
+    SlackEventProfile,
+)
+from .slack.slack_app import SlackApp
+from .telegram_bot import TelegramBot
+
+__all__ = [
+    'DiscordApp',
+    'SlackApp',
+    'SlackAppMentionEventBody',
+    'SlackAppMentionEventProfile',
+    'SlackAuthProfile',
+    'SlackEventBody',
+    'SlackEventProfile',
+    'TelegramBot',
+]

owl/camel/bots/discord_app.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. =========
+import logging
+import os
+from typing import TYPE_CHECKING, List, Optional
+
+from camel.utils import dependencies_required
+
+if TYPE_CHECKING:
+    from discord import Message
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class DiscordApp:
+    r"""A class representing a Discord app that uses the `discord.py` library
+    to interact with Discord servers.
+
+    This bot can respond to messages in specific channels and only reacts to
+    messages that mention the bot.
+
+    Attributes:
+        channel_ids (Optional[List[int]]): A list of allowed channel IDs. If
+            provided, the bot will only respond to messages in these channels.
+        token (Optional[str]): The Discord bot token used for authentication.
+    """
+
+    @dependencies_required('discord')
+    def __init__(
+        self,
+        channel_ids: Optional[List[int]] = None,
+        token: Optional[str] = None,
+    ) -> None:
+        r"""Initialize the DiscordApp instance by setting up the Discord client
+        and event handlers.
+
+        Args:
+            channel_ids (Optional[List[int]]): A list of allowed channel IDs.
+                The bot will only respond to messages in these channels if
+                provided.
+            token (Optional[str]): The Discord bot token for authentication.
+                If not provided, the token will be retrieved from the
+                environment variable `DISCORD_TOKEN`.
+
+        Raises:
+            ValueError: If the `DISCORD_TOKEN` is not found in environment
+                variables.
+        """
+        self.token = token or os.getenv('DISCORD_TOKEN')
+        self.channel_ids = channel_ids
+
+        if not self.token:
+            raise ValueError(
+                "`DISCORD_TOKEN` not found in environment variables. Get it"
+                " here: `https://discord.com/developers/applications`."
+            )
+
+        import discord
+
+        intents = discord.Intents.default()
+        intents.message_content = True
+        self._client = discord.Client(intents=intents)
+
+        # Register event handlers
+        self._client.event(self.on_ready)
+        self._client.event(self.on_message)
+
+    async def start(self):
+        r"""Asynchronously start the Discord bot using its token.
+
+        This method starts the bot and logs into Discord asynchronously using
+        the provided token. It should be awaited when used in an async
+        environment.
+        """
+        await self._client.start(self.token)
+
+    def run(self) -> None:
+        r"""Start the Discord bot using its token.
+
+        This method starts the bot and logs into Discord synchronously using
+        the provided token. It blocks execution and keeps the bot running.
+        """
+        self._client.run(self.token)  # type: ignore[arg-type]
+
+    async def on_ready(self) -> None:
+        r"""Event handler that is called when the bot has successfully
+        connected to the Discord server.
+
+        When the bot is ready and logged into Discord, it prints a message
+        displaying the bot's username.
+        """
+        logger.info(f'We have logged in as {self._client.user}')
+
+    async def on_message(self, message: 'Message') -> None:
+        r"""Event handler for processing incoming messages.
+
+        This method is called whenever a new message is received by the bot. It
+        will ignore messages sent by the bot itself, only respond to messages
+        in allowed channels (if specified), and only to messages that mention
+        the bot.
+
+        Args:
+            message (discord.Message): The message object received from
+                Discord.
+        """
+        # If the message author is the bot itself,
+        # do not respond to this message
+        if message.author == self._client.user:
+            return
+
+        # If allowed channel IDs are provided,
+        # only respond to messages in those channels
+        if self.channel_ids and message.channel.id not in self.channel_ids:
+            return
+
+        # Only respond to messages that mention the bot
+        if not self._client.user or not self._client.user.mentioned_in(
+            message
+        ):
+            return
+
+        logger.info(f"Received message: {message.content}")
+
+    @property
+    def client(self):
+        return self._client

owl/camel/bots/slack/__init__.py

@@ -0,0 +1,30 @@
+# ========= 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 .models import (
+    SlackAppMentionEventBody,
+    SlackAppMentionEventProfile,
+    SlackAuthProfile,
+    SlackEventBody,
+    SlackEventProfile,
+)
+from .slack_app import SlackApp
+
+__all__ = [
+    'SlackApp',
+    'SlackAppMentionEventBody',
+    'SlackAppMentionEventProfile',
+    'SlackAuthProfile',
+    'SlackEventBody',
+    'SlackEventProfile',
+]

owl/camel/bots/slack/models.py

@@ -0,0 +1,158 @@
+# ========= 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 Optional
+
+from pydantic import BaseModel
+
+
+class SlackAuthProfile(BaseModel):
+    r"""Represents the authorization profile within a Slack event.
+
+    Events will contain a single, compact authorizations field that shows one
+    installation of your app that the event is visible to.
+    In other words, lists of authorizations will be truncated to one element.
+
+    If there's more than one installing party that your app is keeping track
+    of, it's best not to rely on the single party listed in authorizations to
+    be any particular one.
+
+    To get a full list of who can see events, call the apps.event.
+    authorizations.list method after obtaining an app-level token. Read more on
+    the changes here; they have taken effect for existing apps as of
+    February 24, 2021.
+
+    References:
+
+    - https://api.slack.com/apis/events-api#authorizations
+    - https://api.slack.com/changelog/2020-09-15-events-api-truncate-authed-users#no_context
+    """
+
+    enterprise_id: Optional[str] = None
+    """The ID of the enterprise associated with the authorization."""
+
+    team_id: str
+    """The ID of the team associated with the authorization."""
+
+    user_id: str
+    """The ID of the user associated with the authorization."""
+
+    is_bot: bool
+    """Whether the authorized user is a bot."""
+
+    is_enterprise_install: bool
+    """Whether the authorization is for an enterprise installation."""
+
+
+class SlackEventProfile(BaseModel):
+    r"""Represents the detailed profile of a Slack event, including user,
+    message, and context data.
+    """
+
+    user: str
+    """The ID of the user associated with the event."""
+
+    type: str
+    """The type of the event (e.g., 'message')."""
+
+    ts: str
+    """A timestamp representing when the event was triggered."""
+
+    thread_ts: Optional[str] = None
+    """The timestamp of the parent message in a thread."""
+
+    client_msg_id: str
+    """A unique ID generated by the client for the message (if available)."""
+
+    text: str
+    """The message content text."""
+
+    team: str
+    """The ID of the team that the event is associated with."""
+
+    blocks: list
+    """The list of message blocks, providing structured information."""
+
+    channel: str
+    """The ID of the Slack channel where the event happened."""
+
+    event_ts: str
+    """The event-specific timestamp when it occurred."""
+
+    channel_type: Optional[str]
+    """The type of Slack channel (e.g., 'channel', 'im')."""
+
+
+class SlackEventBody(BaseModel):
+    r"""Represents the entire body of a Slack event, including the event
+    profile, authorization, and context.
+    """
+
+    token: str
+    """The token to verify the source of the event."""
+
+    team_id: str
+    """The ID of the team where the event is happening."""
+
+    context_team_id: Optional[str]
+    """The team ID for the shared channel context, if applicable."""
+
+    context_enterprise_id: Optional[str] = None
+    """The enterprise ID for the shared channel context, if applicable."""
+
+    api_app_id: str
+    """The unique identifier for the Slack app that received the event."""
+
+    event: SlackEventProfile
+    """A detailed profile of the event"""
+
+    type: str
+    """The overall type of event received (e.g., 'event_callback')."""
+
+    event_id: str
+    """A unique identifier assigned to this event by Slack."""
+
+    event_time: int
+    """The timestamp (in seconds) representing when the event was triggered."""
+
+    authorizations: Optional[list[SlackAuthProfile]] = None
+    """An optional list of authorizations that describe which installation can 
+    see the event."""
+
+    is_ext_shared_channel: bool
+    """Indicates if the event is part of a shared channel between different 
+    organizations."""
+
+    event_context: str
+    """A unique string representing the context of the event."""
+
+
+class SlackAppMentionEventProfile(SlackEventProfile):
+    r"""Represents the detailed profile of a Slack event where the app was
+    mentioned in a message.
+    """
+
+    channel_type: Optional[str] = None
+    """The type of Slack channel. it's None for app mentions."""
+
+
+class SlackAppMentionEventBody(SlackEventBody):
+    r"""Represents the entire body of a Slack event where the app was mentioned
+    in a message.
+    """
+
+    context_team_id: Optional[str] = None
+    """A detailed profile of the event. it's None for app mentions."""
+
+    event: SlackAppMentionEventProfile
+    """A detailed profile of the event"""

owl/camel/bots/slack/slack_app.py

@@ -0,0 +1,255 @@
+# ========= 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 logging
+import os
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from slack_sdk.oauth.installation_store.async_installation_store import (
+    AsyncInstallationStore,
+)
+from starlette import requests, responses
+
+from camel.bots.slack.models import (
+    SlackAppMentionEventBody,
+    SlackAppMentionEventProfile,
+    SlackEventBody,
+    SlackEventProfile,
+)
+from camel.utils import dependencies_required
+
+if TYPE_CHECKING:
+    from slack_bolt.context.async_context import AsyncBoltContext
+    from slack_bolt.context.say.async_say import AsyncSay
+    from slack_sdk.web.async_client import AsyncWebClient
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class SlackApp:
+    r"""Represents a Slack app that is powered by a Slack Bolt `AsyncApp`.
+
+    This class is responsible for initializing and managing the Slack
+    application by setting up event handlers, running the app server, and
+    handling events such as messages and mentions from Slack.
+
+    Args:
+        token (Optional[str]): Slack API token for authentication.
+        scopes (Optional[str]): Slack app scopes for permissions.
+        signing_secret (Optional[str]): Signing secret for verifying Slack
+            requests.
+        client_id (Optional[str]): Slack app client ID.
+        client_secret (Optional[str]): Slack app client secret.
+        redirect_uri_path (str): The URI path for OAuth redirect, defaults to
+            "/slack/oauth_redirect".
+        installation_store (Optional[AsyncInstallationStore]): The installation
+            store for handling OAuth installations.
+    """
+
+    @dependencies_required('slack_bolt')
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        scopes: Optional[str] = None,
+        signing_secret: Optional[str] = None,
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        redirect_uri_path: str = "/slack/oauth_redirect",
+        installation_store: Optional[AsyncInstallationStore] = None,
+    ) -> None:
+        r"""Initializes the SlackApp instance by setting up the Slack Bolt app
+        and configuring event handlers and OAuth settings.
+
+        Args:
+            token (Optional[str]): The Slack API token.
+            scopes (Optional[str]): The scopes for Slack app permissions.
+            signing_secret (Optional[str]): The signing secret for verifying
+                requests.
+            client_id (Optional[str]): The Slack app client ID.
+            client_secret (Optional[str]): The Slack app client secret.
+            redirect_uri_path (str): The URI path for handling OAuth redirects
+                (default is "/slack/oauth_redirect").
+            installation_store (Optional[AsyncInstallationStore]): An optional
+                installation store for OAuth installations.
+        """
+        from slack_bolt.adapter.starlette.async_handler import (
+            AsyncSlackRequestHandler,
+        )
+        from slack_bolt.app.async_app import AsyncApp
+        from slack_bolt.oauth.async_oauth_settings import AsyncOAuthSettings
+
+        self.token: Optional[str] = token or os.getenv("SLACK_TOKEN")
+        self.scopes: Optional[str] = scopes or os.getenv("SLACK_SCOPES")
+        self.signing_secret: Optional[str] = signing_secret or os.getenv(
+            "SLACK_SIGNING_SECRET"
+        )
+        self.client_id: Optional[str] = client_id or os.getenv(
+            "SLACK_CLIENT_ID"
+        )
+        self.client_secret: Optional[str] = client_secret or os.getenv(
+            "SLACK_CLIENT_SECRET"
+        )
+
+        if not all([self.token, self.scopes, self.signing_secret]):
+            raise ValueError(
+                "`SLACK_TOKEN`, `SLACK_SCOPES`, and `SLACK_SIGNING_SECRET` "
+                "environment variables must be set. Get it here: "
+                "`https://api.slack.com/apps`."
+            )
+
+        # Setup OAuth settings if client ID and secret are provided
+        if self.client_id and self.client_secret:
+            self._app = AsyncApp(
+                oauth_settings=AsyncOAuthSettings(
+                    client_id=self.client_id,
+                    client_secret=self.client_secret,
+                    scopes=self.scopes,
+                    redirect_uri_path=redirect_uri_path,
+                ),
+                logger=logger,
+                signing_secret=self.signing_secret,
+                installation_store=installation_store,
+                token=self.token,
+            )
+        else:
+            # Initialize Slack Bolt AsyncApp with settings
+            self._app = AsyncApp(
+                logger=logger,
+                signing_secret=self.signing_secret,
+                installation_store=installation_store,
+                token=self.token,
+            )
+
+        self._handler = AsyncSlackRequestHandler(self._app)
+        self.setup_handlers()
+
+    def setup_handlers(self) -> None:
+        r"""Sets up the event handlers for Slack events, such as `app_mention`
+        and `message`.
+
+        This method registers the `app_mention` and `on_message` event handlers
+        with the Slack Bolt app to respond to Slack events.
+        """
+        self._app.event("app_mention")(self.app_mention)
+        self._app.event("message")(self.on_message)
+
+    def run(
+        self,
+        port: int = 3000,
+        path: str = "/slack/events",
+        host: Optional[str] = None,
+    ) -> None:
+        r"""Starts the Slack Bolt app server to listen for incoming Slack
+        events.
+
+        Args:
+            port (int): The port on which the server should run (default is
+                3000).
+            path (str): The endpoint path for receiving Slack events (default
+                is "/slack/events").
+            host (Optional[str]): The hostname to bind the server (default is
+                None).
+        """
+        self._app.start(port=port, path=path, host=host)
+
+    async def handle_request(
+        self, request: requests.Request
+    ) -> responses.Response:
+        r"""Handles incoming requests from Slack through the request handler.
+
+        Args:
+            request (Request): A Starlette request object representing the
+                incoming request.
+
+        Returns:
+            The response generated by the Slack Bolt handler.
+        """
+        return await self._handler.handle(request)
+
+    async def app_mention(
+        self,
+        context: "AsyncBoltContext",
+        client: "AsyncWebClient",
+        event: Dict[str, Any],
+        body: Dict[str, Any],
+        say: "AsyncSay",
+    ) -> None:
+        r"""Event handler for `app_mention` events.
+
+        This method is triggered when someone mentions the app in Slack.
+
+        Args:
+            context (AsyncBoltContext): The Slack Bolt context for the event.
+            client (AsyncWebClient): The Slack Web API client.
+            event (Dict[str, Any]): The event data for the app mention.
+            body (Dict[str, Any]): The full request body from Slack.
+            say (AsyncSay): A function to send a response back to the channel.
+        """
+        event_profile = SlackAppMentionEventProfile(**event)
+        event_body = SlackAppMentionEventBody(**body)
+
+        logger.info(f"app_mention, context: {context}")
+        logger.info(f"app_mention, client: {client}")
+        logger.info(f"app_mention, event_profile: {event_profile}")
+        logger.info(f"app_mention, event_body: {event_body}")
+        logger.info(f"app_mention, say: {say}")
+
+    async def on_message(
+        self,
+        context: "AsyncBoltContext",
+        client: "AsyncWebClient",
+        event: Dict[str, Any],
+        body: Dict[str, Any],
+        say: "AsyncSay",
+    ) -> None:
+        r"""Event handler for `message` events.
+
+        This method is triggered when the app receives a message in Slack.
+
+        Args:
+            context (AsyncBoltContext): The Slack Bolt context for the event.
+            client (AsyncWebClient): The Slack Web API client.
+            event (Dict[str, Any]): The event data for the message.
+            body (Dict[str, Any]): The full request body from Slack.
+            say (AsyncSay): A function to send a response back to the channel.
+        """
+        await context.ack()
+
+        event_profile = SlackEventProfile(**event)
+        event_body = SlackEventBody(**body)
+
+        logger.info(f"on_message, context: {context}")
+        logger.info(f"on_message, client: {client}")
+        logger.info(f"on_message, event_profile: {event_profile}")
+        logger.info(f"on_message, event_body: {event_body}")
+        logger.info(f"on_message, say: {say}")
+
+        logger.info(f"Received message: {event_profile.text}")
+
+    def mention_me(
+        self, context: "AsyncBoltContext", body: SlackEventBody
+    ) -> bool:
+        r"""Check if the bot is mentioned in the message.
+
+        Args:
+            context (AsyncBoltContext): The Slack Bolt context for the event.
+            body (SlackEventBody): The body of the Slack event.
+
+        Returns:
+            bool: True if the bot is mentioned in the message, False otherwise.
+        """
+        message = body.event.text
+        bot_user_id = context.bot_user_id
+        mention = f"<@{bot_user_id}>"
+        return mention in message

owl/camel/bots/telegram_bot.py

@@ -0,0 +1,82 @@
+# ========= 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 typing import TYPE_CHECKING, Optional
+
+from camel.agents import ChatAgent
+from camel.messages import BaseMessage
+from camel.utils import dependencies_required
+
+# Conditionally import telebot types only for type checking
+if TYPE_CHECKING:
+    from telebot.types import (  # type: ignore[import-untyped]
+        Message,
+    )
+
+
+class TelegramBot:
+    r"""Represents a Telegram bot that is powered by an agent.
+
+    Attributes:
+        chat_agent (ChatAgent): Chat agent that will power the bot.
+        telegram_token (str, optional): The bot token.
+    """
+
+    @dependencies_required('telebot')
+    def __init__(
+        self,
+        chat_agent: ChatAgent,
+        telegram_token: Optional[str] = None,
+    ) -> None:
+        self.chat_agent = chat_agent
+
+        if not telegram_token:
+            self.token = os.getenv('TELEGRAM_TOKEN')
+            if not self.token:
+                raise ValueError(
+                    "`TELEGRAM_TOKEN` not found in environment variables. "
+                    "Get it from t.me/BotFather."
+                )
+        else:
+            self.token = telegram_token
+
+        import telebot  # type: ignore[import-untyped]
+
+        self.bot = telebot.TeleBot(token=self.token)
+
+        # Register the message handler within the constructor
+        self.bot.message_handler(func=lambda message: True)(self.on_message)
+
+    def run(self) -> None:
+        r"""Start the Telegram bot."""
+        print("Telegram bot is running...")
+        self.bot.infinity_polling()
+
+    def on_message(self, message: 'Message') -> None:
+        r"""Handles incoming messages from the user.
+
+        Args:
+            message (types.Message): The incoming message object.
+        """
+        self.chat_agent.reset()
+
+        if not message.text:
+            return
+
+        user_msg = BaseMessage.make_user_message(
+            role_name="User", content=message.text
+        )
+        assistant_response = self.chat_agent.step(user_msg)
+
+        self.bot.reply_to(message, assistant_response.msg.content)

owl/camel/configs/__init__.py

@@ -0,0 +1,76 @@
+# ========= 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 .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
+from .base_config import BaseConfig
+from .cohere_config import COHERE_API_PARAMS, CohereConfig
+from .deepseek_config import DEEPSEEK_API_PARAMS, DeepSeekConfig
+from .gemini_config import Gemini_API_PARAMS, GeminiConfig
+from .groq_config import GROQ_API_PARAMS, GroqConfig
+from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
+from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
+from .nvidia_config import NVIDIA_API_PARAMS, NvidiaConfig
+from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
+from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig
+from .qwen_config import QWEN_API_PARAMS, QwenConfig
+from .reka_config import REKA_API_PARAMS, RekaConfig
+from .samba_config import (
+    SAMBA_CLOUD_API_PARAMS,
+    SAMBA_VERSE_API_PARAMS,
+    SambaCloudAPIConfig,
+    SambaVerseAPIConfig,
+)
+from .togetherai_config import TOGETHERAI_API_PARAMS, TogetherAIConfig
+from .vllm_config import VLLM_API_PARAMS, VLLMConfig
+from .yi_config import YI_API_PARAMS, YiConfig
+from .zhipuai_config import ZHIPUAI_API_PARAMS, ZhipuAIConfig
+
+__all__ = [
+    'BaseConfig',
+    'ChatGPTConfig',
+    'OPENAI_API_PARAMS',
+    'AnthropicConfig',
+    'ANTHROPIC_API_PARAMS',
+    'GROQ_API_PARAMS',
+    'GroqConfig',
+    'LiteLLMConfig',
+    'LITELLM_API_PARAMS',
+    'NvidiaConfig',
+    'NVIDIA_API_PARAMS',
+    'OllamaConfig',
+    'OLLAMA_API_PARAMS',
+    'ZhipuAIConfig',
+    'ZHIPUAI_API_PARAMS',
+    'GeminiConfig',
+    'Gemini_API_PARAMS',
+    'VLLMConfig',
+    'VLLM_API_PARAMS',
+    'MistralConfig',
+    'MISTRAL_API_PARAMS',
+    'RekaConfig',
+    'REKA_API_PARAMS',
+    'SambaVerseAPIConfig',
+    'SAMBA_VERSE_API_PARAMS',
+    'SambaCloudAPIConfig',
+    'SAMBA_CLOUD_API_PARAMS',
+    'TogetherAIConfig',
+    'TOGETHERAI_API_PARAMS',
+    'CohereConfig',
+    'COHERE_API_PARAMS',
+    'YiConfig',
+    'YI_API_PARAMS',
+    'QwenConfig',
+    'QWEN_API_PARAMS',
+    'DeepSeekConfig',
+    'DEEPSEEK_API_PARAMS',
+]