Switch to Docker SDK to fix dependency conflicts

- Add Dockerfile with python:3.10-slim base image
- Pin gradio==5.23.1 and huggingface_hub==0.23.0 in requirements.txt
- Change sdk from gradio to docker in README.md
- This resolves the HfFolder import error from huggingface_hub

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 7860
+
+# Set environment variables
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+ENV GRADIO_SERVER_PORT="7860"
+
+# Run the application
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,48 @@
+---
+title: Tongyi DeepResearch
+emoji: 🔍
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+# Tongyi DeepResearch
+
+A leading open-source Deep Research Agent that conducts thorough, multi-source investigations into any topic.
+
+## Features
+
+- 🔍 **Web Search**: Perform Google web searches to find relevant information
+- 📚 **Academic Search**: Leverage Google Scholar for academic publications
+- 🌐 **Web Visiting**: Visit webpages and extract useful information
+- 🐍 **Python Interpreter**: Execute Python code in a sandboxed environment
+
+## Environment Variables
+
+To run this application, you need to set the following environment variables:
+
+| Variable | Description |
+|----------|-------------|
+| `DR_MODEL_NAME` | The name of the LLM model to use |
+| `DR_MODEL_SERVER` | The API endpoint of the model server |
+| `DR_MODEL_API_KEY` | The API key for the model server |
+| `SERPER_KEY_ID` | API key for Serper.dev (Google Search) |
+| `JINA_KEY` | API key for Jina.ai (Web Reading) |
+| `SANDBOX_URL` | URL of the sandbox fusion endpoint for Python execution |
+| `API_KEY` | API key for the summary model |
+| `API_BASE` | Base URL for the summary model API |
+
+## Usage
+
+1. Clone this repository
+2. Set up the environment variables
+3. Run `python app.py`
+4. Open your browser and navigate to `http://localhost:7860`
+
+## License
+
+Apache-2.0
+

agents/__init__.py

@@ -0,0 +1,4 @@
+from .search_agent import SearchAgent
+
+__all__ = ['SearchAgent']
+

agents/search_agent.py

@@ -0,0 +1,126 @@
+import copy
+from typing import Dict, Iterator, List, Literal, Union, Optional
+
+from qwen_agent.agents import Assistant
+from qwen_agent.llm import BaseChatModel
+from qwen_agent.llm.schema import USER, FUNCTION, Message, DEFAULT_SYSTEM_MESSAGE, SYSTEM, ROLE
+from qwen_agent.tools import BaseTool
+from qwen_agent.log import logger
+
+
+class SearchAgent(Assistant):
+    def __init__(self,
+                 function_list: Optional[List[Union[str, Dict, BaseTool]]] = None,
+                 llm: Optional[Union[Dict, BaseChatModel]] = None,
+                 system_message: Optional[str] = DEFAULT_SYSTEM_MESSAGE,
+                 name: Optional[str] = None,
+                 description: Optional[str] = None,
+                 files: Optional[List[str]] = None,
+                 rag_cfg: Optional[Dict] = None,
+                 extra: Optional[Dict] = {},
+                 custom_user_prompt: Optional[str] = '',
+                 make_system_prompt=None,
+                 addtional_agent=None):
+        super().__init__(function_list=function_list,
+                         llm=llm,
+                         system_message=system_message,
+                         name=name,
+                         description=description,
+                         files=files,
+                         rag_cfg=rag_cfg)
+        self.extra = extra
+        self.custom_user_prompt = custom_user_prompt
+        self.make_system_prompt = make_system_prompt
+        self.addtional_agent = addtional_agent
+
+    def insert_in_custom_user_prompt(self, messages: List[Message]) -> List[Message]:
+        for message in messages:
+            if message.role == USER:
+                message.content[0].text = self.custom_user_prompt + message.content[0].text
+                break
+        return messages
+
+    def _run(self,
+             messages: List[Message],
+             lang: Literal['en', 'zh'] = 'zh',
+             knowledge: str = '',
+             **kwargs) -> Iterator[List[Message]]:
+        messages = self._prepend_knowledge_prompt(messages=messages,
+                                                  lang=lang,
+                                                  knowledge=knowledge,
+                                                  **kwargs)
+        messages = copy.deepcopy(messages)
+        self.insert_in_custom_user_prompt(messages=messages)
+
+        if self.make_system_prompt:
+            if not messages or messages[0][ROLE] != SYSTEM:
+                messages.insert(0, Message(role=SYSTEM, content=self.make_system_prompt()))
+
+        for msg in messages:
+            if isinstance(msg.content, list):
+                assert len(msg.content) == 1
+                msg.content = msg.content[0].text
+            if msg.role == USER:
+                msg.content = msg.content.strip()
+
+        reasoning = self.extra.get('reasoning', True)
+        num_llm_calls_available = self.extra.get('max_llm_calls', 20)
+
+        response = []
+        while True and num_llm_calls_available > 0:
+            num_llm_calls_available -= 1
+
+            extra_generate_cfg = {'lang': lang}
+            if kwargs.get('seed') is not None:
+                extra_generate_cfg['seed'] = kwargs['seed']
+
+            output_stream = self._call_llm(messages=messages,
+                                           functions=[func.function for func in self.function_map.values()],
+                                           extra_generate_cfg=extra_generate_cfg)
+
+            output: List[Message] = []
+            for output in output_stream:
+                if output:
+                    first_msg = output[0]
+                    if reasoning and isinstance(first_msg.content, str):
+                        first_msg.content = "<think>\n" + first_msg.content.strip()
+                    yield response + output
+
+            if output:
+                response.extend(output)
+                messages.extend(output)
+
+            used_any_tool = False
+            for out in output:
+                print("out:\n", out)
+                print("output:\n", output)
+                use_tool, tool_name, tool_args, _ = self._detect_tool(out)
+                logger.info(f"{self.name} use_tool: {use_tool}, tool_name: {tool_name}, tool_args: {tool_args}")
+
+                if use_tool:
+                    tool_result = self._call_tool(tool_name, tool_args, messages=messages, **kwargs)
+                    fn_msg = Message(
+                        role=FUNCTION,
+                        name=tool_name,
+                        content=tool_result,
+                    )
+                    messages.append(fn_msg)
+                    used_any_tool = True
+
+            if not used_any_tool:
+                logger.info(f'{self.name} not used any tool, skip out')
+                break
+
+        yield response
+
+        if self.addtional_agent:
+            new_messages = copy.deepcopy(messages)
+            new_messages.pop()
+            new_response = copy.deepcopy(response)
+            new_response.pop()
+            if new_messages[0][ROLE] == SYSTEM:
+                # Add the system instruction to the agent
+                new_messages[0].content = self.addtional_agent.make_system_prompt()
+            for rsp in self.addtional_agent._run(messages=new_messages, **kwargs):
+                yield new_response + rsp
+

app.py

