refactor direactory

owl/app.py

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

owl/app_en.py

@@ -1,918 +0,0 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-import os
-import sys
-import gradio as gr
-import subprocess
-import threading
-import time
-from datetime import datetime
-import queue
-from pathlib import Path
-import json
-import signal
-import dotenv
-
-# Set up log queue
-log_queue: queue.Queue[str] = queue.Queue()
-
-# Currently running process
-current_process = None
-process_lock = threading.Lock()
-
-# Script options
-SCRIPTS = {
-    "Qwen Mini (Chinese)": "run_qwen_mini_zh.py",
-    "Qwen (Chinese)": "run_qwen_zh.py",
-    "Mini": "run_mini.py",
-    "DeepSeek (Chinese)": "run_deepseek_zh.py",
-    "Default": "run.py",
-    "GAIA Roleplaying": "run_gaia_roleplaying.py",
-    "OpenAI Compatible": "run_openai_compatiable_model.py",
-    "Ollama": "run_ollama.py",
-    "Terminal": "run_terminal.py",
-}
-
-# Script descriptions
-SCRIPT_DESCRIPTIONS = {
-    "Qwen Mini (Chinese)": "Uses the Chinese version of Alibaba Cloud's Qwen model, suitable for Chinese Q&A and tasks",
-    "Qwen (Chinese)": "Uses Alibaba Cloud's Qwen model, supports various tools and functions",
-    "Mini": "Lightweight version, uses OpenAI GPT-4o model",
-    "DeepSeek (Chinese)": "Uses DeepSeek model, suitable for non-multimodal tasks",
-    "Default": "Default OWL implementation, uses OpenAI GPT-4o model and full set of tools",
-    "GAIA Roleplaying": "GAIA benchmark implementation, used to evaluate model capabilities",
-    "OpenAI Compatible": "Uses third-party models compatible with OpenAI API, supports custom API endpoints",
-    "Ollama": "Uses Ollama API",
-    "Terminal": "Uses local terminal to execute python files",
-}
-
-# Environment variable groups
-ENV_GROUPS = {
-    "Model API": [
-        {
-            "name": "OPENAI_API_KEY",
-            "label": "OpenAI API Key",
-            "type": "password",
-            "required": False,
-            "help": "OpenAI API key for accessing GPT models. Get it from: https://platform.openai.com/api-keys",
-        },
-        {
-            "name": "OPENAI_API_BASE_URL",
-            "label": "OpenAI API Base URL",
-            "type": "text",
-            "required": False,
-            "help": "Base URL for OpenAI API, optional. Set this if using a proxy or custom endpoint.",
-        },
-        {
-            "name": "QWEN_API_KEY",
-            "label": "Alibaba Cloud Qwen API Key",
-            "type": "password",
-            "required": False,
-            "help": "Alibaba Cloud Qwen API key for accessing Qwen models. Get it from: https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key",
-        },
-        {
-            "name": "DEEPSEEK_API_KEY",
-            "label": "DeepSeek API Key",
-            "type": "password",
-            "required": False,
-            "help": "DeepSeek API key for accessing DeepSeek models. Get it from: https://platform.deepseek.com/api_keys",
-        },
-    ],
-    "Search Tools": [
-        {
-            "name": "GOOGLE_API_KEY",
-            "label": "Google API Key",
-            "type": "password",
-            "required": False,
-            "help": "Google Search API key for web search functionality. Get it from: https://developers.google.com/custom-search/v1/overview",
-        },
-        {
-            "name": "SEARCH_ENGINE_ID",
-            "label": "Search Engine ID",
-            "type": "text",
-            "required": False,
-            "help": "Google Custom Search Engine ID, used with Google API key. Get it from: https://developers.google.com/custom-search/v1/overview",
-        },
-    ],
-    "Other Tools": [
-        {
-            "name": "HF_TOKEN",
-            "label": "Hugging Face Token",
-            "type": "password",
-            "required": False,
-            "help": "Hugging Face API token for accessing Hugging Face models and datasets. Get it from: https://huggingface.co/join",
-        },
-        {
-            "name": "CHUNKR_API_KEY",
-            "label": "Chunkr API Key",
-            "type": "password",
-            "required": False,
-            "help": "Chunkr API key for document processing functionality. Get it from: https://chunkr.ai/",
-        },
-        {
-            "name": "FIRECRAWL_API_KEY",
-            "label": "Firecrawl API Key",
-            "type": "password",
-            "required": False,
-            "help": "Firecrawl API key for web crawling functionality. Get it from: https://www.firecrawl.dev/",
-        },
-    ],
-    "Custom Environment Variables": [],  # User-defined environment variables will be stored here
-}
-
-
-def get_script_info(script_name):
-    """Get detailed information about the script"""
-    return SCRIPT_DESCRIPTIONS.get(script_name, "No description available")
-
-
-def load_env_vars():
-    """Load environment variables"""
-    env_vars = {}
-    # Try to load from .env file
-    dotenv.load_dotenv()
-
-    # Get all environment variables
-    for group in ENV_GROUPS.values():
-        for var in group:
-            env_vars[var["name"]] = os.environ.get(var["name"], "")
-
-    # Load other environment variables that may exist in the .env file
-    if Path(".env").exists():
-        try:
-            with open(".env", "r", encoding="utf-8") as f:
-                for line in f:
-                    line = line.strip()
-                    if line and not line.startswith("#") and "=" in line:
-                        try:
-                            key, value = line.split("=", 1)
-                            key = key.strip()
-                            value = value.strip()
-
-                            # Handle quoted values
-                            if (value.startswith('"') and value.endswith('"')) or (
-                                value.startswith("'") and value.endswith("'")
-                            ):
-                                value = value[
-                                    1:-1
-                                ]  # Remove quotes at the beginning and end
-
-                            # Check if it's a known environment variable
-                            known_var = False
-                            for group in ENV_GROUPS.values():
-                                if any(var["name"] == key for var in group):
-                                    known_var = True
-                                    break
-
-                            # If it's not a known environment variable, add it to the custom environment variables group
-                            if not known_var and key not in env_vars:
-                                ENV_GROUPS["Custom Environment Variables"].append(
-                                    {
-                                        "name": key,
-                                        "label": key,
-                                        "type": "text",
-                                        "required": False,
-                                        "help": "User-defined environment variable",
-                                    }
-                                )
-                                env_vars[key] = value
-                        except Exception as e:
-                            print(
-                                f"Error parsing environment variable line: {line}, error: {str(e)}"
-                            )
-        except Exception as e:
-            print(f"Error loading .env file: {str(e)}")
-
-    return env_vars
-
-
-def save_env_vars(env_vars):
-    """Save environment variables to .env file"""
-    # Read existing .env file content
-    env_path = Path(".env")
-    existing_content = {}
-
-    if env_path.exists():
-        try:
-            with open(env_path, "r", encoding="utf-8") as f:
-                for line in f:
-                    line = line.strip()
-                    if line and not line.startswith("#") and "=" in line:
-                        try:
-                            key, value = line.split("=", 1)
-                            existing_content[key.strip()] = value.strip()
-                        except Exception as e:
-                            print(
-                                f"Error parsing environment variable line: {line}, error: {str(e)}"
-                            )
-        except Exception as e:
-            print(f"Error reading .env file: {str(e)}")
-
-    # Update environment variables
-    for key, value in env_vars.items():
-        if value is not None:  # Allow empty string values, but not None
-            # Ensure the value is a string
-            value = str(value)  # Ensure the value is a string
-
-            # Check if the value is already wrapped in quotes
-            if (value.startswith('"') and value.endswith('"')) or (
-                value.startswith("'") and value.endswith("'")
-            ):
-                # Already wrapped in quotes, keep as is
-                existing_content[key] = value
-                # Update environment variable by removing quotes
-                os.environ[key] = value[1:-1]
-            else:
-                # Not wrapped in quotes, add double quotes
-                # Wrap the value in double quotes to ensure special characters are handled correctly
-                quoted_value = f'"{value}"'
-                existing_content[key] = quoted_value
-                # Also update the environment variable for the current process (using the unquoted value)
-                os.environ[key] = value
-
-    # Write to .env file
-    try:
-        with open(env_path, "w", encoding="utf-8") as f:
-            for key, value in existing_content.items():
-                f.write(f"{key}={value}\n")
-    except Exception as e:
-        print(f"Error writing to .env file: {str(e)}")
-        return f"❌ Failed to save environment variables: {str(e)}"
-
-    return "✅ Environment variables saved"
-
-
-def add_custom_env_var(name, value, var_type):
-    """Add custom environment variable"""
-    if not name:
-        return "❌ Environment variable name cannot be empty", None
-
-    # Check if an environment variable with the same name already exists
-    for group in ENV_GROUPS.values():
-        if any(var["name"] == name for var in group):
-            return f"❌ Environment variable {name} already exists", None
-
-    # Add to custom environment variables group
-    ENV_GROUPS["Custom Environment Variables"].append(
-        {
-            "name": name,
-            "label": name,
-            "type": var_type,
-            "required": False,
-            "help": "User-defined environment variable",
-        }
-    )
-
-    # Save environment variables
-    env_vars = {name: value}
-    save_env_vars(env_vars)
-
-    # Return success message and updated environment variable group
-    return f"✅ Added environment variable {name}", ENV_GROUPS[
-        "Custom Environment Variables"
-    ]
-
-
-def update_custom_env_var(name, value, var_type):
-    """Update custom environment variable"""
-    if not name:
-        return "❌ Environment variable name cannot be empty", None
-
-    # Check if the environment variable exists in the custom environment variables group
-    found = False
-    for i, var in enumerate(ENV_GROUPS["Custom Environment Variables"]):
-        if var["name"] == name:
-            # Update type
-            ENV_GROUPS["Custom Environment Variables"][i]["type"] = var_type
-            found = True
-            break
-
-    if not found:
-        return f"❌ Custom environment variable {name} does not exist", None
-
-    # Save environment variable value
-    env_vars = {name: value}
-    save_env_vars(env_vars)
-
-    # Return success message and updated environment variable group
-    return f"✅ Updated environment variable {name}", ENV_GROUPS[
-        "Custom Environment Variables"
-    ]
-
-
-def delete_custom_env_var(name):
-    """Delete custom environment variable"""
-    if not name:
-        return "❌ Environment variable name cannot be empty", None
-
-    # Check if the environment variable exists in the custom environment variables group
-    found = False
-    for i, var in enumerate(ENV_GROUPS["Custom Environment Variables"]):
-        if var["name"] == name:
-            # Delete from custom environment variables group
-            del ENV_GROUPS["Custom Environment Variables"][i]
-            found = True
-            break
-
-    if not found:
-        return f"❌ Custom environment variable {name} does not exist", None
-
-    # Delete the environment variable from .env file
-    env_path = Path(".env")
-    if env_path.exists():
-        try:
-            with open(env_path, "r", encoding="utf-8") as f:
-                lines = f.readlines()
-
-            with open(env_path, "w", encoding="utf-8") as f:
-                for line in lines:
-                    try:
-                        # More precisely match environment variable lines
-                        line_stripped = line.strip()
-                        # Check if it's a comment line or empty line
-                        if not line_stripped or line_stripped.startswith("#"):
-                            f.write(line)  # Keep comment lines and empty lines
-                            continue
-
-                        # Check if it contains an equals sign
-                        if "=" not in line_stripped:
-                            f.write(line)  # Keep lines without equals sign
-                            continue
-
-                        # Extract variable name and check if it matches the variable to be deleted
-                        var_name = line_stripped.split("=", 1)[0].strip()
-                        if var_name != name:
-                            f.write(line)  # Keep variables that don't match
-                    except Exception as e:
-                        print(
-                            f"Error processing .env file line: {line}, error: {str(e)}"
-                        )
-                        # Keep the original line when an error occurs
-                        f.write(line)
-        except Exception as e:
-            print(f"Error deleting environment variable: {str(e)}")
-            return f"❌ Failed to delete environment variable: {str(e)}", None
-
-    # Delete from current process environment variables
-    if name in os.environ:
-        del os.environ[name]
-
-    # Return success message and updated environment variable group
-    return f"✅ Deleted environment variable {name}", ENV_GROUPS[
-        "Custom Environment Variables"
-    ]
-
-
-def terminate_process():
-    """Terminate the currently running process"""
-    global current_process
-
-    with process_lock:
-        if current_process is not None and current_process.poll() is None:
-            try:
-                # On Windows, use taskkill to forcibly terminate the process tree
-                if os.name == "nt":
-                    # Get process ID
-                    pid = current_process.pid
-                    # Use taskkill command to terminate the process and its children - avoid using shell=True for better security
-                    try:
-                        subprocess.run(
-                            ["taskkill", "/F", "/T", "/PID", str(pid)], check=False
-                        )
-                    except subprocess.SubprocessError as e:
-                        log_queue.put(f"Error terminating process: {str(e)}\n")
-                        return f"❌ Error terminating process: {str(e)}"
-                else:
-                    # On Unix, use SIGTERM and SIGKILL
-                    current_process.terminate()
-                    try:
-                        current_process.wait(timeout=3)
-                    except subprocess.TimeoutExpired:
-                        current_process.kill()
-
-                # Wait for process to terminate
-                try:
-                    current_process.wait(timeout=2)
-                except subprocess.TimeoutExpired:
-                    pass  # Already tried to force terminate, ignore timeout
-
-                log_queue.put("Process terminated\n")
-                return "✅ Process terminated"
-            except Exception as e:
-                log_queue.put(f"Error terminating process: {str(e)}\n")
-                return f"❌ Error terminating process: {str(e)}"
-        else:
-            return "❌ No process is currently running"
-
-
-def run_script(script_dropdown, question, progress=gr.Progress()):
-    """Run the selected script and return the output"""
-    global current_process
-
-    script_name = SCRIPTS.get(script_dropdown)
-    if not script_name:
-        return "❌ Invalid script selection", "", "", "", None
-
-    if not question.strip():
-        return "Please enter a question!", "", "", "", None
-
-    # Clear the log queue
-    while not log_queue.empty():
-        log_queue.get()
-
-    # Create log directory
-    log_dir = Path("logs")
-    log_dir.mkdir(exist_ok=True)
-
-    # Create log file with timestamp
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    log_file = log_dir / f"{script_name.replace('.py', '')}_{timestamp}.log"
-
-    # Build command
-    base_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    cmd = [
-        sys.executable,
-        os.path.join(base_path, "owl", "script_adapter.py"),
-        os.path.join(base_path, "owl", script_name),
-    ]
-
-    # Create a copy of environment variables and add the question
-    env = os.environ.copy()
-    # Ensure question is a string type
-    if not isinstance(question, str):
-        question = str(question)
-    # Preserve newlines, but ensure it's a valid string
-    env["OWL_QUESTION"] = question
-
-    # Start the process
-    with process_lock:
-        current_process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-            bufsize=1,
-            env=env,
-            encoding="utf-8",
-        )
-
-    # Create thread to read output
-    def read_output():
-        try:
-            # Use a unique timestamp to ensure log filename is not duplicated
-            timestamp_unique = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
-            unique_log_file = (
-                log_dir / f"{script_name.replace('.py', '')}_{timestamp_unique}.log"
-            )
-
-            # Use this unique filename to write logs
-            with open(unique_log_file, "w", encoding="utf-8") as f:
-                # Update global log file path
-                nonlocal log_file
-                log_file = unique_log_file
-
-                for line in iter(current_process.stdout.readline, ""):
-                    if line:
-                        # Write to log file
-                        f.write(line)
-                        f.flush()
-                        # Add to queue
-                        log_queue.put(line)
-        except Exception as e:
-            log_queue.put(f"Error reading output: {str(e)}\n")
-
-    # Start the reading thread
-    threading.Thread(target=read_output, daemon=True).start()
-
-    # Collect logs
-    logs = []
-    progress(0, desc="Running...")
-
-    # Wait for process to complete or timeout
-    start_time = time.time()
-    timeout = 1800  # 30 minutes timeout
-
-    while current_process.poll() is None:
-        # Check if timeout
-        if time.time() - start_time > timeout:
-            with process_lock:
-                if current_process.poll() is None:
-                    if os.name == "nt":
-                        current_process.send_signal(signal.CTRL_BREAK_EVENT)
-                    else:
-                        current_process.terminate()
-                    log_queue.put("Execution timeout, process terminated\n")
-            break
-
-        # Get logs from queue
-        while not log_queue.empty():
-            log = log_queue.get()
-            logs.append(log)
-
-        # Update progress
-        elapsed = time.time() - start_time
-        progress(min(elapsed / 300, 0.99), desc="Running...")
-
-        # Short sleep to reduce CPU usage
-        time.sleep(0.1)
-
-        # Update log display once per second
-        yield (
-            status_message(current_process),
-            extract_answer(logs),
-            "".join(logs),
-            str(log_file),
-            None,
-        )
-
-    # Get remaining logs
-    while not log_queue.empty():
-        logs.append(log_queue.get())
-
-    # Extract chat history (if any)
-    chat_history = extract_chat_history(logs)
-
-    # Return final status and logs
-    return (
-        status_message(current_process),
-        extract_answer(logs),
-        "".join(logs),
-        str(log_file),
-        chat_history,
-    )
-
-
-def status_message(process):
-    """Return status message based on process status"""
-    if process.poll() is None:
-        return "⏳ Running..."
-    elif process.returncode == 0:
-        return "✅ Execution successful"
-    else:
-        return f"❌ Execution failed (return code: {process.returncode})"
-
-
-def extract_answer(logs):
-    """Extract answer from logs"""
-    answer = ""
-    for log in logs:
-        if "Answer:" in log:
-            answer = log.split("Answer:", 1)[1].strip()
-            break
-    return answer
-
-
-def extract_chat_history(logs):
-    """Try to extract chat history from logs"""
-    try:
-        chat_json_str = ""
-        capture_json = False
-
-        for log in logs:
-            if "chat_history" in log:
-                # Start capturing JSON
-                start_idx = log.find("[")
-                if start_idx != -1:
-                    capture_json = True
-                    chat_json_str = log[start_idx:]
-            elif capture_json:
-                # Continue capturing JSON until finding the matching closing bracket
-                chat_json_str += log
-                if "]" in log:
-                    # Found closing bracket, try to parse JSON
-                    end_idx = chat_json_str.rfind("]") + 1
-                    if end_idx > 0:
-                        try:
-                            # Clean up possible extra text
-                            json_str = chat_json_str[:end_idx].strip()
-                            chat_data = json.loads(json_str)
-
-                            # Format for use with Gradio chat component
-                            formatted_chat = []
-                            for msg in chat_data:
-                                if "role" in msg and "content" in msg:
-                                    role = (
-                                        "User" if msg["role"] == "user" else "Assistant"
-                                    )
-                                    formatted_chat.append([role, msg["content"]])
-                            return formatted_chat
-                        except json.JSONDecodeError:
-                            # If parsing fails, continue capturing
-                            pass
-                        except Exception:
-                            # Other errors, stop capturing
-                            capture_json = False
-    except Exception:
-        pass
-    return None
-
-
-def create_ui():
-    """Create Gradio interface"""
-    # Load environment variables
-    env_vars = load_env_vars()
-
-    with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue")) as app:
-        gr.Markdown(
-            """
-            # 🦉 OWL Intelligent Assistant Platform
-
-            Select a model and enter your question, the system will run the corresponding script and display the results.
-            """
-        )
-
-        with gr.Tabs():
-            with gr.TabItem("Run Mode"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        # Ensure default value is a key that exists in SCRIPTS
-                        default_script = list(SCRIPTS.keys())[0] if SCRIPTS else None
-                        script_dropdown = gr.Dropdown(
-                            choices=list(SCRIPTS.keys()),
-                            value=default_script,
-                            label="Select Mode",
-                        )
-
-                        script_info = gr.Textbox(
-                            value=get_script_info(default_script)
-                            if default_script
-                            else "",
-                            label="Model Description",
-                            interactive=False,
-                        )
-
-                        script_dropdown.change(
-                            fn=lambda x: get_script_info(x),
-                            inputs=script_dropdown,
-                            outputs=script_info,
-                        )
-
-                        question_input = gr.Textbox(
-                            lines=8,
-                            placeholder="Please enter your question...",
-                            label="Question",
-                            elem_id="question_input",
-                            show_copy_button=True,
-                        )
-
-                        gr.Markdown(
-                            """
-                            > **Note**: Your question will replace the default question in the script. The system will automatically handle the replacement, ensuring your question is used correctly.
-                            > Multi-line input is supported, line breaks will be preserved.
-                            """
-                        )
-
-                        with gr.Row():
-                            run_button = gr.Button("Run", variant="primary")
-                            stop_button = gr.Button("Stop", variant="stop")
-
-                    with gr.Column(scale=2):
-                        with gr.Tabs():
-                            with gr.TabItem("Results"):
-                                status_output = gr.Textbox(label="Status")
-                                answer_output = gr.Textbox(label="Answer", lines=10)
-                                log_file_output = gr.Textbox(label="Log File Path")
-
-                            with gr.TabItem("Run Logs"):
-                                log_output = gr.Textbox(label="Complete Logs", lines=25)
-
-                            with gr.TabItem("Chat History"):
-                                chat_output = gr.Chatbot(label="Conversation History")
-
-                # Example questions
-                examples = [
-                    [
-                        "Qwen Mini (Chinese)",
-                        "Browse Amazon and find a product that is attractive to programmers. Please provide the product name and price.",
-                    ],
-                    [
-                        "DeepSeek (Chinese)",
-                        "Please analyze the latest statistics of the CAMEL-AI project on GitHub. Find out the number of stars, number of contributors, and recent activity of the project. Then, create a simple Excel spreadsheet to display this data and generate a bar chart to visualize these metrics. Finally, summarize the popularity and development trends of the CAMEL project.",
-                    ],
-                    [
-                        "Default",
-                        "Navigate to Amazon.com and identify one product that is attractive to coders. Please provide me with the product name and price. No need to verify your answer.",
-                    ],
-                ]
-
-                gr.Examples(examples=examples, inputs=[script_dropdown, question_input])
-
-            with gr.TabItem("Environment Variable Configuration"):
-                env_inputs = {}
-                save_status = gr.Textbox(label="Save Status", interactive=False)
-
-                # Add custom environment variables section
-                with gr.Accordion("Add Custom Environment Variables", open=True):
-                    with gr.Row():
-                        new_var_name = gr.Textbox(
-                            label="Environment Variable Name",
-                            placeholder="Example: MY_CUSTOM_API_KEY",
-                        )
-                        new_var_value = gr.Textbox(
-                            label="Environment Variable Value",
-                            placeholder="Enter value",
-                        )
-                        new_var_type = gr.Dropdown(
-                            choices=["text", "password"], value="text", label="Type"
-                        )
-
-                    add_var_button = gr.Button(
-                        "Add Environment Variable", variant="primary"
-                    )
-                    add_var_status = gr.Textbox(label="Add Status", interactive=False)
-
-                    # Custom environment variables list
-                    custom_vars_list = gr.JSON(
-                        value=ENV_GROUPS["Custom Environment Variables"],
-                        label="Added Custom Environment Variables",
-                        visible=len(ENV_GROUPS["Custom Environment Variables"]) > 0,
-                    )
-
-                # Update and delete custom environment variables section
-                with gr.Accordion(
-                    "Update or Delete Custom Environment Variables",
-                    open=True,
-                    visible=len(ENV_GROUPS["Custom Environment Variables"]) > 0,
-                ) as update_delete_accordion:
-                    with gr.Row():
-                        # Create dropdown menu to display all custom environment variables
-                        custom_var_dropdown = gr.Dropdown(
-                            choices=[
-                                var["name"]
-                                for var in ENV_GROUPS["Custom Environment Variables"]
-                            ],
-                            label="Select Environment Variable",
-                            interactive=True,
-                        )
-                        update_var_value = gr.Textbox(
-                            label="New Environment Variable Value",
-                            placeholder="Enter new value",
-                        )
-                        update_var_type = gr.Dropdown(
-                            choices=["text", "password"], value="text", label="Type"
-                        )
-
-                    with gr.Row():
-                        update_var_button = gr.Button(
-                            "Update Environment Variable", variant="primary"
-                        )
-                        delete_var_button = gr.Button(
-                            "Delete Environment Variable", variant="stop"
-                        )
-
-                    update_var_status = gr.Textbox(
-                        label="Operation Status", interactive=False
-                    )
-
-                # Add environment variable button click event
-                add_var_button.click(
-                    fn=add_custom_env_var,
-                    inputs=[new_var_name, new_var_value, new_var_type],
-                    outputs=[add_var_status, custom_vars_list],
-                ).then(
-                    fn=lambda vars: {"visible": len(vars) > 0},
-                    inputs=[custom_vars_list],
-                    outputs=[update_delete_accordion],
-                )
-
-                # Update environment variable button click event
-                update_var_button.click(
-                    fn=update_custom_env_var,
-                    inputs=[custom_var_dropdown, update_var_value, update_var_type],
-                    outputs=[update_var_status, custom_vars_list],
-                )
-
-                # Delete environment variable button click event
-                delete_var_button.click(
-                    fn=delete_custom_env_var,
-                    inputs=[custom_var_dropdown],
-                    outputs=[update_var_status, custom_vars_list],
-                ).then(
-                    fn=lambda vars: {"visible": len(vars) > 0},
-                    inputs=[custom_vars_list],
-                    outputs=[update_delete_accordion],
-                )
-
-                # When custom environment variables list is updated, update dropdown menu options
-                custom_vars_list.change(
-                    fn=lambda vars: {
-                        "choices": [var["name"] for var in vars],
-                        "value": None,
-                    },
-                    inputs=[custom_vars_list],
-                    outputs=[custom_var_dropdown],
-                )
-
-                # Existing environment variable configuration
-                for group_name, vars in ENV_GROUPS.items():
-                    if (
-                        group_name != "Custom Environment Variables" or len(vars) > 0
-                    ):  # Only show non-empty custom environment variable groups
-                        with gr.Accordion(
-                            group_name,
-                            open=(group_name != "Custom Environment Variables"),
-                        ):
-                            for var in vars:
-                                # Add help information
-                                gr.Markdown(f"**{var['help']}**")
-
-                                if var["type"] == "password":
-                                    env_inputs[var["name"]] = gr.Textbox(
-                                        value=env_vars.get(var["name"], ""),
-                                        label=var["label"],
-                                        placeholder=f"Please enter {var['label']}",
-                                        type="password",
-                                    )
-                                else:
-                                    env_inputs[var["name"]] = gr.Textbox(
-                                        value=env_vars.get(var["name"], ""),
-                                        label=var["label"],
-                                        placeholder=f"Please enter {var['label']}",
-                                    )
-
-                save_button = gr.Button("Save Environment Variables", variant="primary")
-
-                # Save environment variables
-                save_inputs = [
-                    env_inputs[var_name]
-                    for group in ENV_GROUPS.values()
-                    for var in group
-                    for var_name in [var["name"]]
-                    if var_name in env_inputs
-                ]
-                save_button.click(
-                    fn=lambda *values: save_env_vars(
-                        dict(
-                            zip(
-                                [
-                                    var["name"]
-                                    for group in ENV_GROUPS.values()
-                                    for var in group
-                                    if var["name"] in env_inputs
-                                ],
-                                values,
-                            )
-                        )
-                    ),
-                    inputs=save_inputs,
-                    outputs=save_status,
-                )
-
-        # Run script
-        run_button.click(
-            fn=run_script,
-            inputs=[script_dropdown, question_input],
-            outputs=[
-                status_output,
-                answer_output,
-                log_output,
-                log_file_output,
-                chat_output,
-            ],
-            show_progress=True,
-        )
-
-        # Terminate execution
-        stop_button.click(fn=terminate_process, inputs=[], outputs=[status_output])
-
-        # Add footer
-        gr.Markdown(
-            """
-            ### 📝 Instructions
-
-            - Select a model and enter your question
-            - Click the "Run" button to start execution
-            - To stop execution, click the "Stop" button
-            - View execution status and answers in the "Results" tab
-            - View complete logs in the "Run Logs" tab
-            - View conversation history in the "Chat History" tab (if available)
-            - Configure API keys and other environment variables in the "Environment Variable Configuration" tab
-            - You can add custom environment variables to meet special requirements
-
-            ### ⚠️ Notes
-
-            - Running some models may require API keys, please make sure you have set the corresponding environment variables in the "Environment Variable Configuration" tab
-            - Some scripts may take a long time to run, please be patient
-            - If execution exceeds 30 minutes, the process will automatically terminate
-            - Your question will replace the default question in the script, ensure the question is compatible with the selected model
-            """
-        )
-
-    return app
-
-
-if __name__ == "__main__":
-    # Create and launch the application
-    app = create_ui()
-    app.queue().launch(share=True)

owl/script_adapter.py

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

owl/webapp.py

@@ -0,0 +1,400 @@
+# Import from the correct module path
+from owl.utils import run_society
+import os
+import gradio as gr
+import time
+import json
+from typing import Tuple, List, Dict, Any
+import importlib
+
+# Enhanced CSS with navigation bar and additional styling
+custom_css = """
+:root {
+    --primary-color: #1e3c72;
+    --secondary-color: #2a5298;
+    --accent-color: #4776E6;
+    --light-bg: #f8f9fa;
+    --border-color: #dee2e6;
+    --text-muted: #6c757d;
+}
+
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+}
+
+.navbar {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 15px 30px;
+    background: linear-gradient(90deg, var(--primary-color), var(--secondary-color));
+    color: white;
+    border-radius: 10px 10px 0 0;
+    margin-bottom: 0;
+}
+
+.navbar-logo {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    font-size: 1.5em;
+    font-weight: bold;
+}
+
+.navbar-menu {
+    display: flex;
+    gap: 20px;
+}
+
+.navbar-menu a {
+    color: white;
+    text-decoration: none;
+    padding: 5px 10px;
+    border-radius: 5px;
+    transition: background-color 0.3s;
+}
+
+.navbar-menu a:hover {
+    background-color: rgba(255, 255, 255, 0.1);
+}
+
+.header {
+    text-align: center;
+    margin-bottom: 20px;
+    background: linear-gradient(180deg, var(--secondary-color), var(--accent-color));
+    color: white;
+    padding: 40px 20px;
+    border-radius: 0 0 10px 10px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.module-info {
+    background-color: var(--light-bg);
+    border-left: 5px solid var(--primary-color);
+    padding: 10px 15px;
+    margin-top: 10px;
+    border-radius: 5px;
+    font-size: 0.9em;
+}
+
+.answer-box {
+    background-color: var(--light-bg);
+    border-left: 5px solid var(--secondary-color);
+    padding: 15px;
+    margin-bottom: 20px;
+    border-radius: 5px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+}
+
+.token-count {
+    background-color: #e9ecef;
+    padding: 10px;
+    border-radius: 5px;
+    text-align: center;
+    font-weight: bold;
+    margin-bottom: 20px;
+}
+
+.chat-container {
+    border: 1px solid var(--border-color);
+    border-radius: 5px;
+    max-height: 500px;
+    overflow-y: auto;
+    margin-bottom: 20px;
+}
+
+.footer {
+    text-align: center;
+    margin-top: 20px;
+    color: var(--text-muted);
+    font-size: 0.9em;
+    padding: 20px;
+    border-top: 1px solid var(--border-color);
+}
+
+.features-section {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 20px;
+    margin: 20px 0;
+}
+
+.feature-card {
+    background-color: white;
+    border-radius: 8px;
+    padding: 20px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+    transition: transform 0.3s, box-shadow 0.3s;
+}
+
+.feature-card:hover {
+    transform: translateY(-5px);
+    box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1);
+}
+
+.feature-icon {
+    font-size: 2em;
+    color: var(--primary-color);
+    margin-bottom: 10px;
+}
+
+/* Improved button and input styles */
+button.primary {
+    background: linear-gradient(90deg, var(--primary-color), var(--secondary-color));
+    transition: all 0.3s;
+}
+
+button.primary:hover {
+    background: linear-gradient(90deg, var(--secondary-color), var(--primary-color));
+    transform: translateY(-2px);
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.15);
+}
+"""
+
+# Dictionary containing module descriptions
+MODULE_DESCRIPTIONS = {
+    "run": "默认模式：使用默认的智能体协作模式，适合大多数任务。",
+    "run_mini":"使用最小化配置处理任务",
+    "run_deepseek_zh":"使用deepseek模型处理中文任务",
+    "run_terminal_zh": "终端模式：可执行命令行操作，支持网络搜索、文件处理等功能。适合需要系统交互的任务。",
+    "run_mini": "精简模式：轻量级智能体协作，适合快速回答和简单任务处理，响应速度更快。",
+    "run_gaia_roleplaying":"GAIA基准测试实现，用于评估模型能力",
+    "run_openai_compatiable_model":"使用openai兼容模型处理任务",
+    "run_ollama":"使用本地ollama模型处理任务",
+    "run_qwen_mini_zh":"使用qwen模型处理中文任务",
+    "run_qwen_zh":"使用qwen模型处理任务",
+ 
+    
+   
+}
+
+def format_chat_history(chat_history: List[Dict[str, str]]) -> List[List[str]]:
+    """将聊天历史格式化为Gradio聊天组件可接受的格式
+    
+    Args:
+        chat_history: 原始聊天历史
+        
+    Returns:
+        List[List[str]]: 格式化后的聊天历史
+    """
+    formatted_history = []
+    for message in chat_history:
+        user_msg = message.get("user", "")
+        assistant_msg = message.get("assistant", "")
+        
+        if user_msg:
+            formatted_history.append([user_msg, None])
+        if assistant_msg and formatted_history:
+            formatted_history[-1][1] = assistant_msg
+        elif assistant_msg:
+            formatted_history.append([None, assistant_msg])
+    
+    return formatted_history
+
+def run_owl(question: str, example_module: str) -> Tuple[str, List[List[str]], str, str]:
+    """运行OWL系统并返回结果
+    
+    Args:
+        question: 用户问题
+        example_module: 要导入的示例模块名（如 "run_terminal_zh" 或 "run_deep"）
+        
+    Returns:
+        Tuple[...]: 回答、聊天历史、令牌计数、状态
+    """
+    try:
+        # 动态导入目标模块
+        module_path = f"owl.examples.{example_module}"
+        module = importlib.import_module(module_path)
+        
+        # 检查是否包含construct_society函数
+        if not hasattr(module, "construct_society"):
+            raise AttributeError(f"模块 {module_path} 中未找到 construct_society 函数")
+            
+        # 构建社会模拟
+        society = module.construct_society(question)
+        
+        # 运行社会模拟（假设run_society兼容不同模块）
+        answer, chat_history, token_info = run_society(society)
+        
+        # 格式化和令牌计数（与原逻辑一致）
+        formatted_chat_history = format_chat_history(chat_history)
+        total_tokens = token_info["completion_token_count"] + token_info["prompt_token_count"]
+        
+        return (
+            answer, 
+            formatted_chat_history, 
+            f"完成令牌: {token_info['completion_token_count']:,} | 提示令牌: {token_info['prompt_token_count']:,} | 总计: {total_tokens:,}", 
+            "✅ 成功完成"
+        )
+        
+    except Exception as e:
+        return (
+            f"发生错误: {str(e)}", 
+            [], 
+            "0", 
+            f"❌ 错误: {str(e)}"
+        )
+
+def update_module_description(module_name: str) -> str:
+    """返回所选模块的描述"""
+    return MODULE_DESCRIPTIONS.get(module_name, "无可用描述")
+
+def create_ui():
+    """创建增强版Gradio界面"""
+    with gr.Blocks(css=custom_css, theme=gr.themes.Soft(primary_hue="blue")) as app:
+        with gr.Column(elem_classes="container"):
+            gr.HTML("""
+                <div class="navbar">
+                    <div class="navbar-logo">
+                        🦉 OWL 智能助手
+                    </div>
+                    <div class="navbar-menu">
+                        <a href="#home">首页</a>
+                        <a href="#features">功能</a>
+                        <a href="#about">关于</a>
+                        <a href="#docs">文档</a>
+                        <a href="#contact">联系我们</a>
+                    </div>
+                </div>
+                <div class="header" id="home">
+                    <h1>多智能体协作系统</h1>
+                    <p>基于CAMEL框架的先进多智能体协作平台，解决复杂问题的智能解决方案</p>
+                </div>
+            """)
+            
+            with gr.Row(elem_id="features"):
+                gr.HTML("""
+                    <div class="features-section">
+                        <div class="feature-card">
+                            <div class="feature-icon">🔍</div>
+                            <h3>智能信息获取</h3>
+                            <p>自动化网络搜索和数据收集，提供精准信息</p>
+                        </div>
+                        <div class="feature-card">
+                            <div class="feature-icon">🤖</div>
+                            <h3>多智能体协作</h3>
+                            <p>多个专家智能体协同工作，解决复杂问题</p>
+                        </div>
+                        <div class="feature-card">
+                            <div class="feature-icon">📊</div>
+                            <h3>数据分析与可视化</h3>
+                            <p>强大的数据分析能力，生成直观的可视化结果</p>
+                        </div>
+                    </div>
+                """)
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    question_input = gr.Textbox(
+                        lines=5,
+                        placeholder="请输入您的问题...",
+                        label="问题",
+                        elem_id="question_input",
+                        show_copy_button=True,
+                    )
+                    
+                    # 增强版模块选择下拉菜单
+                    module_dropdown = gr.Dropdown(
+                        choices=["run", "run_mini","run_terminal_zh","run_gaia_roleplaying",
+                                 "run_openai_compatiable_model","run_ollama","run_qwen_zh","run_qwen_mini_zh","run_deepseek_zh","run_terminal"],
+                        value="run_terminal_zh",
+                        label="选择功能模块",
+                        interactive=True
+                    )
+                    
+                    # 模块描述文本框
+                    module_description = gr.Textbox(
+                        value=MODULE_DESCRIPTIONS["run_terminal_zh"],
+                        label="模块描述",
+                        interactive=False,
+                        elem_classes="module-info"
+                    )
+                    
+                    run_button = gr.Button("运行", variant="primary", elem_classes="primary")
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    ### 使用指南
+                    
+                    1. **选择适合的模块**：根据您的任务需求选择合适的功能模块
+                    2. **详细描述您的需求**：在输入框中清晰描述您的问题或任务
+                    3. **启动智能处理**：点击"运行"按钮开始多智能体协作处理
+                    4. **查看结果**：在下方标签页查看回答和完整对话历史
+                    
+                    > **高级提示**: 对于复杂任务，可以尝试指定具体步骤和预期结果
+                    """)
+            
+            status_output = gr.Textbox(label="状态", interactive=False)
+            
+            with gr.Tabs():
+                with gr.TabItem("回答"):
+                    answer_output = gr.Textbox(
+                        label="回答", 
+                        lines=10,
+                        elem_classes="answer-box"
+                    )
+                
+                with gr.TabItem("对话历史"):
+                    chat_output = gr.Chatbot(
+                        label="完整对话记录",
+                        elem_classes="chat-container",
+                        height=500
+                    )
+                    
+                
+            
+            token_count_output = gr.Textbox(
+                label="令牌计数", 
+                interactive=False,
+                elem_classes="token-count"
+            )
+            
+            # 示例问题
+            examples = [
+                "打开百度搜索，总结一下camel-ai的camel框架的github star、fork数目等，并把数字用plot包写成python文件保存到本地，用本地终端执行python文件显示图出来给我",
+                "请分析GitHub上CAMEL-AI项目的最新统计数据。找出该项目的星标数量、贡献者数量和最近的活跃度。",
+                "浏览亚马逊并找出一款对程序员有吸引力的产品。请提供产品名称和价格",
+                "写一个hello world的python文件，保存到本地",
+             
+            ]
+            
+            gr.Examples(
+                examples=examples, 
+                inputs=question_input
+            )
+            
+            gr.HTML("""
+                <div class="footer" id="about">
+                    <h3>关于 OWL 智能助手</h3>
+                    <p>OWL 是一个基于CAMEL框架开发的先进多智能体协作系统，旨在通过智能体协作解决复杂问题。</p>
+                    <p>© 2024 CAMEL-AI.org. 基于Apache License 2.0开源协议</p>
+                    <p><a href="https://github.com/camel-ai/camel" target="_blank">GitHub</a> | 
+                       <a href="#docs">文档</a> | 
+                       <a href="#contact" id="contact">联系我们</a></p>
+                </div>
+            """)
+            
+            # 设置事件处理
+            run_button.click(
+                fn=run_owl,
+                inputs=[question_input, module_dropdown], 
+                outputs=[answer_output, chat_output, token_count_output, status_output]
+            )
+            
+            # 模块选择更新描述
+            module_dropdown.change(
+                fn=update_module_description,
+                inputs=module_dropdown,
+                outputs=module_description
+            )
+    
+    return app
+
+# 主函数
+def main():
+    app = create_ui()
+    app.launch(share=False)
+
+if __name__ == "__main__":
+    main()

run_app.py

@@ -1,62 +0,0 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-OWL Intelligent Assistant Platform Launch Script
-"""
-
-import os
-import sys
-from pathlib import Path
-
-os.environ['PYTHONIOENCODING'] = 'utf-8'
-
-def main():
-    """Main function to launch the OWL Intelligent Assistant Platform"""
-    # Ensure the current directory is the project root
-    project_root = Path(__file__).resolve().parent
-    os.chdir(project_root)
-
-    # Create log directory
-    log_dir = project_root / "logs"
-    log_dir.mkdir(exist_ok=True)
-
-    # Add project root to Python path
-    sys.path.insert(0, str(project_root))
-
-    try:
-        from owl.app_en import create_ui
-
-        # Create and launch the application
-        app = create_ui()
-        app.queue().launch(share=False)
-
-    except ImportError as e:
-        print(
-            f"Error: Unable to import necessary modules. Please ensure all dependencies are installed: {e}"
-        )
-        print("Tip: Run 'pip install -r requirements.txt' to install all dependencies")
-        sys.exit(1)
-    except Exception as e:
-        print(f"Error occurred while starting the application: {e}")
-        import traceback
-
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

run_app_zh.py

@@ -1,60 +0,0 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-OWL 智能助手运行平台启动脚本
-"""
-
-import os
-import sys
-from pathlib import Path
-
-os.environ['PYTHONIOENCODING'] = 'utf-8'
-
-def main():
-    """主函数，启动OWL智能助手运行平台"""
-    # 确保当前目录是项目根目录
-    project_root = Path(__file__).resolve().parent
-    os.chdir(project_root)
-
-    # 创建日志目录
-    log_dir = project_root / "logs"
-    log_dir.mkdir(exist_ok=True)
-
-    # 导入并运行应用
-    sys.path.insert(0, str(project_root))
-
-    try:
-        from owl.app import create_ui
-
-        # 创建并启动应用
-        app = create_ui()
-        app.queue().launch(share=False)
-
-    except ImportError as e:
-        print(f"错误: 无法导入必要的模块。请确保已安装所有依赖项: {e}")
-        print("提示: 运行 'pip install -r requirements.txt' 安装所有依赖项")
-        sys.exit(1)
-    except Exception as e:
-        print(f"启动应用程序时出错: {e}")
-        import traceback
-
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()