@@ -0,0 +1,125 @@
+"""Tongyi DeepResearch - A Deep Research Agent Demo for Huggingface Spaces"""
+
+import os
+from agents.search_agent import SearchAgent
+from llm.oai import TextChatAtOAI
+from gui.web_ui import WebUI
+import datetime
+from search import Search
+from visit import Visit
+from scholar import Scholar
+from tool_python import PythonInterpreter
+
+DR_MODEL_NAME = os.getenv("DR_MODEL_NAME", "")
+DR_MODEL_SERVER = os.getenv("DR_MODEL_SERVER", "")
+DR_MODEL_API_KEY = os.getenv("DR_MODEL_API_KEY", "")
+
+ROOT_RESOURCE = os.path.join(os.path.dirname(__file__), 'resource')
+
+
+def today_date():
+    return datetime.date.today().strftime("%Y-%m-%d")
+
+
+def init_dev_search_agent_service(
+    name: str = 'SEARCH',
+    port: int = 8002,
+    desc: str = '初版',
+    reasoning: bool = True,
+    max_llm_calls: int = 20,
+    tools=['search', 'visit'],
+    addtional_agent=None
+):
+    llm_cfg = TextChatAtOAI({
+        'model': DR_MODEL_NAME,
+        'model_type': 'oai',
+        'model_server': DR_MODEL_SERVER,
+        'api_key': DR_MODEL_API_KEY,
+        'generate_cfg': {
+            'fncall_prompt_type': 'nous',
+            'temperature': 0.85,
+            'top_p': 0.95,
+            'top_k': -1,
+            'presence_penalty': 1.1,
+            'max_tokens': 32768,
+            'stream_options': {
+                'include_usage': True,
+            },
+            'timeout': 3000
+        },
+    })
+
+    def make_system_prompt():
+        system_message = """You are a deep research assistant. Your core function is to conduct thorough, multi-source investigations into any topic. You must handle both broad, open-domain inquiries and queries within specialized academic fields. For every request, synthesize information from credible, diverse sources to deliver a comprehensive, accurate, and objective response. When you have gathered sufficient information and are ready to provide the definitive response, you must enclose the entire final answer within <answer></answer> tags.\n\n"""
+        return system_message
+
+    bot = SearchAgent(
+        llm=llm_cfg,
+        function_list=tools,
+        system_message="",
+        name=f'Tongyi DeepResearch',
+        description=f"I am Tongyi DeepResearch, a leading open-source Deep Research Agent, welcome to try!",
+        extra={
+            'reasoning': reasoning,
+            'max_llm_calls': max_llm_calls,
+        },
+        addtional_agent=addtional_agent,
+        make_system_prompt=make_system_prompt,
+        custom_user_prompt=''''''
+    )
+    return bot
+
+
+def app_gui():
+    agents = []
+    for name, port, desc, reasoning, max_llm_calls, tools in [
+        ('Tongyi DeepResearch', 8004, '...', True, 50, ['search', 'visit', 'google_scholar', 'PythonInterpreter']),
+    ]:
+        search_bot_dev = init_dev_search_agent_service(
+            name=name,
+            port=port,
+            desc=desc,
+            reasoning=reasoning,
+            max_llm_calls=max_llm_calls,
+            tools=tools,
+        )
+        agents.append(search_bot_dev)
+
+    chatbot_config = {
+        'prompt.suggestions': [
+            '中国国足的一场比赛，国足首先失球，由一名宿姓球员扳平了。后来还发生了点球。比分最终是平局。这是哪场比赛？',
+            'When is the paper submission deadline for the ACL 2025 Industry Track, and what is the venue address for the conference?',
+            'On June 6, 2023, an article by Carolyn Collins Petersen was published in Universe Today. This article mentions a team that produced a paper about their observations, linked at the bottom of the article. Find this paper. Under what NASA award number was the work performed by R. G. Arendt supported by?',
+            '有一位华语娱乐圈的重要人物，与其兄弟共同创作并主演了一部在中国南方沿海城市上映的喜剧电影，这部电影成为该类型的开山之作。与此同时，这位人物还凭借两首极具影响力的本地方言歌曲在音乐领域取得突破，极大推动了本地方言流行音乐的发展。请问，这一切发生在20世纪70年代的哪一年？',
+            '有一首欧洲国家的国歌自20世纪50年代初被正式采用，并只选用了其中的一部分歌词。同一年，一位中国文艺界的重要人物创作了一部以民间传说为基础的戏曲作品，并在当年担任了多个文化领域的重要职务。请问这位中国文艺界人物是谁？',
+            '有一部英国文坛上极具影响力的长篇诗歌，由一位16世纪末的著名诗人创作，这位诗人在16世纪90年代末于伦敦去世后，被安葬在一个象征英国文学传统的著名场所，与多位文学巨匠为邻。请问，这位诗人安息之地是哪里？',
+            '出一份三天两夜的端午北京旅游攻略',
+            '对比下最新小米汽车和保时捷性能参数，然后根据最终的结果分析下性价比最高的车型，并给出杭州的供应商',
+            '量子计算突破对现有加密体系的威胁',
+            '人工智能伦理框架的全球差异',
+            '老龄化社会对全球养老金体系的长期冲击',
+            '全球碳中和目标下的能源转型路径差异',
+            '塑料污染在海洋食物链中的累积效应',
+            'AI生成内容（如AI绘画）对传统艺术价值的重构'
+        ],
+        'user.name': 'User',
+        'verbose': True
+    }
+    messages = {'role': 'user', 'content': '介绍下你自己'}
+
+    WebUI(
+        agent=agents,
+        chatbot_config=chatbot_config,
+    ).run(
+        message=messages,
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860,
+        concurrency_limit=20,
+        enable_mention=False,
+    )
+
+
+if __name__ == '__main__':
+    app_gui()
+

gui/__init__.py

@@ -0,0 +1,4 @@
+from .web_ui import WebUI
+
+__all__ = ['WebUI']
+

gui/assets/appBot.css

@@ -0,0 +1,157 @@
+/* Deep Research Agent Custom Styles */
+
+.container {
+    max-width: 1400px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+.gradio-container {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+}
+
+/* Chat message styling */
+.message {
+    border-radius: 12px;
+    padding: 12px 16px;
+    margin: 8px 0;
+}
+
+.user-message {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+}
+
+.bot-message {
+    background: #f5f5f5;
+    border: 1px solid #e0e0e0;
+}
+
+/* Code blocks */
+pre, code {
+    font-family: 'JetBrains Mono', 'Fira Code', monospace;
+    background: #1e1e1e;
+    color: #d4d4d4;
+    border-radius: 8px;
+}
+
+pre {
+    padding: 16px;
+    overflow-x: auto;
+}
+
+/* Thinking blocks */
+.thinking-block {
+    background: linear-gradient(135deg, #f6f8fc 0%, #eef1f8 100%);
+    border-left: 4px solid #667eea;
+    padding: 12px 16px;
+    margin: 8px 0;
+    border-radius: 0 8px 8px 0;
+    font-style: italic;
+    color: #666;
+}
+
+/* Tool call styling */
+.tool-call {
+    background: #fff3cd;
+    border: 1px solid #ffc107;
+    border-radius: 8px;
+    padding: 12px;
+    margin: 8px 0;
+}
+
+.tool-result {
+    background: #d4edda;
+    border: 1px solid #28a745;
+    border-radius: 8px;
+    padding: 12px;
+    margin: 8px 0;
+}
+
+/* Answer block */
+.answer-block {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border-radius: 12px;
+    padding: 20px;
+    margin: 16px 0;
+    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4);
+}
+
+/* Input area */
+.input-area {
+    border-radius: 12px;
+    border: 2px solid #e0e0e0;
+    transition: border-color 0.3s ease;
+}
+
+.input-area:focus-within {
+    border-color: #667eea;
+    box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+}
+
+/* Buttons */
+button.primary {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    border: none;
+    border-radius: 8px;
+    color: white;
+    padding: 10px 20px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: transform 0.2s ease, box-shadow 0.2s ease;
+}
+
+button.primary:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+}
+
+/* Scrollbar styling */
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: #f1f1f1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb {
+    background: #c1c1c1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #a8a8a8;
+}
+
+/* Loading animation */
+.loading-dots {
+    display: inline-block;
+}
+
+.loading-dots::after {
+    content: '';
+    animation: dots 1.5s steps(4, end) infinite;
+}
+
+@keyframes dots {
+    0%, 20% { content: ''; }
+    40% { content: '.'; }
+    60% { content: '..'; }
+    80%, 100% { content: '...'; }
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .container {
+        padding: 10px;
+    }
+    
+    .message {
+        padding: 10px 12px;
+    }
+}
+

gui/web_ui.py

@@ -0,0 +1,380 @@
+import os
+import pprint
+import re
+from typing import List, Optional, Union
+
+from qwen_agent import Agent, MultiAgentHub
+from qwen_agent.agents.user_agent import PENDING_USER_INPUT
+from qwen_agent.gui.gradio_utils import format_cover_html
+from qwen_agent.gui.utils import convert_fncall_to_text, convert_history_to_chatbot, get_avatar_image
+from qwen_agent.llm.schema import AUDIO, CONTENT, FILE, IMAGE, NAME, ROLE, USER, VIDEO, Message
+from qwen_agent.log import logger
+from qwen_agent.utils.utils import print_traceback
+
+
+class WebUI:
+    """A Common chatbot application for agent."""
+
+    def __init__(self, agent: Union[Agent, MultiAgentHub, List[Agent]], chatbot_config: Optional[dict] = None):
+        """
+        Initialization the chatbot.
+
+        Args:
+            agent: The agent or a list of agents, supports various types of agents such as Assistant, GroupChat, Router, etc.
+            chatbot_config: The chatbot configuration. Set the configuration as {'user.name': '', 'user.avatar': '', 'agent.avatar': '', 'input.placeholder': '', 'prompt.suggestions': []}.
+        """
+        chatbot_config = chatbot_config or {}
+
+        if isinstance(agent, MultiAgentHub):
+            self.agent_list = [agent for agent in agent.nonuser_agents]
+            self.agent_hub = agent
+        elif isinstance(agent, list):
+            self.agent_list = agent
+            self.agent_hub = None
+        else:
+            self.agent_list = [agent]
+            self.agent_hub = None
+
+        user_name = chatbot_config.get('user.name', 'user')
+        self.user_config = {
+            'name': user_name,
+            'avatar': chatbot_config.get(
+                'user.avatar',
+                get_avatar_image(user_name),
+            ),
+        }
+
+        self.agent_config_list = [{
+            'name': agent.name,
+            'avatar': chatbot_config.get(
+                'agent.avatar',
+                get_avatar_image(agent.name),
+            ),
+            'description': agent.description or "I'm a helpful assistant.",
+        } for agent in self.agent_list]
+
+        self.input_placeholder = chatbot_config.get('input.placeholder', '请输入需要分析的问题，尽管交给我吧～')
+        self.prompt_suggestions = chatbot_config.get('prompt.suggestions', [])
+        self.verbose = chatbot_config.get('verbose', False)
+
+    """
+    Run the chatbot.
+
+    Args:
+        messages: The chat history.
+    """
+
+    def run(self,
+            messages: List[Message] = None,
+            share: bool = False,
+            server_name: str = None,
+            server_port: int = None,
+            concurrency_limit: int = 10,
+            enable_mention: bool = False,
+            **kwargs):
+        self.run_kwargs = kwargs
+        from qwen_agent.gui.gradio_dep import gr, mgr, ms
+
+        customTheme = gr.themes.Default(
+            primary_hue=gr.themes.utils.colors.blue,
+            radius_size=gr.themes.utils.sizes.radius_none,
+        )
+
+        if messages is not None:
+            logger.info('web-ui messages.size %s' % len(messages))
+
+        with gr.Blocks(
+            css=os.path.join(os.path.dirname(__file__), 'assets/appBot.css'),
+            theme=customTheme,
+        ) as demo:
+            history = gr.State([])
+
+            with ms.Application():
+                with gr.Row(elem_classes='container'):
+                    with gr.Column(scale=4):
+                        chatbot = mgr.Chatbot(value=convert_history_to_chatbot(messages=messages),
+                                              avatar_images=[
+                                                  self.user_config,
+                                                  self.agent_config_list,
+                                              ],
+                                              height=850,
+                                              avatar_image_width=80,
+                                              flushing=False,
+                                              show_copy_button=True,
+                                              latex_delimiters=[{
+                                                  'left': '\\(',
+                                                  'right': '\\)',
+                                                  'display': True
+                                              }, {
+                                                  'left': '\\begin{equation}',
+                                                  'right': '\\end{equation}',
+                                                  'display': True
+                                              }, {
+                                                  'left': '\\begin{align}',
+                                                  'right': '\\end{align}',
+                                                  'display': True
+                                              }, {
+                                                  'left': '\\begin{alignat}',
+                                                  'right': '\\end{alignat}',
+                                                  'display': True
+                                              }, {
+                                                  'left': '\\begin{gather}',
+                                                  'right': '\\end{gather}',
+                                                  'display': True
+                                              }, {
+                                                  'left': '\\begin{CD}',
+                                                  'right': '\\end{CD}',
+                                                  'display': True
+                                              }, {
+                                                  'left': '\\[',
+                                                  'right': '\\]',
+                                                  'display': True
+                                              }])
+
+                        input = mgr.MultimodalInput(
+                            placeholder=self.input_placeholder,
+                            show_copy_button=True,
+                        )
+
+                    with gr.Column(scale=1):
+                        if len(self.agent_list) > 1:
+                            agent_selector = gr.Dropdown(
+                                [(agent.name, i) for i, agent in enumerate(self.agent_list)],
+                                label='Agents',
+                                info='请选择一个 Agent',
+                                value=0,
+                                interactive=True,
+                            )
+
+                        agent_info_block = self._create_agent_info_block()
+                        agent_plugins_block = self._create_agent_plugins_block()
+
+                        if self.prompt_suggestions:
+                            gr.Examples(
+                                label='推荐对话',
+                                examples=self.prompt_suggestions,
+                                inputs=[input],
+                            )
+
+                if len(self.agent_list) > 1:
+                    agent_selector.change(
+                        fn=self.change_agent,
+                        inputs=[agent_selector],
+                        outputs=[agent_selector, agent_info_block, agent_plugins_block],
+                        queue=False,
+                    )
+
+                input.change(
+                    fn=self.change_text,
+                    inputs=[input],
+                )
+
+                input_promise = input.submit(
+                    fn=self.add_text,
+                    inputs=[input, chatbot, history],
+                    outputs=[input, chatbot, history],
+                    queue=True,
+                    concurrency_limit=concurrency_limit,
+                )
+
+                if len(self.agent_list) > 1:
+                    if enable_mention:
+                        input_promise = input_promise.then(
+                            self.add_mention,
+                            [chatbot, agent_selector],
+                            [chatbot, agent_selector],
+                        ).then(
+                            self.agent_run,
+                            [chatbot, history, agent_selector],
+                            [chatbot, history, agent_selector],
+                        )
+                    else:
+                        input_promise = input_promise.then(
+                            self.agent_run,
+                            [chatbot, history, agent_selector],
+                            [chatbot, history, agent_selector],
+                        )
+                else:
+                    input_promise = input_promise.then(
+                        self.agent_run,
+                        [chatbot, history],
+                        [chatbot, history],
+                    )
+
+                input_promise.then(self.flushed, None, [input])
+
+            demo.load(None)
+
+        demo.queue(default_concurrency_limit=concurrency_limit).launch()
+
+    def change_agent(self, agent_selector):
+        yield agent_selector, self._create_agent_info_block(agent_selector), self._create_agent_plugins_block(
+            agent_selector)
+
+    def change_text(self, _input):
+        logger.info(f'agent_run change_text input:{_input.text}')
+
+    def add_text(self, _input, _chatbot, _history):
+        _history.append({
+            ROLE: USER,
+            CONTENT: [{
+                'text': _input.text
+            }],
+        })
+
+        if self.user_config[NAME]:
+            _history[-1][NAME] = self.user_config[NAME]
+
+        logger.info('agent_run add_text input:\n' + pprint.pformat(_history, indent=2))
+
+        if _input.files:
+            for file in _input.files:
+                if file.mime_type.startswith('image/'):
+                    _history[-1][CONTENT].append({IMAGE: 'file://' + file.path})
+                elif file.mime_type.startswith('audio/'):
+                    _history[-1][CONTENT].append({AUDIO: 'file://' + file.path})
+                elif file.mime_type.startswith('video/'):
+                    _history[-1][CONTENT].append({VIDEO: 'file://' + file.path})
+                else:
+                    _history[-1][CONTENT].append({FILE: file.path})
+
+        _chatbot.append([_input, None])
+        from qwen_agent.gui.gradio_dep import gr
+        yield gr.update(interactive=False, value=''), _chatbot, _history
+
+    def add_mention(self, _chatbot, _agent_selector):
+        if len(self.agent_list) == 1:
+            yield _chatbot, _agent_selector
+
+        query = _chatbot[-1][0].text
+        match = re.search(r'@\w+\b', query)
+        if match:
+            _agent_selector = self._get_agent_index_by_name(match.group()[1:])
+
+        agent_name = self.agent_list[_agent_selector].name
+        if ('@' + agent_name) not in query and self.agent_hub is None:
+            _chatbot[-1][0].text = '@' + agent_name + ' ' + query
+
+        yield _chatbot, _agent_selector
+
+    def agent_run(self, _chatbot, _history, _agent_selector=None):
+        # TODO 仅保持任务的单论对话
+        if self.verbose:
+            logger.info('agent_run input[all]:\n' + pprint.pformat(_history, indent=2))
+
+        _history = _history[-1:]
+        if self.verbose:
+            logger.info('agent_run input[new]:\n' + pprint.pformat(_history, indent=2))
+
+        if len(_history) == 0:
+            if _agent_selector is not None:
+                yield _chatbot, _history, _agent_selector
+            else:
+                yield _chatbot, _history
+            logger.info('agent_run input with empty input, do nothing.')
+            return
+
+        num_input_bubbles = len(_chatbot) - 1
+        num_output_bubbles = 1
+        _chatbot[-1][1] = [None for _ in range(len(self.agent_list))]
+
+        logger.info('agent_run input:_agent_selector %s' % _agent_selector)
+        agent_runner = self.agent_list[_agent_selector or 0]
+        if self.agent_hub:
+            agent_runner = self.agent_hub
+
+        agent_runner.function_map
+        responses = []
+        for responses in agent_runner.run(_history, **self.run_kwargs):
+            if not responses:
+                continue
+            if responses[-1][CONTENT] == PENDING_USER_INPUT:
+                logger.info('Interrupted. Waiting for user input!')
+                break
+
+            display_responses = convert_fncall_to_text(responses)
+            if not display_responses:
+                continue
+            if display_responses[-1][CONTENT] is None:
+                continue
+
+            while len(display_responses) > num_output_bubbles:
+                # Create a new chat bubble
+                _chatbot.append([None, None])
+                _chatbot[-1][1] = [None for _ in range(len(self.agent_list))]
+                num_output_bubbles += 1
+
+            assert num_output_bubbles == len(display_responses)
+            assert num_input_bubbles + num_output_bubbles == len(_chatbot)
+
+            for i, rsp in enumerate(display_responses):
+                agent_index = self._get_agent_index_by_name(rsp[NAME])
+                _chatbot[num_input_bubbles + i][1][agent_index] = rsp[CONTENT]
+                if len(self.agent_list) > 1:
+                    _agent_selector = agent_index
+
+            if _agent_selector is not None:
+                yield _chatbot, _history, _agent_selector
+            else:
+                yield _chatbot, _history
+
+        if responses:
+            _history.extend([res for res in responses if res[CONTENT] != PENDING_USER_INPUT])
+
+        if _agent_selector is not None:
+            yield _chatbot, _history, _agent_selector
+        else:
+            yield _chatbot, _history
+
+        if self.verbose:
+            logger.info('agent_run response:\n' + pprint.pformat(responses, indent=2))
+
+    def flushed(self):
+        logger.info('agent_run flushed')
+        from qwen_agent.gui.gradio_dep import gr
+        return gr.update(interactive=True, value='')
+
+    def _get_agent_index_by_name(self, agent_name):
+        if agent_name is None:
+            return 0
+        try:
+            agent_name = agent_name.strip()
+            for i, agent in enumerate(self.agent_list):
+                if agent.name == agent_name:
+                    return i
+            return 0
+        except Exception:
+            print_traceback()
+            return 0
+
+    def _create_agent_info_block(self, agent_index=0):
+        from qwen_agent.gui.gradio_dep import gr
+        agent_config_interactive = self.agent_config_list[agent_index]
+
+        return gr.HTML(
+            format_cover_html(
+                bot_name=agent_config_interactive['name'],
+                bot_description=agent_config_interactive['description'],
+                bot_avatar=agent_config_interactive['avatar'],
+            ))
+
+    def _create_agent_plugins_block(self, agent_index=0):
+        from qwen_agent.gui.gradio_dep import gr
+        agent_interactive = self.agent_list[agent_index]
+
+        if agent_interactive.function_map:
+            capabilities = [key for key in agent_interactive.function_map.keys()]
+            return gr.CheckboxGroup(
+                label='插件',
+                value=capabilities,
+                choices=capabilities,
+                interactive=False,
+            )
+        else:
+            return gr.CheckboxGroup(
+                label='插件',
+                value=[],
+                choices=[],
+                interactive=False,
+            )
+

llm/__init__.py

@@ -0,0 +1,4 @@
+from .oai import TextChatAtOAI
+
+__all__ = ['TextChatAtOAI']
+

llm/oai.py

@@ -0,0 +1,289 @@
+import time
+from typing import List, Iterator
+import copy
+import json
+import logging
+import random
+import os
+from pprint import pformat
+from typing import Dict, Iterator, List, Optional, Literal, Union
+import openai
+from openai import OpenAIError, RateLimitError
+
+if openai.__version__.startswith('0.'):
+    from openai.error import OpenAIError  # noqa
+else:
+    from openai import OpenAIError
+
+from qwen_agent.llm.base import ModelServiceError, register_llm
+from qwen_agent.llm.function_calling import BaseFnCallModel, simulate_response_completion_with_chat
+from qwen_agent.llm.schema import ASSISTANT, Message, FunctionCall
+from qwen_agent.log import logger
+import datetime
+
+
+def today_date():
+    return datetime.date.today().strftime("%Y-%m-%d")
+
+
+SYSTEM_PROMPT = """You are a deep research assistant. Your core function is to conduct thorough, multi-source investigations into any topic. You must handle both broad, open-domain inquiries and queries within specialized academic fields. For every request, synthesize information from credible, diverse sources to deliver a comprehensive, accurate, and objective response. When you have gathered sufficient information and are ready to provide the definitive response, you must enclose the entire final answer within <answer></answer> tags.
+
+# Tools
+
+You may call one or more functions to assist with the user query.
+
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>
+{"type": "function", "function": {"name": "search", "description": "Perform Google web searches then returns a string of the top search results. Accepts multiple queries.", "parameters": {"type": "object", "properties": {"query": {"type": "array", "items": {"type": "string", "description": "The search query."}, "minItems": 1, "description": "The list of search queries."}}, "required": ["query"]}}}
+{"type": "function", "function": {"name": "visit", "description": "Visit webpage(s) and return the summary of the content.", "parameters": {"type": "object", "properties": {"url": {"type": "array", "items": {"type": "string"}, "description": "The URL(s) of the webpage(s) to visit. Can be a single URL or an array of URLs."}, "goal": {"type": "string", "description": "The specific information goal for visiting webpage(s)."}}, "required": ["url", "goal"]}}}
+{"type": "function", "function": {"name": "PythonInterpreter", "description": "Executes Python code in a sandboxed environment. To use this tool, you must follow this format:
+1. The 'arguments' JSON object must be empty: {}.
+2. The Python code to be executed must be placed immediately after the JSON block, enclosed within <code> and </code> tags.
+
+IMPORTANT: Any output you want to see MUST be printed to standard output using the print() function.
+
+Example of a correct call:
+<tool_call>
+{"name": "PythonInterpreter", "arguments": {}}
+<code>
+import numpy as np
+# Your code here
+print(f"The result is: {np.mean([1,2,3])}")
+</code>
+</tool_call>", "parameters": {"type": "object", "properties": {}, "required": []}}}
+{"type": "function", "function": {"name": "google_scholar", "description": "Leverage Google Scholar to retrieve relevant information from academic publications. Accepts multiple queries. This tool will also return results from google search", "parameters": {"type": "object", "properties": {"query": {"type": "array", "items": {"type": "string", "description": "The search query."}, "minItems": 1, "description": "The list of search queries for Google Scholar."}}, "required": ["query"]}}}
+{"type": "function", "function": {"name": "parse_file", "description": "This is a tool that can be used to parse multiple user uploaded local files such as PDF, DOCX, PPTX, TXT, CSV, XLSX, DOC, ZIP, MP4, MP3.", "parameters": {"type": "object", "properties": {"files": {"type": "array", "items": {"type": "string"}, "description": "The file name of the user uploaded local files to be parsed."}}, "required": ["files"]}}}
+</tools>
+
+For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
+<tool_call>
+{"name": <function-name>, "arguments": <args-json-object>}
+</tool_call>
+
+"""
+
+
+@register_llm('oai')
+class TextChatAtOAI(BaseFnCallModel):
+    def __init__(self, cfg: Optional[Dict] = None):
+        super().__init__(cfg)
+        self.model = self.model or 'gpt-4o-mini'
+        cfg = cfg or {}
+        api_base = cfg.get('api_base')
+        api_base = api_base or cfg.get('base_url')
+        api_base = api_base or cfg.get('model_server')
+        api_base = (api_base or '').strip()
+
+        api_key = cfg.get('api_key')
+        api_key = api_key or os.getenv('OPENAI_API_KEY')
+        api_key = (api_key or 'EMPTY').strip()
+
+        if openai.__version__.startswith('0.'):
+            if api_base:
+                openai.api_base = api_base
+            if api_key:
+                openai.api_key = api_key
+            self._complete_create = openai.Completion.create
+            self._chat_complete_create = openai.ChatCompletion.create
+        else:
+            api_kwargs = {}
+            if api_base:
+                api_kwargs['base_url'] = api_base
+            if api_key:
+                api_kwargs['api_key'] = api_key
+
+            def _chat_complete_create(*args, **kwargs):
+                # OpenAI API v1 does not allow the following args, must pass by extra_body
+                extra_params = ['top_k', 'repetition_penalty']
+                if any((k in kwargs) for k in extra_params):
+                    kwargs['extra_body'] = copy.deepcopy(kwargs.get('extra_body', {}))
+                    for k in extra_params:
+                        if k in kwargs:
+                            kwargs['extra_body'][k] = kwargs.pop(k)
+                if 'request_timeout' in kwargs:
+                    kwargs['timeout'] = kwargs.pop('request_timeout')
+                client = openai.OpenAI(**api_kwargs)
+                return client.chat.completions.create(*args, **kwargs)
+
+            def _complete_create(*args, **kwargs):
+                # OpenAI API v1 does not allow the following args, must pass by extra_body
+                extra_params = ['top_k', 'repetition_penalty']
+                if any((k in kwargs) for k in extra_params):
+                    kwargs['extra_body'] = copy.deepcopy(kwargs.get('extra_body', {}))
+                    for k in extra_params:
+                        if k in kwargs:
+                            kwargs['extra_body'][k] = kwargs.pop(k)
+                if 'request_timeout' in kwargs:
+                    kwargs['timeout'] = kwargs.pop('request_timeout')
+                client = openai.OpenAI(**api_kwargs)
+                return client.completions.create(*args, **kwargs)
+
+            self._complete_create = _complete_create
+            self._chat_complete_create = _chat_complete_create
+
+    def _chat_stream(
+        self,
+        messages: List[Message],
+        delta_stream: bool,
+        generate_cfg: dict,
+    ) -> Iterator[List[Message]]:
+        messages = self.convert_messages_to_dicts(messages)
+        try:
+            MAX_RETRIES = 5
+            INITIAL_DELAY = 2
+            CONTENT_THRESHOLD = 50
+            REASONING_THRESHOLD = 50
+
+            response = None
+            for attempt in range(MAX_RETRIES):
+                try:
+                    response = self._chat_complete_create(model=self.model,
+                                                          messages=messages,
+                                                          stream=True,
+                                                          **generate_cfg)
+                    break
+                except RateLimitError as ex:
+                    if attempt == MAX_RETRIES - 1:
+                        logger.error(f"API rate limit error after {MAX_RETRIES} retries. Raising exception.")
+                        raise ModelServiceError(exception=ex) from ex
+                    delay = INITIAL_DELAY * (2 ** attempt) + random.uniform(0, 1)
+                    logger.warning(
+                        f"Rate limit exceeded. Retrying in {delay:.2f} seconds... (Attempt {attempt + 1}/{MAX_RETRIES})"
+                    )
+                    time.sleep(delay)
+                except OpenAIError as ex:
+                    logger.error(f"An OpenAI error occurred: {ex}")
+                    raise ModelServiceError(exception=ex) from ex
+
+            if delta_stream:
+                for chunk in response:
+                    if chunk.choices:
+                        choice = chunk.choices[0]
+                        if hasattr(choice.delta, 'reasoning_content') and choice.delta.reasoning_content:
+                            yield [
+                                Message(
+                                    role=ASSISTANT,
+                                    content='',
+                                    reasoning_content=choice.delta.reasoning_content
+                                )
+                            ]
+                        if hasattr(choice.delta, 'content') and choice.delta.content:
+                            yield [Message(role=ASSISTANT, content=choice.delta.content, reasoning_content='')]
+                        if hasattr(choice.delta, 'tool_calls') and choice.delta.tool_calls:
+                            function_name = choice.delta.tool_calls[0].function.name
+                            function_call = {
+                                'name': function_name,
+                                'arguments': json.loads(choice.delta.tool_calls[0].function.arguments)
+                            }
+                            function_json = json.dumps(function_call, ensure_ascii=False)
+                            yield [Message(role=ASSISTANT, content=f'<tool_call>{function_json}</tool_call>')]
+                        logger.info(f'delta_stream message chunk: {chunk}')
+            else:
+                full_response = ''
+                full_reasoning_content = ''
+                content_buffer = ''
+                reasoning_content_buffer = ''
+
+                for chunk in response:
+                    if not chunk.choices:
+                        continue
+                    choice = chunk.choices[0]
+                    new_content = choice.delta.content if hasattr(choice.delta, 'content') and choice.delta.content else ''
+                    new_reasoning = choice.delta.reasoning if hasattr(choice.delta, 'reasoning') and choice.delta.reasoning else ''
+                    has_tool_calls = hasattr(choice.delta, 'tool_calls') and choice.delta.tool_calls
+
+                    if new_reasoning:
+                        full_reasoning_content += new_reasoning
+                        reasoning_content_buffer += new_reasoning
+
+                    if new_content:
+                        full_response += new_content
+                        content_buffer += new_content
+
+                    if has_tool_calls:
+                        function_name = choice.delta.tool_calls[0].function.name
+                        function_call = {
+                            'name': function_name,
+                            'arguments': json.loads(choice.delta.tool_calls[0].function.arguments)
+                        }
+                        function_json = json.dumps(function_call, ensure_ascii=False)
+                        logger.info(json.dumps(function_call, ensure_ascii=False, indent=4))
+                        full_response += f'<tool_call>{function_json}</tool_call>'
+                        content_buffer += '<tool_call>'
+
+                    if (len(content_buffer) >= CONTENT_THRESHOLD or
+                            len(reasoning_content_buffer) >= REASONING_THRESHOLD or
+                            '\n' in new_content or
+                            '\n' in new_reasoning):
+                        yield [Message(role=ASSISTANT, content=full_response, reasoning_content=full_reasoning_content)]
+                        content_buffer = ''
+                        reasoning_content_buffer = ''
+
+                    logger.info(f'message chunk: {chunk}')
+
+                if content_buffer or reasoning_content_buffer:
+                    yield [Message(role=ASSISTANT, content=full_response, reasoning_content=full_reasoning_content)]
+
+        except OpenAIError as ex:
+            raise ModelServiceError(exception=ex)
+
+    def _chat_no_stream(
+        self,
+        messages: List[Message],
+        generate_cfg: dict,
+    ) -> List[Message]:
+        messages = self.convert_messages_to_dicts(messages)
+        try:
+            response = self._chat_complete_create(model=self.model, messages=messages, stream=False, **generate_cfg)
+            if hasattr(response.choices[0].message, 'reasoning_content'):
+                return [
+                    Message(role=ASSISTANT,
+                            content=response.choices[0].message.content,
+                            reasoning_content=response.choices[0].message.reasoning_content)
+                ]
+            else:
+                return [Message(role=ASSISTANT, content=response.choices[0].message.content)]
+        except OpenAIError as ex:
+            raise ModelServiceError(exception=ex)
+
+    def _chat_with_functions(
+        self,
+        messages: List[Message],
+        functions: List[Dict],
+        stream: bool,
+        delta_stream: bool,
+        generate_cfg: dict,
+        lang: Literal['en', 'zh'],
+    ) -> Union[List[Message], Iterator[List[Message]]]:
+        generate_cfg = copy.deepcopy(generate_cfg)
+        for k in ['parallel_function_calls', 'function_choice', 'thought_in_content']:
+            if k in generate_cfg:
+                del generate_cfg[k]
+
+        messages = simulate_response_completion_with_chat(messages)
+        return self._chat(messages, stream=stream, delta_stream=delta_stream, generate_cfg=generate_cfg)
+
+    def _chat(
+        self,
+        messages: List[Union[Message, Dict]],
+        stream: bool,
+        delta_stream: bool,
+        generate_cfg: dict,
+    ) -> Union[List[Message], Iterator[List[Message]]]:
+        if stream:
+            return self._chat_stream(messages, delta_stream=delta_stream, generate_cfg=generate_cfg)
+        else:
+            return self._chat_no_stream(messages, generate_cfg=generate_cfg)
+
+    @staticmethod
+    def convert_messages_to_dicts(messages: List[Message]) -> List[dict]:
+        messages = [msg.model_dump() for msg in messages]
+        return_messages = []
+        messages[0]["content"] = SYSTEM_PROMPT + "Current date: " + str(today_date())
+        for i in messages:
+            i["content"] = i["content"].replace("<think>\n<think>\n", "<think>\n\n")
+            return_messages.append(i)
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f'LLM Input:\n{pformat(messages, indent=2)}')
+        return return_messages
+

prompt.py

@@ -0,0 +1,16 @@
+EXTRACTOR_PROMPT = """Please process the following webpage content and user goal to extract relevant information:
+
+## **Webpage Content** 
+{webpage_content}
+
+## **User Goal**
+{goal}
+
+## **Task Guidelines**
+1. **Content Scanning for Rational**: Locate the **specific sections/data** directly related to the user's goal within the webpage content
+2. **Key Extraction for Evidence**: Identify and extract the **most relevant information** from the content, you never miss any important information, output the **full original context** of the content as far as possible, it can be more than three paragraphs.
+3. **Summary Output for Summary**: Organize into a concise paragraph with logical flow, prioritizing clarity and judge the contribution of the information to the goal.
+
+**Final Output Format using JSON format has "rational", "evidence", "summary" feilds**
+"""
+

requirements.txt

@@ -0,0 +1,8 @@
+gradio==5.23.1
+huggingface_hub==0.23.0
+qwen-agent[gui,rag,code_interpreter]==0.0.31
+sandbox_fusion
+tiktoken
+openai
+requests
+modelscope_studio

scholar.py

@@ -0,0 +1,107 @@
+import os
+import json
+import requests
+from typing import Union, List
+from qwen_agent.tools.base import BaseTool, register_tool
+from concurrent.futures import ThreadPoolExecutor
+import http.client
+
+
+SERPER_KEY = os.environ.get('SERPER_KEY_ID')
+
+
+@register_tool("google_scholar", allow_overwrite=True)
+class Scholar(BaseTool):
+    name = "google_scholar"
+    description = "Leverage Google Scholar to retrieve relevant information from academic publications. Accepts multiple queries."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "array",
+                "items": {"type": "string", "description": "The search query."},
+                "minItems": 1,
+                "description": "The list of search queries for Google Scholar."
+            },
+        },
+        "required": ["query"],
+    }
+
+    def google_scholar_with_serp(self, query: str):
+        conn = http.client.HTTPSConnection("google.serper.dev")
+        payload = json.dumps({
+            "q": query,
+        })
+        headers = {
+            'X-API-KEY': SERPER_KEY,
+            'Content-Type': 'application/json'
+        }
+        for i in range(5):
+            try:
+                conn.request("POST", "/scholar", payload, headers)
+                res = conn.getresponse()
+                break
+            except Exception as e:
+                print(e)
+                if i == 4:
+                    return f"Google Scholar Timeout, return None, Please try again later."
+                continue
+
+        data = res.read()
+        results = json.loads(data.decode("utf-8"))
+        try:
+            if "organic" not in results:
+                raise Exception(f"No results found for query: '{query}'. Use a less specific query.")
+
+            web_snippets = list()
+            idx = 0
+            if "organic" in results:
+                for page in results["organic"]:
+                    idx += 1
+                    date_published = ""
+                    if "year" in page:
+                        date_published = "\nDate published: " + str(page["year"])
+
+                    publicationInfo = ""
+                    if "publicationInfo" in page:
+                        publicationInfo = "\npublicationInfo: " + page["publicationInfo"]
+
+                    snippet = ""
+                    if "snippet" in page:
+                        snippet = "\n" + page["snippet"]
+                    
+                    link_info = "no available link"
+                    if "pdfUrl" in page:
+                        link_info = "pdfUrl: " + page["pdfUrl"]
+                    
+                    citedBy = ""
+                    if "citedBy" in page:
+                        citedBy = "\ncitedBy: " + str(page["citedBy"])
+                    
+                    redacted_version = f"{idx}. [{page['title']}]({link_info}){publicationInfo}{date_published}{citedBy}\n{snippet}"
+
+                    redacted_version = redacted_version.replace("Your browser can't play this video.", "")
+                    web_snippets.append(redacted_version)
+
+            content = f"A Google scholar for '{query}' found {len(web_snippets)} results:\n\n## Scholar Results\n" + "\n\n".join(web_snippets)
+            return content
+        except:
+            return f"No results found for '{query}'. Try with a more general query."
+
+    def call(self, params: Union[str, dict], **kwargs) -> str:
+        try:
+            params = json.loads(params)
+            params = self._verify_json_format_args(params)
+            query = params["query"]
+        except:
+            return "[google_scholar] Invalid request format: Input must be a JSON object containing 'query' field"
+        
+        if isinstance(query, str):
+            response = self.google_scholar_with_serp(query)
+        else:
+            assert isinstance(query, List)
+            with ThreadPoolExecutor(max_workers=3) as executor:
+                response = list(executor.map(self.google_scholar_with_serp, query))
+            response = "\n=======\n".join(response)
+        return response
+

search.py

@@ -0,0 +1,134 @@
+import json
+from concurrent.futures import ThreadPoolExecutor
+from typing import List, Union
+import requests
+from qwen_agent.tools.base import BaseTool, register_tool
+import asyncio
+from typing import Dict, List, Optional, Union
+import uuid
+import http.client
+import json
+import os
+
+
+SERPER_KEY = os.environ.get('SERPER_KEY_ID')
+
+
+@register_tool("search", allow_overwrite=True)
+class Search(BaseTool):
+    name = "search"
+    description = "Performs batched web searches: supply an array 'query'; the tool retrieves the top 10 results for each query in one call."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Array of query strings. Include multiple complementary search queries in a single call."
+            },
+        },
+        "required": ["query"],
+    }
+
+    def __init__(self, cfg: Optional[dict] = None):
+        super().__init__(cfg)
+
+    def google_search_with_serp(self, query: str):
+        def contains_chinese_basic(text: str) -> bool:
+            return any('\u4E00' <= char <= '\u9FFF' for char in text)
+        
+        conn = http.client.HTTPSConnection("google.serper.dev")
+        if contains_chinese_basic(query):
+            payload = json.dumps({
+                "q": query,
+                "location": "China",
+                "gl": "cn",
+                "hl": "zh-cn"
+            })
+        else:
+            payload = json.dumps({
+                "q": query,
+                "location": "United States",
+                "gl": "us",
+                "hl": "en"
+            })
+        headers = {
+            'X-API-KEY': SERPER_KEY,
+            'Content-Type': 'application/json'
+        }
+
+        for i in range(5):
+            try:
+                conn.request("POST", "/search", payload, headers)
+                res = conn.getresponse()
+                break
+            except Exception as e:
+                print(e)
+                if i == 4:
+                    return f"Google search Timeout, return None, Please try again later."
+                continue
+
+        data = res.read()
+        results = json.loads(data.decode("utf-8"))
+        print(results)
+
+        try:
+            if "organic" not in results:
+                raise Exception(f"No results found for query: '{query}'. Use a less specific query.")
+
+            web_snippets = list()
+            idx = 0
+            if "organic" in results:
+                for page in results["organic"]:
+                    idx += 1
+                    date_published = ""
+                    if "date" in page:
+                        date_published = "\nDate published: " + page["date"]
+
+                    source = ""
+                    if "source" in page:
+                        source = "\nSource: " + page["source"]
+
+                    snippet = ""
+                    if "snippet" in page:
+                        snippet = "\n" + page["snippet"]
+
+                    redacted_version = f"{idx}. [{page['title']}]({page['link']}){date_published}{source}\n{snippet}"
+                    redacted_version = redacted_version.replace("Your browser can't play this video.", "")
+                    web_snippets.append(redacted_version)
+
+            content = f"A Google search for '{query}' found {len(web_snippets)} results:\n\n## Web Results\n" + "\n\n".join(web_snippets)
+            return content
+        except Exception as e:
+            print(e)
+            return f"No results found for '{query}'. Try with a more general query."
+
+    def search_with_serp(self, query: str):
+        result = self.google_search_with_serp(query)
+        return result
+
+    def call(self, params: Union[str, dict], **kwargs) -> str:
+        try:
+            print(params)
+            params = json.loads(params)
+            print(params)
+            query = params["query"]
+            print("query:\n", query)
+        except:
+            return "[Search] Invalid request format: Input must be a JSON object containing 'query' field"
+        
+        if isinstance(query, str):
+            # 单个查询
+            response = self.search_with_serp(query)
+        else:
+            # 多个查询
+            assert isinstance(query, List)
+            responses = []
+            for q in query:
+                responses.append(self.search_with_serp(q))
+            response = "\n=======\n".join(responses)
+            
+        return response
+

tool_python.py

@@ -0,0 +1,156 @@
+import re
+from typing import Dict, List, Optional, Union
+import json5
+from qwen_agent.tools.base import BaseToolWithFileAccess, register_tool
+from qwen_agent.utils.utils import extract_code
+from sandbox_fusion import run_code, RunCodeRequest, RunStatus
+from requests.exceptions import Timeout
+import os
+import random
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+
+SANDBOX_URL = os.getenv('SANDBOX_URL', '')
+SANDBOX_FUSION_ENDPOINTS = [SANDBOX_URL]
+
+# Fallback to single endpoint if environment variable exists
+if 'SANDBOX_FUSION_ENDPOINT' in os.environ:
+    SANDBOX_FUSION_ENDPOINTS = os.environ['SANDBOX_FUSION_ENDPOINT'].split(',')
+
+
+def has_chinese_chars(data) -> bool:
+    CHINESE_CHAR_RE = re.compile(r'[\u4e00-\u9fff]')
+    text = f'{data}'
+    return bool(CHINESE_CHAR_RE.search(text))
+
+
+@register_tool('PythonInterpreter', allow_overwrite=True)
+class PythonInterpreter(BaseToolWithFileAccess):
+    name = "PythonInterpreter"
+    description = 'Execute Python code in a sandboxed environment. Use this to run Python code and get the execution results.\n**Make sure to use print() for any output you want to see in the results.**\nFor code parameters, use placeholders first, and then put the code within <code></code> XML tags, such as:\n<tool_call>\n{"purpose": <detailed-purpose-of-this-tool-call>, "name": <tool-name>, "arguments": {"code": ""}}\n<code>\nHere is the code.\n</code>\n</tool_call>\n'
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "code": {
+                "type": "string",
+                "description": "The Python code to execute. Must be provided within <code></code> XML tags. Remember to use print() statements for any output you want to see.",
+            }
+        },
+        "required": ["code"],
+    }
+
+    def __init__(self, cfg: Optional[Dict] = None):
+        super().__init__(cfg)
+
+    @property
+    def args_format(self) -> str:
+        fmt = self.cfg.get('args_format')
+        if fmt is None:
+            if has_chinese_chars([self.name_for_human, self.name, self.description, self.parameters]):
+                fmt = 'The input for this tool should be a Markdown code block.'
+            else:
+                fmt = 'Enclose the code within triple backticks (`) at the beginning and end of the code.'
+        return fmt
+
+    def observation(self, tool: dict, tool_dict: dict, tool_results, empty_mode: bool = False, readpage: bool = False, max_observation_length: int = None, tokenizer=None):
+        print('test')
+        assert isinstance(tool_results, str), f"result of python code should be str, instead of {type(tool_results)}. {tool_results}"
+        return tool_results
+
+    @property
+    def function(self) -> dict:
+        return {
+            'name': self.name,
+            'description': self.description,
+            'parameters': self.parameters,
+        }
+
+    def call(self, params, files=None, timeout=50, **kwargs) -> str:
+        try:
+            try:
+                code = params.split('<code>')[1].split('</code')[0]
+            except Exception:
+                return '[Python Interpreter Error]: format error.'
+
+            if not code.strip():
+                return '[Python Interpreter Error]: Empty code.'
+
+            last_error = None
+            for attempt in range(8):
+                try:
+                    # Randomly sample an endpoint for each attempt
+                    endpoint = random.choice(SANDBOX_FUSION_ENDPOINTS)
+                    print(f"Attempt {attempt + 1}/5 using endpoint: {endpoint}")
+
+                    code_result = run_code(RunCodeRequest(code=code, language='python', run_timeout=timeout), max_attempts=1, client_timeout=timeout, endpoint=endpoint)
+                    print("[Python] Code Result", code_result)
+                    result = []
+                    if code_result.run_result.stdout:
+                        result.append(f"stdout:\n{code_result.run_result.stdout}")
+                    if code_result.run_result.stderr:
+                        result.append(f"stderr:\n{code_result.run_result.stderr}")
+                    if code_result.run_result.execution_time >= timeout - 1:
+                        result.append(f"[PythonInterpreter Error] TimeoutError: Execution timed out.")
+                    result = '\n'.join(result)
+                    print('SUCCESS RUNNING TOOL')
+                    return result if result.strip() else 'Finished execution.'
+
+                except Timeout as e:
+                    last_error = f'[Python Interpreter Error] TimeoutError: Execution timed out on endpoint {endpoint}.'
+                    print(f"Timeout on attempt {attempt + 1}: {last_error}")
+                    if attempt == 4:  # Last attempt
+                        return last_error
+                    continue
+
+                except Exception as e:
+                    last_error = f'[Python Interpreter Error]: {str(e)} on endpoint {endpoint}'
+                    print(f"Error on attempt {attempt + 1}: {last_error}")
+                    if attempt == 4:  # Last attempt
+                        return last_error
+                    continue
+
+            return last_error if last_error else '[Python Interpreter Error]: All attempts failed.'
+
+        except Exception as e:
+            return f"[Python Interpreter Error]: {str(e)}"
+
+    def call_specific_endpoint(self, params: Union[str, dict], endpoint: str, timeout: Optional[int] = 30, **kwargs) -> tuple:
+        """Test a specific endpoint directly"""
+        try:
+            if type(params) is str:
+                params = json5.loads(params)
+            code = params.get('code', '')
+            if not code:
+                code = params.get('raw', '')
+            triple_match = re.search(r'```[^\n]*\n(.+?)```', code, re.DOTALL)
+            if triple_match:
+                code = triple_match.group(1)
+        except Exception:
+            code = extract_code(params)
+
+        if not code.strip():
+            return False, '[Python Interpreter Error]: Empty code.'
+
+        try:
+            start_time = time.time()
+            code_result = run_code(RunCodeRequest(code=code, language='python', run_timeout=timeout),
+                                   max_attempts=1, client_timeout=timeout, endpoint=endpoint)
+            end_time = time.time()
+
+            result = []
+            if code_result.run_result.stdout:
+                result.append(f"stdout:\n{code_result.run_result.stdout}")
+            if code_result.run_result.stderr:
+                result.append(f"stderr:\n{code_result.run_result.stderr}")
+
+            result = '\n'.join(result)
+            execution_time = end_time - start_time
+            return True, result if result.strip() else 'Finished execution.', execution_time
+
+        except Timeout as e:
+            return False, f'[Python Interpreter Error] TimeoutError: Execution timed out.', None
+        except Exception as e:
+            return False, f'[Python Interpreter Error]: {str(e)}', None
+

utils/__init__.py

@@ -0,0 +1,2 @@
+# Utils module
+

visit.py

@@ -0,0 +1,260 @@
+import json
+import os
+import signal
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import List, Union
+import requests
+from qwen_agent.tools.base import BaseTool, register_tool
+from prompt import EXTRACTOR_PROMPT
+from openai import OpenAI
+import random
+from urllib.parse import urlparse, unquote
+import time
+import tiktoken
+
+
+VISIT_SERVER_TIMEOUT = int(os.getenv("VISIT_SERVER_TIMEOUT", 200))
+WEBCONTENT_MAXLENGTH = int(os.getenv("WEBCONTENT_MAXLENGTH", 150000))
+
+JINA_API_KEYS = os.getenv("JINA_KEY", "")
+
+
+def truncate_to_tokens(text: str, max_tokens: int = 95000) -> str:
+    encoding = tiktoken.get_encoding("cl100k_base")
+    tokens = encoding.encode(text)
+    if len(tokens) <= max_tokens:
+        return text
+    truncated_tokens = tokens[:max_tokens]
+    return encoding.decode(truncated_tokens)
+
+
+OSS_JSON_FORMAT = """# Response Formats
+## visit_content
+{"properties":{"rational":{"type":"string","description":"Locate the **specific sections/data** directly related to the user's goal within the webpage content"},"evidence":{"type":"string","description":"Identify and extract the **most relevant information** from the content, never miss any important information, output the **full original context** of the content as far as possible, it can be more than three paragraphs.","summary":{"type":"string","description":"Organize into a concise paragraph with logical flow, prioritizing clarity and judge the contribution of the information to the goal."}}}}"""
+
+
+@register_tool('visit', allow_overwrite=True)
+class Visit(BaseTool):
+    # The `description` tells the agent the functionality of this tool.
+    name = 'visit'
+    description = 'Visit webpage(s) and return the summary of the content.'
+    # The `parameters` tell the agent what input parameters the tool has.
+    parameters = {
+        "type": "object",
+        "properties": {
+            "url": {
+                "type": ["string", "array"],
+                "items": {
+                    "type": "string"
+                },
+                "minItems": 1,
+                "description": "The URL(s) of the webpage(s) to visit. Can be a single URL or an array of URLs."
+            },
+            "goal": {
+                "type": "string",
+                "description": "The goal of the visit for webpage(s)."
+            }
+        },
+        "required": ["url", "goal"]
+    }
+
+    # The `call` method is the main function of the tool.
+    def call(self, params: Union[str, dict], **kwargs) -> str:
+        try:
+            params = json.loads(params)
+            url = params["url"]
+            goal = params["goal"]
+        except:
+            return "[Visit] Invalid request format: Input must be a JSON object containing 'url' and 'goal' fields"
+        
+        start_time = time.time()
+        
+        # Create log folder if it doesn't exist
+        log_folder = "log"
+        os.makedirs(log_folder, exist_ok=True)
+
+        if isinstance(url, str):
+            response = self.readpage_jina(url, goal)
+        else:
+            response = []
+            assert isinstance(url, List)
+            start_time = time.time()
+            for u in url:
+                if time.time() - start_time > 900:
+                    cur_response = "The useful information in {url} for user goal {goal} as follows: \n\n".format(url=url, goal=goal)
+                    cur_response += "Evidence in page: \n" + "The provided webpage content could not be accessed. Please check the URL or file format." + "\n\n"
+                    cur_response += "Summary: \n" + "The webpage content could not be processed, and therefore, no information is available." + "\n\n"
+                else:
+                    try:
+                        cur_response = self.readpage_jina(u, goal)
+                    except Exception as e:
+                        cur_response = f"Error fetching {u}: {str(e)}"
+                response.append(cur_response)
+            response = "\n=======\n".join(response)
+        
+        print(f'Summary Length {len(response)}; Summary Content {response}')
+        return response.strip()
+
+    def call_server(self, msgs, max_retries=2):
+        api_key = os.environ.get("API_KEY")
+        url_llm = os.environ.get("API_BASE")
+        model_name = os.environ.get("SUMMARY_MODEL_NAME", "qwen/qwen3-30b-a3b-instruct-2507")
+        
+        client = OpenAI(
+            api_key=api_key,
+            base_url=url_llm,
+        )
+        for attempt in range(max_retries):
+            try:
+                chat_response = client.chat.completions.create(
+                    model=model_name,
+                    messages=msgs,
+                    temperature=0.7
+                )
+                content = chat_response.choices[0].message.content
+                if content:
+                    try:
+                        json.loads(content)
+                    except:
+                        # extract json from string 
+                        left = content.find('{')
+                        right = content.rfind('}')
+                        if left != -1 and right != -1 and left <= right:
+                            content = content[left:right+1]
+                    return content
+            except Exception as e:
+                print(e)
+                if attempt == (max_retries - 1):
+                    return ""
+                continue
+
+    def jina_readpage(self, url: str) -> str:
+        """
+        Read webpage content using Jina service.
+        
+        Args:
+            url: The URL to read
+            goal: The goal/purpose of reading the page
+            
+        Returns:
+            str: The webpage content or error message
+        """
+        max_retries = 3
+        timeout = 50
+        
+        for attempt in range(max_retries):
+            headers = {
+                "Authorization": f"Bearer {JINA_API_KEYS}",
+            }
+            try:
+                response = requests.get(
+                    f"https://r.jina.ai/{url}",
+                    headers=headers,
+                    timeout=timeout
+                )
+                if response.status_code == 200:
+                    webpage_content = response.text
+                    return webpage_content
+                else:
+                    print(response.text)
+                    raise ValueError("jina readpage error")
+            except Exception as e:
+                time.sleep(0.5)
+                if attempt == max_retries - 1:
+                    return "[visit] Failed to read page."
+                
+        return "[visit] Failed to read page."
+
+    def html_readpage_jina(self, url: str) -> str:
+        max_attempts = 8
+        for attempt in range(max_attempts):
+            content = self.jina_readpage(url)
+            service = "jina"
+            print(service)
+            if content and not content.startswith("[visit] Failed to read page.") and content != "[visit] Empty content." and not content.startswith("[document_parser]"):
+                return content
+        return "[visit] Failed to read page."
+
+    def readpage_jina(self, url: str, goal: str) -> str:
+        """
+        Attempt to read webpage content by alternating between jina and aidata services.
+        
+        Args:
+            url: The URL to read
+            goal: The goal/purpose of reading the page
+            
+        Returns:
+            str: The webpage content or error message
+        """
+
+        summary_page_func = self.call_server
+        max_retries = int(os.getenv('VISIT_SERVER_MAX_RETRIES', 1))
+
+        content = self.html_readpage_jina(url)
+
+        if content and not content.startswith("[visit] Failed to read page.") and content != "[visit] Empty content." and not content.startswith("[document_parser]"):
+            content = truncate_to_tokens(content, max_tokens=95000)
+            messages = [{"role": "user", "content": EXTRACTOR_PROMPT.format(webpage_content=content, goal=goal)}]
+            parse_retry_times = 0
+            raw = summary_page_func(messages, max_retries=max_retries)
+            summary_retries = 3
+            while len(raw) < 10 and summary_retries >= 0:
+                truncate_length = int(0.7 * len(content)) if summary_retries > 0 else 25000
+                status_msg = (
+                    f"[visit] Summary url[{url}] "
+                    f"attempt {3 - summary_retries + 1}/3, "
+                    f"content length: {len(content)}, "
+                    f"truncating to {truncate_length} chars"
+                ) if summary_retries > 0 else (
+                    f"[visit] Summary url[{url}] failed after 3 attempts, "
+                    f"final truncation to 25000 chars"
+                )
+                print(status_msg)
+                content = content[:truncate_length]
+                extraction_prompt = EXTRACTOR_PROMPT.format(
+                    webpage_content=content,
+                    goal=goal
+                )
+                messages = [{"role": "user", "content": extraction_prompt}]
+                raw = summary_page_func(messages, max_retries=max_retries)
+                summary_retries -= 1
+
+            parse_retry_times = 2
+            if isinstance(raw, str):
+                raw = raw.replace("```json", "").replace("```", "").strip()
+            while parse_retry_times < 3:
+                try:
+                    raw = json.loads(raw)
+                    break
+                except:
+                    raw = summary_page_func(messages, max_retries=max_retries)
+                    parse_retry_times += 1
+            
+            if parse_retry_times >= 3:
+                useful_information = "The useful information in {url} for user goal {goal} as follows: \n\n".format(url=url, goal=goal)
+                useful_information += "Evidence in page: \n" + "The provided webpage content could not be accessed. Please check the URL or file format." + "\n\n"
+                useful_information += "Summary: \n" + "The webpage content could not be processed, and therefore, no information is available." + "\n\n"
+            else:
+                useful_information = "The useful information in {url} for user goal {goal} as follows: \n\n".format(url=url, goal=goal)
+                useful_information += "Evidence in page: \n" + str(raw["evidence"]) + "\n\n"
+                useful_information += "Summary: \n" + str(raw["summary"]) + "\n\n"
+
+            if len(useful_information) < 10 and summary_retries < 0:
+                print("[visit] Could not generate valid summary after maximum retries")
+                useful_information = "[visit] Failed to read page"
+            
+            return useful_information
+
+        # If no valid content was obtained after all retries
+        else:
+            useful_information = "The useful information in {url} for user goal {goal} as follows: \n\n".format(url=url, goal=goal)
+            useful_information += "Evidence in page: \n" + "The provided webpage content could not be accessed. Please check the URL or file format." + "\n\n"
+            useful_information += "Summary: \n" + "The webpage content could not be processed, and therefore, no information is available." + "\n\n"
+            return useful_information
+
+
+if __name__ == "__main__":
+    a = Visit()
+    print(a.call('{"url": ["https://2025.aclweb.org/"], "goal": "Find the important dates page and locate the Industry Track paper submission deadline"}'))
+