rushed demo

.gitingore

@@ -0,0 +1,216 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

agents/__init__.py

@@ -0,0 +1 @@
+# coding=utf-8

agents/search_agent.py

@@ -0,0 +1,116 @@
+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)
+                    # exit()
+                    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)
+                        response.append(fn_msg)
+                        yield response
+                        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,112 @@
+"""An image generation agent implemented by assistant with qwq"""
+
+import os
+
+from agents.search_agent import SearchAgent
+from llm.oai import TextChatAtOAI
+from gui.web_ui import WebUI
+import datetime
+
+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=True,
+        server_name='127.0.0.1',
+        server_port=7860,
+        concurrency_limit=20,
+        enable_mention=False,
+    )
+
+
+if __name__ == '__main__':
+    app_gui()

gui/__init__.py

@@ -0,0 +1 @@
+# coding=utf-8

gui/html_decorate.py

@@ -0,0 +1,157 @@
+from markdown_it import MarkdownIt
+import html
+import re
+
+def get_style_css(style_name):
+    """
+    根据选择的样式名称获取对应的CSS样式文件
+    
+    Args:
+        style_name (str): 样式名称，可选值为"Default"、"MBE"、"Glassmorphism"、"Apple"
+    
+    Returns:
+        str: CSS样式内容
+    """
+    
+    if style_name == "Default":
+        return open("assets/demo.css", "r").read()
+    elif style_name == "1":
+        return open("assets/demo.1.css", "r").read()
+    elif style_name == "MBE":
+        return open("assets/demo_mbe.css", "r").read()
+    elif style_name == "Glassmorphism":
+        return open("assets/demo_glassmorphism.css", "r").read()
+    elif style_name == "Apple":
+        return open("assets/demo_apple.css", "r").read()
+    elif style_name == "Paper":
+        return open("assets/demo_paper.css", "r").read()
+    else:
+        return open("assets/demo.css", "r").read()
+
+def decorate_writing(writing_result, style="Default"):
+    if not writing_result:
+        return writing_result
+    
+    cite_pattern = r'<qwen:cite\s+url=["\']([^"\']+)["\'](?:\s+[^>]*)?>(.*?)</qwen:cite>'
+    takeaway_pattern = r'<qwen:takeaway(?:\s+class=["\'](?P<class>[^"\']+)["\'])?>(?P<content>[^<]*)</qwen:takeaway>'
+    citation_map = {}
+
+    def replace_cite(match):
+        nonlocal citation_map
+        urls = match.group(1).split(',')
+        content = match.group(2)
+        citation_html = []
+        
+        for url in urls:
+            if url not in citation_map:
+                citation_map[url] = len(citation_map) + 1
+            current_index = citation_map[url]
+            citation_html.append((f'<a href="{url}" title="点击查看引用来源: {url}">{current_index}</a>', current_index))
+        
+        citation_html = sorted(citation_html, key=lambda x: x[1])
+        citation_html = ', '.join([x[0] for x in citation_html])
+
+        cite_html = f'{content}<sup class="citation">[{citation_html}]</sup>'
+        return cite_html
+    
+    decorated_result = re.sub(cite_pattern, replace_cite, writing_result, flags=re.S)
+
+    def replace_takeaway(match):
+        class_attr = match.group('class')
+        content = match.group('content')
+        
+        if class_attr:
+            return f'<div class="takeaway {class_attr}">{content}</div>'
+        else:
+            return f'<div class="takeaway">{content}</div>'
+    
+    decorated_result = re.sub(takeaway_pattern, replace_takeaway, decorated_result, flags=re.S)
+
+    mermaid_pattern = r'```mermaid\n(.*?)\n```'
+    def decorate_mermaid(match):
+        return f"""
+<pre class="mermaid">
+{match.group(1)}
+</pre>
+"""
+    decorated_result = re.sub(mermaid_pattern, decorate_mermaid, decorated_result, flags=re.S)
+
+    echarts_pattern = r'```echarts\n(.*?)\n```'
+    echarts_index = 0
+    
+    def replace_echarts(match):
+        """
+        将echarts代码块转换为HTML和JavaScript
+        
+        Args:
+            match: 正则表达式匹配对象
+        
+        Returns:
+            str: 包含HTML和JavaScript的echarts图表代码
+        """
+        nonlocal echarts_index 
+        echarts_code = match.group(1)
+        echarts_id = f'echarts-container-{echarts_index}'
+        echarts_index += 1
+        
+        replace_code = f"""
+<div class="echarts-container loading" id="{echarts_id}">Echarts Rendering...</div>
+<script>
+    var chartDom = document.getElementById('{echarts_id}');
+    var myChart = echarts.init(chartDom);
+    var option;
+    option = {echarts_code};
+    myChart.setOption(option);
+    chartDom.classList.remove('loading');
+</script>
+        """
+        return replace_code
+    
+    decorated_result = re.sub(echarts_pattern, replace_echarts, decorated_result, flags=re.S)
+
+    md = MarkdownIt()
+    body = md.render(decorated_result)
+    
+    selected_css = get_style_css(style)
+    
+    html_content = """
+<html>
+<head>
+    <!-- KaTeX for mathematical formulas -->
+    <link rel="stylesheet" href="https://s4.zstatic.net/npm/[email protected]/dist/katex.min.css">
+    <script src="https://s4.zstatic.net/npm/[email protected]/dist/katex.min.js"></script>
+    <script src="https://s4.zstatic.net/npm/[email protected]/dist/contrib/auto-render.min.js"></script>
+    <script src="https://s4.zstatic.net/npm/[email protected]/dist/echarts.min.js"></script>
+    <style>
+""" + selected_css + """
+    </style>
+</head>
+<body>
+<div class="generated-content">
+""" + body + """</div>
+<script type="module">
+    import mermaid from 'https://unpkg.com/[email protected]/dist/mermaid.esm.min.mjs';
+</script>
+<script>
+    document.addEventListener('DOMContentLoaded', function() {
+        renderMathInElement(document.body);
+    });
+</script>
+</body>
+</html>
+"""
+    # 转义HTML内容以便在iframe中安全使用
+    # 这是必要的，因为HTML内容包含引号和其他特殊字符
+    escaped_html_content = html.escape(html_content)
+    
+    # 定义iframe的样式属性
+    iframe_style = "width: 100%; height: 1024px; transform-origin: top left; border-color: lightgrey; border-width: 1px; border-radius: 10px;"
+    
+    # 创建最终的iframe HTML，通过srcdoc属性注入转义后的HTML内容
+    # 设置loading="eager"和importance="high"以优先加载
+    # pointer-events="none"防止用户与iframe内容交互
+    iframe_content = f'<iframe id="ai-ui-iframe" loading="eager" importance="high" pointer-events="none" style="{iframe_style}" srcdoc="{escaped_html_content}"></iframe>'
+
+    # 返回最终的iframe HTML内容
+    iframe_content = re.sub(r'\n\s*\n', '\n', iframe_content)
+    return iframe_content

gui/web_ui.py

@@ -0,0 +1,389 @@
+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(share=share,
+                                                                       server_name=server_name,
+                                                                       server_port=server_port)
+
+    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 @@
+# coding=utf-8

llm/oai.py

@@ -0,0 +1,251 @@
+import copy
+import json
+import logging
+import os
+from http import HTTPStatus
+from pprint import pformat
+from typing import Dict, Iterator, List, Optional, Literal, Union
+
+import openai
+
+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:
+            response = self._chat_complete_create(model=self.model, messages=messages, stream=True, **generate_cfg)
+            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='')]
+                        # 兼容 map agent 模型
+                        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 = ''
+                for chunk in response:
+                    if chunk.choices:
+                        choice = chunk.choices[0]
+                        if hasattr(choice.delta, 'reasoning_content') and choice.delta.reasoning_content:
+                            full_reasoning_content += choice.delta.reasoning_content
+                        if hasattr(choice.delta, 'content') and choice.delta.content:
+                            full_response += choice.delta.content
+                        # 兼容 map agent 模型
+                        if hasattr(choice.delta, 'tool_calls') and choice.delta.tool_calls:
+                            function_name = choice.delta.tool_calls[0].function.name
+                            # function_call = FunctionCall(
+                            #     name=function_name,
+                            #     arguments=choice.delta.tool_calls[0].function.arguments,
+                            # )
+                            # yield [Message(role=ASSISTANT, content='', function_call=function_call)]
+                            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>'
+                        yield [Message(role=ASSISTANT, content=full_response, reasoning_content=full_reasoning_content)]
+                    logger.info(f'message chunk: {chunk}')
+        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]]]:
+        # if delta_stream:
+        #     raise NotImplementedError('Please use stream=True with delta_stream=False, because delta_stream=True'
+        #                               ' is not implemented for function calling due to some technical reasons.')
+        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]:
+        # TODO: Change when the VLLM deployed model needs to pass reasoning_complete.
+        #  At this time, in order to be compatible with lower versions of vLLM,
+        #  and reasoning content is currently not useful
+
+        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

llm/qwen_dashscope.py

@@ -0,0 +1,140 @@
+import os
+from http import HTTPStatus
+from pprint import pformat
+from typing import Dict, Iterator, List, Optional
+
+import dashscope
+
+from qwen_agent.llm.base import ModelServiceError, register_llm
+from qwen_agent.llm.function_calling import BaseFnCallModel
+from qwen_agent.llm.schema import ASSISTANT, Message
+from qwen_agent.log import logger
+
+
+@register_llm('qwen_dashscope')
+class QwenChatAtDS(BaseFnCallModel):
+
+    def __init__(self, cfg: Optional[Dict] = None):
+        super().__init__(cfg)
+        self.model = self.model or 'qwen-max'
+        initialize_dashscope(cfg)
+
+    def _chat_stream(
+        self,
+        messages: List[Message],
+        delta_stream: bool,
+        generate_cfg: dict,
+    ) -> Iterator[List[Message]]:
+        messages = [msg.model_dump() for msg in messages]
+        if messages[-1]['role'] == ASSISTANT:
+            messages[-1]['partial'] = True
+        logger.debug(f'LLM Input:\n{pformat(messages, indent=2)}')
+        response = dashscope.Generation.call(
+            self.model,
+            messages=messages,  # noqa
+            result_format='message',
+            stream=True,
+            **generate_cfg)
+        if delta_stream:
+            return self._delta_stream_output(response)
+        else:
+            return self._full_stream_output(response)
+
+    def _chat_no_stream(
+        self,
+        messages: List[Message],
+        generate_cfg: dict,
+    ) -> List[Message]:
+        messages = [msg.model_dump() for msg in messages]
+        if messages[-1]['role'] == ASSISTANT:
+            messages[-1]['partial'] = True
+        logger.debug(f'LLM Input:\n{pformat(messages, indent=2)}')
+        response = dashscope.Generation.call(
+            self.model,
+            messages=messages,  # noqa
+            result_format='message',
+            stream=False,
+            **generate_cfg)
+        if response.status_code == HTTPStatus.OK:
+            return [
+                Message(role=ASSISTANT,
+                        content=response.output.choices[0].message.content,
+                        reasoning_content=response.output.choices[0].message.get('reasoning_content', ''),
+                        extra={'model_service_info': response})
+            ]
+        else:
+            raise ModelServiceError(code=response.code,
+                                    message=response.message,
+                                    extra={'model_service_info': response})
+
+    def _continue_assistant_response(
+        self,
+        messages: List[Message],
+        generate_cfg: dict,
+        stream: bool,
+    ) -> Iterator[List[Message]]:
+        return self._chat(messages, stream=stream, delta_stream=False, generate_cfg=generate_cfg)
+
+    @staticmethod
+    def _delta_stream_output(response) -> Iterator[List[Message]]:
+        for chunk in response:
+            if chunk.status_code == HTTPStatus.OK:
+                yield [
+                    Message(role=ASSISTANT,
+                            content=chunk.output.choices[0].message.content,
+                            reasoning_content=chunk.output.choices[0].message.reasoning_content,
+                            extra={'model_service_info': chunk})
+                ]
+            else:
+                raise ModelServiceError(code=chunk.code, message=chunk.message, extra={'model_service_info': chunk})
+
+    @staticmethod
+    def _full_stream_output(response) -> Iterator[List[Message]]:
+        full_content = ''
+        full_reasoning_content = ''
+        for chunk in response:
+            if chunk.status_code == HTTPStatus.OK:
+                if chunk.output.choices[0].message.get('reasoning_content', ''):
+                    full_reasoning_content += chunk.output.choices[0].message.reasoning_content
+                if chunk.output.choices[0].message.content:
+                    full_content += chunk.output.choices[0].message.content
+                yield [
+                    Message(role=ASSISTANT,
+                            content=full_content,
+                            reasoning_content=full_reasoning_content,
+                            extra={'model_service_info': chunk})
+                ]
+            else:
+                raise ModelServiceError(code=chunk.code, message=chunk.message, extra={'model_service_info': chunk})
+
+
+def initialize_dashscope(cfg: Optional[Dict] = None) -> None:
+    cfg = cfg or {}
+
+    api_key = cfg.get('api_key', '')
+    base_http_api_url = cfg.get('base_http_api_url', None)
+    base_websocket_api_url = cfg.get('base_websocket_api_url', None)
+
+    if not api_key:
+        api_key = os.getenv('DASHSCOPE_API_KEY', 'EMPTY')
+    if not base_http_api_url:
+        base_http_api_url = os.getenv('DASHSCOPE_HTTP_URL', None)
+    if not base_websocket_api_url:
+        base_websocket_api_url = os.getenv('DASHSCOPE_WEBSOCKET_URL', None)
+
+    api_key = api_key.strip()
+    if api_key in ('', 'EMPTY'):
+        if dashscope.api_key is None or dashscope.api_key in ('', 'EMPTY'):
+            logger.warning('No valid dashscope api_key found in cfg, environment variable `DASHSCOPE_API_KEY` or dashscope.api_key, the model call may raise errors.')
+        else:
+            logger.info('No dashscope api_key found in cfg, using the dashscope.api_key that has already been set.')
+    else: # valid api_key
+        if api_key != dashscope.api_key:
+            logger.info('Setting the dashscope api_key.')
+            dashscope.api_key = api_key
+        # or do nothing since both keys are the same
+  
+    if base_http_api_url is not None:
+        dashscope.base_http_api_url = base_http_api_url.strip()
+    if base_websocket_api_url is not None:
+        dashscope.base_websocket_api_url = base_websocket_api_url.strip()

messages.json

@@ -0,0 +1,34 @@
+[
+    {
+        "role": "system",
+        "content": "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# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>\n{\"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\"]}}}\n{\"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\"]}}}\n{\"type\": \"function\", \"function\": {\"name\": \"PythonInterpreter\", \"description\": \"Executes Python code in a sandboxed environment. To use this tool, you must follow this format:\n1. The 'arguments' JSON object must be empty: {}.\n2. The Python code to be executed must be placed immediately after the JSON block, enclosed within <code> and </code> tags.\n\nIMPORTANT: Any output you want to see MUST be printed to standard output using the print() function.\n\nExample of a correct call:\n<tool_call>\n{\"name\": \"PythonInterpreter\", \"arguments\": {}}\n<code>\nimport numpy as np\n# Your code here\nprint(f\"The result is: {np.mean([1,2,3])}\")\n</code>\n</tool_call>\", \"parameters\": {\"type\": \"object\", \"properties\": {}, \"required\": []}}}\n{\"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\"]}}}\n{\"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\"]}}}\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call>\n\nCurrent date: 2025-09-19"
+    },
+    {
+        "role": "user",
+        "content": "When is the paper submission deadline for the ACL 2025 Industry Track, and what is the venue address for the conference?"
+    },
+    {
+        "role": "assistant",
+        "content": "<think>\n\nThe user asks: \"When is the paper submission deadline for the ACL 2025 Industry Track, and what is the venue address for the conference?\" So we need to find:\n\n- ACL 2025 (Association for Computational Linguistics) conference. Specifically the Industry Track submission deadline date.\n- Venue address for the conference (likely the location, city, country; maybe specific venue address like a convention center).\n\nWe need to browse the web to locate official information about ACL 2025 (maybe it hasn't happened yet). Possibly the site is something like https://2025.aclweb.org or similar.\n\nSearch queries could be:\n\n- \"ACL 2025 industry track submission deadline\"\n- \"ACL 2025 conference venue address\"\n- \"ACL 2025 location\"\n- \"ACL 2025 main conference venue\"\n- \"ACL 2025 call for papers industry track\"\n\nWe will search using the functions.search tool.\n</think>\n<tool_call>\n{\"name\": \"search\", \"arguments\": {\"query\": [\"ACL 2025 industry track submission deadline\", \"ACL 2025 conference venue address\", \"ACL 2025 location\", \"ACL 2025 call for papers industry track\", \"ACL 2025 conference details\"]}}\n</tool_call>"
+    },
+    {
+        "role": "user",
+        "content": "<tool_response>\nA Google search for 'ACL 2025 industry track submission deadline' found 10 results:\n\n## Web Results\n1. [Industry Track](https://2025.aclweb.org/calls/industry_track/)\n\nNote: All deadlines are 11:59PM UTC-12:00 (anywhere on Earth). Following the ACL and ARR Policies for Review and Citation, updated in early 2024, there is no ...\n\n2. [ACL 2025 Industry Track](https://openreview.net/group?id=aclweb.org/ACL/2025/Industry_Track)\nDate published: Jul 28, 2025\n\nPlease see the venue website for more information. Submission Start: Jan 27 2025 12:00AM UTC-0, Submission Deadline: Mar 22 2025 12:59PM UTC-0.\n\n3. [ACL 2025: The 63rd Annual Meeting of the Association for ...](https://2025.aclweb.org/)\n\nCall for Industry Track is out. Oct 7, 2024, First call for papers is out. Sep ... Commitment deadline for ACL 2025, April 20, 2025. Notification of ...\n\n4. [Call for Industry Track Papers](https://2025.naacl.org/calls/industry/)\n\nAll deadlines are 11:59PM UTC-12:00 (“anywhere on Earth”). Paper submission deadline, December 2, 2024 December 7, 2024. Notification of acceptance, February 5, ...\n\n5. [Call for Industry Track Papers](https://2025.emnlp.org/calls/industry_track/)\n\nImportant Dates · Paper submission deadline: July 4, 2025 · Reviewer-author discussion period: August 28 – September 8, 2025 · Notification: September 24, 2025 ...\n\n6. [ACL 2025 Industry Track: Overview](https://aclanthology.org/2025.acl-industry.1/)\nDate published: by G Rehm · 2025\n\nFor the 63rd Annual Meeting of the Association for Computational Linguistics (ACL 2025), it was decided once again to organise a dedicated Industry Track.\n\n7. [The 2025 Conference on Empirical Methods in Natural ...](https://2025.emnlp.org/)\n\nReview submission deadline, June 18, 2025 ; Author response and author-reviewer discussion, June 26 - July 2, 2025 ; Commitment deadline, August 1, 2025.\n\n8. [Acl 2025 deadline](https://assets-global.website-files.com/683fdb5e8008a99e5b00140f/6854688e54c673b87dfbc2c6_nukanavowazix.pdf)\nDate published: Jun 29, 2025\n\nAuthors of accepted papers must submit pre-recorded video presentations, poster PDFs and/or slides. CL and TACL authors also need to upload ...\n\n9. [ACL 2025 (@aclmeeting) / X](https://x.com/aclmeeting?lang=en)\n\n... submission deadline: Oct 6, 2025 • EACL commitment deadline: Dec 14, 2025. A tall building with intricate geometric patterns on its facade, featuring arched ...\n\n10. [ACL 2025 The 63rd Annual Meeting of the Association for ...](https://aclanthology.org/2025.acl-industry.0.pdf)\nDate published: by G Rehm · 2025\n\n... Industry Track submissions as well as the reviewers and area chairs for their hard and dedicated work under very tight deadlines. We would ...\n=======\nA Google search for 'ACL 2025 conference venue address' found 10 results:\n\n## Web Results\n1. [Venue](https://2025.aclweb.org/venue/)\n\nThe Austria Center Vienna is an easy-to-reach location, and right in the heart of Europe. And the only conference centre in the world that is situated right ...\n\n2. [ACL 2025: The 63rd Annual Meeting of the Association for ...](https://2025.aclweb.org/)\n\nThe 63rd Annual Meeting of the Association for Computational Linguistics (ACL 2025) will take place in Vienna, Austria from July 27 to August 1st, 2025.\n\n3. [ACL 2025](https://www.clarin.eu/event/2025/acl-2025)\n\nThe 63rd Annual Meeting of the Association for Computational Linguistics (ACL 2025) will take place in Vienna, Austria from July 27 to August 1st, 2025.\n\n4. [ACL 2025 Conference](https://openreview.net/group?id=aclweb.org/ACL/2025/Conference)\n\nThe 63rd Annual Meeting of the Association for Computational Linguistics. ACL 2025. Vienna, AustriaJul 27 2025https://2025.aclweb.org/[email protected].\n\n5. [ACL 2025 in Vienna, Austria](https://scads.ai/acl-2025-in-vienna-austria/)\nDate published: Aug 5, 2025\n\nFrom July 27 to August 1 the 63rd Annual Meeting of the Association for Computational Linguistics ACL 2025 took place in Vienna, Austria.\n\n6. [ACL 2025 (@aclmeeting) / X](https://x.com/aclmeeting?lang=en)\n\nJoin us for our 30th anniversary conference , November 4–9, 2025! Early registration ends on October 6, 2025. Space is limited, so register soon to ...\n\n7. [ACL 2025 : The 63rd Annual Meeting of the Association for ...](http://www.wikicfp.com/cfp/servlet/event.showcfp?copyownerid=90704&eventid=183095)\n\nACL 2025 Call for Papers Main Conference ACL 2025. Website: https://2025.aclweb.org/ Submission Deadline: February 15, 2025. Conference Dates: July 27 to ...\n\n8. [2025 Annual Conference of the Nations of the Americas ...](https://2025.naacl.org/)\n\n2025 Annual Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics Albuquerque, New Mexico April 29–May 4, 2025\n\n9. [Annual Meeting of the Association for Computational ...](https://aclanthology.org/events/acl-2025/)\n\nAnnual Meeting of the Association for Computational Linguistics (2025) ... address the lack of ground truth explanations to train the model, we propose ...\n\n10. [IBM at ACL 2025 - Vienna, Austria and virtual](https://research.ibm.com/events/acl-2025)\nDate published: Jul 27, 2025\n\nThis event has ended. About. IBM is proud to sponsor the 63rd Annual Meeting of the Association for Computational Linguistics (ACL 2025).\n=======\nA Google search for 'ACL 2025 location' found 10 results:\n\n## Web Results\n1. [Austin City Limits Music Festival | Austin, TX | October 3-5 & 10 ...](https://www.aclfestival.com/)\n\nAustin City Limits Music Festival will be presented at Zilker Park, in Austin, TX on October 3-5 & 10-12, 2025. Stay connected for upcoming announcements ...\n\n2. [ACL 2025: The 63rd Annual Meeting of the Association for ...](https://2025.aclweb.org/)\n\nThe 63rd Annual Meeting of the Association for Computational Linguistics (ACL 2025) will take place in Vienna, Austria from July 27 to August 1st, 2025.\n\n3. [Venue](https://2025.aclweb.org/venue/)\n\nThe Austria Center Vienna is an easy-to-reach location, and right in the heart of Europe. And the only conference centre in the world that is situated right ...\n\n4. [Tickets | Austin City Limits Music Festival](https://www.aclfestival.com/tickets)\n\nBuy tickets for Austin City Limits Music Festival for October 3-5 & 10-12, 2025.\n\n5. [Austin City Limits Music Festival | Tickets, Dates & More](https://www.austintexas.org/events/acl-fest/)\n\nPlan your ACL 2025 visit! Get tickets, VIP passes, hotel options, and learn about the best activities for an unforgettable experience in Austin.\n\n6. [Austin City Limits Music Festival 2025 guide: tickets, tips ...](https://www.statesman.com/entertainment/music/article/acl-fest-guide-lineup-schedule-zilker-rules-21040936.php)\nDate published: 3 days ago\n\nACL Fest runs Oct. 3-5 and Oct. 10-12 in Zilker Park, 2100 Barton Springs Road. Gates open at noon and close at 10 p.m. on Friday, Saturday and ...\n\n7. [ACL 2025 (@aclmeeting) / X](https://x.com/aclmeeting?lang=en)\n\nWelcome to Vienna! What an incredible week it has been here in Vienna for the main conference!\n\n8. [ACL 2025](https://www.clarin.eu/event/2025/acl-2025)\n\nThe 63rd Annual Meeting of the Association for Computational Linguistics (ACL 2025) will take place in Vienna, Austria from July 27 to August 1st, 2025.\n\n9. [Festival Map](https://support.aclfestival.com/hc/en-us/articles/4405399774484-Festival-Map)\n\nWhat are the dates of ACL Festival 2025? Where is the festival located? Can I leave and re-enter on the same day? Can I check my chair at ...\n\n10. [What are the dates of ACL Festival 2025?](https://support.aclfestival.com/hc/en-us/articles/4405406283924-What-are-the-dates-of-ACL-Festival-2025)\nDate published: Aug 27, 2025\n\nAustin City Limits Music Festival will take place on October 3-5 and October 10-12, 2025. Sign-up for our SMS list to be the first to know ...\n=======\nA Google search for 'ACL 2025 call for papers industry track' found 10 results:\n\n## Web Results\n1. [Industry Track](https://2025.aclweb.org/calls/industry_track/)\n\nThis track provides an opportunity to highlight the key insights and new research challenges that arise from real world implementations.\n\n2. [ACL 2025: The 63rd Annual Meeting of the Association for ...](https://2025.aclweb.org/)\n\nCall for System Demonstrations is out. Jan 20, 2025, Second call for papers is out. Dec 3, 2024, Call for Industry Track is out. Oct 7, 2024, First call for ...\n\n3. [ACL 2025 Industry Track](https://openreview.net/group?id=aclweb.org/ACL/2025/Industry_Track)\n\nPlease see the venue website for more information. Submission Start: Jan 27 2025 12:00AM UTC-0, Submission Deadline: Mar 22 2025 12:59PM UTC-0.\n\n4. [Call for Industry Track Papers](https://2025.naacl.org/calls/industry/)\n\nThe industry track welcomes submissions describing innovations and implementations of applications in all areas of speech and natural language processing.\n\n5. [ACL Industry track 2025 decisions : r/airesearch](https://www.reddit.com/r/airesearch/comments/1ki8ohz/acl_industry_track_2025_decisions/)\nDate published: 4 months ago\n\nACL indutry track reviews will be out soon. This is a thread for all types of discussions.\n\n6. [Call for Industry Track Papers](https://2025.emnlp.org/calls/industry_track/)\n\nThe EMNLP 2025 Industry Track provides the opportunity to highlight the key insights and new research challenges that arise from the development and deployment ...\n\n7. [ACL 2025 Industry Track: Overview](https://aclanthology.org/2025.acl-industry.1/)\nDate published: by G Rehm · 2025\n\nFor the 63rd Annual Meeting of the Association for Computational Linguistics (ACL 2025), it was decided once again to organise a dedicated Industry Track.\n\n8. [2025 Annual Conference of the Nations of the Americas ...](https://2025.naacl.org/)\n\nCall for industry track papers is out. Oct 01, 2024, Second call for papers is out. Sep 10, 2024, The ACL-NAACL-EMNLP joint call for tutorials is out. Sep 10 ...\n\n9. [Call for Industry Track](https://coling2025.org/calls/industry_track/)\n\nTopics of InterestPermalink. The purpose of this track is to showcase key insights and emerging research challenges emanating from practical applications.\n\n10. [ACL 2025 Industry Track: Overview](https://aclanthology.org/2025.acl-industry.1.pdf)\nDate published: by G Rehm · 2025\n\n3 Submissions and Results. The call for Industry Track papers attracted an un- precedented number of 421 paper submissions. A total of 453 ...\n=======\nA Google search for 'ACL 2025 conference details' found 10 results:\n\n## Web Results\n1. [ACL 2025: The 63rd Annual Meeting of the Association for ...](https://2025.aclweb.org/)\n\nImportant Dates ; Camera-ready papers due, May 30, 2025 ; Overall Conference, July 27 to August 1st, 2025 ; Tutorials & Welcome Reception, July 27, 2025 ; Main ...\n\n2. [ACL 2025 Conference](https://openreview.net/group?id=aclweb.org/ACL/2025/Conference)\n\nThe 63rd Annual Meeting of the Association for Computational Linguistics. ACL 2025. Vienna, AustriaJul 27 2025https://2025.aclweb.org/[email protected].\n\n3. [ACL 2025 (@aclmeeting) / X](https://x.com/aclmeeting?lang=en)\n\nWe look forward to seeing you at #ACL2026 in San Diego! ACL SRW 2025 updates the program schedule: acl2025-srw.github.io/schedule. Welcome to Vienna! What an ...\n\n4. [Annual Meeting of the Association for Computational ...](https://aclanthology.org/events/acl-2025/)\n\n... ACL 2025 1388 papers; Proceedings of the Sixth Workshop on African Natural Language Processing (AfricaNLP 2025) 29 papers; Proceedings of the 2nd Workshop on ...\n\n5. [2025 Annual Conference of the Nations of the Americas ...](https://2025.naacl.org/)\n\nSubmission Deadline (via ACL Rolling Review), October 15, 2024 ; Welcome Reception, Tuesday, April 29, 2025 ; Main Conference, Wednesday–Friday, April 30–May 2, ...\n\n6. [ACL 2025](https://www.clarin.eu/event/2025/acl-2025)\n\nThe 63rd Annual Meeting of the Association for Computational Linguistics (ACL 2025) will take place in Vienna, Austria from July 27 to August 1st, 2025.\n\n7. [2025 ACL Conference Registration](https://acl.swoogo.com/acl2025)\n\n2025 ACL Conference Registration July 27 - August 1, 2025. Early Registration: Ends Wednesday, July 2, 2025. AOE Late Registration: Ends for In-Person and ...\n\n8. [ACL 2025 The 63rd Annual Meeting of the Association for ...](https://aclanthology.org/2025.acl-long.0.pdf)\nDate published: by W Che · 2025\n\nACL 2025 hosts a rich set of 28 workshops and 8 tutorials, thanks to the dedicated efforts of our Wo- rkshop Chairs — Terra Blevins and ...\n\n9. [Dates and Venues](http://aclrollingreview.org/dates)\nDate published: May 19, 2025\n\nThis table lists all the key dates, by which the authors may need to take action, for 2025 cycles following the new schedule.\n\n10. [ACL 2025 : The 63rd Annual Meeting of the Association for ...](http://www.wikicfp.com/cfp/servlet/event.showcfp?copyownerid=90704&eventid=183095)\n\nConference July 28 - 30, 2025. Workshops July 31 - August 1, 2025. Note: All deadlines are 11:59PM UTC-12:00 (“anywhere on Earth”). Paper Submission Details\n</tool_response>"
+    },
+    {
+        "role": "assistant",
+        "content": "<think>\n\nWe have search results. The relevant ones for submission deadline of Industry Track:\n\n- #1: \"Industry Track\" page at https://2025.aclweb.org/calls/industry_track/. It might have the exact deadline.\n\n- #2: OpenReview group for ACL 2025 Industry Track shows \"Submission Deadline: Mar 22 2025 12:59PM UTC-0\".\n\nBut we need to verify which is correct. Could be that the industry track call has a deadline in March (like March 22, 2025). But we also see other info from different sources showing deadlines like December 2/7, 2024 for NAACL (not relevant). The question is specifically \"paper submission deadline for the ACL 2025 Industry Track\". We should check the official ACL 2025 website's calls/industry_track page.\n\nLet's visit that URL.\n</think>\n<tool_call>\n{\"name\": \"visit\", \"arguments\": {\"url\": [\"https://2025.aclweb.org/calls/industry_track/\"], \"goal\": \"Find the paper submission deadline date for the ACL 2025 Industry Track.\"}}\n</tool_call>"
+    },
+    {
+        "role": "user",
+        "content": "<tool_response>\nThe useful information in https://2025.aclweb.org/calls/industry_track/ for user goal Find the paper submission deadline date for the ACL 2025 Industry Track. as follows: \n\nEvidence in page: \nIMPORTANT DATES\n---------------\n\nPaper submission deadline: 21 March 2025\n\nNotification of acceptance: 09 May 2025\n\nCamera-ready version of papers due: 23 May 2025\n\nMain conference: 28-30 July 2025\n\nNote: All deadlines are 11:59PM UTC-12:00 (anywhere on Earth).\n\nSummary: \nThe paper submission deadline for the ACL 2025 Industry Track is 21 March 2025, at 11:59 PM UTC-12:00 (anywhere on Earth). This deadline is explicitly stated in the 'IMPORTANT DATES' section of the call for papers, which also outlines subsequent key dates including notification of acceptance (9 May 2025), camera-ready version submission (23 May 2025), and the main conference dates (28–30 July 2025).\n</tool_response>"
+    },
+    {
+        "role": "assistant",
+        "content": "<think>\n\nGreat. The page shows \"Paper submission deadline: 21 March 2025\". However, earlier the OpenReview group indicated March 22 2025 12:59PM UTC-0. The official website is more authoritative.\n\nNow we need venue address for the conference. Search results show a \"Venue\" page at https://2025.aclweb.org/venue/. Let's visit that.\n</think>\n<tool_call>\n{\"name\": \"visit\", \"arguments\": {\"url\": [\"https://2025.aclweb.org/venue/\"], \"goal\": \"Find the venue address for the ACL 2025 conference.\"}}\n</tool_call>"
+    },
+    {
+        "role": "user",
+        "content": "<tool_response>\nThe useful information in https://2025.aclweb.org/venue/ for user goal Find the venue address for the ACL 2025 conference. as follows: \n\nEvidence in page: \nConference Venue\n----------------\n\nAustria Center Vienna Bruno-Kreisky-Platz 1, 1220 Wien, Austria\n\n +43 1 260690\n\n[https://www.acv.at/en/](https://www.acv.at/en/)\n\nThe Austria Center Vienna is an easy-to-reach location, and right in the heart of Europe. And the only conference centre in the world that is situated right next door to a UN headquarters. Austria’s largest congress center with 21 halls, 134 meeting rooms and 5 exhibition halls on 5 levels, with room for up to 22,800 people.\n\nSummary: \nThe venue for the ACL 2025 conference is the Austria Center Vienna, located at Bruno-Kreisky-Platz 1, 1220 Wien, Austria. This major congress center is situated in the heart of Europe, adjacent to a UN headquarters, and features 21 halls, 134 meeting rooms, and 5 exhibition halls, capable of accommodating up to 22,800 attendees.\n</tool_response>"
+    }
+]

prompt.py

@@ -0,0 +1,15 @@
+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,2 @@
+qwen-agent[gui,rag,code_interpreter,mcp]
+sandbox_fusion

scholar.py

@@ -0,0 +1,111 @@
+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:
+        # assert GOOGLE_SEARCH_KEY is not None, "Please set the IDEALAB_SEARCH_KEY environment variable."
+        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,136 @@
+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,481 @@
+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(',')
+
+
+@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)
+        # self.summary_mapping = SummaryMapping()
+    
+    @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:
+            # super().call(params=params, files=files)  # copy remote files to work_dir
+            try:
+                code=params.split('<code>')[1].split('</code')[0]
+                print(params)
+                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 '[Python Interpreter Error]: Empty code.'
+
+            # Retry mechanism with randomly sampled endpoints
+        #     code=params
+            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
+
+
+
+def test_single_endpoint(endpoint: str, test_cases: List[dict], timeout: int = 30) -> dict:
+    """Test a single endpoint with multiple test cases"""
+    executor = PythonInterpreter()
+    results = {
+        'endpoint': endpoint,
+        'status': 'unknown',
+        'passed_tests': 0,
+        'total_tests': len(test_cases),
+        'test_results': [],
+        'avg_execution_time': 0,
+        'errors': []
+    }
+    
+    execution_times = []
+    
+    print(f"\n🧪 Testing endpoint: {endpoint}")
+    
+    for i, test_case in enumerate(test_cases):
+        test_name = test_case['name']
+        test_code = test_case['code']
+        expected_output = test_case.get('expected_output')
+        
+        print(f"  ├─ Running test {i+1}/{len(test_cases)}: {test_name}")
+        
+        try:
+            success, result, exec_time = executor.call_specific_endpoint(
+                {"code": test_code}, endpoint, timeout
+            )
+            
+            test_result = {
+                'name': test_name,
+                'success': success,
+                'result': result,
+                'execution_time': exec_time,
+                'expected_match': False
+            }
+            
+            if success and exec_time is not None:
+                execution_times.append(exec_time)
+                
+                # Check if output matches expected (if provided)
+                if expected_output:
+                    # Clean up output for comparison
+                    actual_output = result.replace('stdout:\n', '').strip()
+                    if expected_output.strip() in actual_output:
+                        test_result['expected_match'] = True
+                        results['passed_tests'] += 1
+                        print(f"  │  ✅ PASSED ({exec_time:.2f}s)")
+                    else:
+                        print(f"  │  ❌ OUTPUT MISMATCH ({exec_time:.2f}s)")
+                        print(f"  │     Expected: {expected_output.strip()}")
+                        print(f"  │     Got: {actual_output}")
+                else:
+                    # No expected output specified, just check if it ran successfully
+                    test_result['expected_match'] = True
+                    results['passed_tests'] += 1
+                    print(f"  │  ✅ PASSED ({exec_time:.2f}s)")
+            else:
+                print(f"  │  ❌ FAILED: {result}")
+                results['errors'].append(f"{test_name}: {result}")
+            
+            results['test_results'].append(test_result)
+            
+        except Exception as e:
+            print(f"  │  💥 EXCEPTION: {str(e)}")
+            results['errors'].append(f"{test_name}: Exception - {str(e)}")
+            results['test_results'].append({
+                'name': test_name,
+                'success': False,
+                'result': f"Exception: {str(e)}",
+                'execution_time': None,
+                'expected_match': False
+            })
+    
+    # Calculate statistics
+    if execution_times:
+        results['avg_execution_time'] = sum(execution_times) / len(execution_times)
+    
+    # Determine overall status
+    if results['passed_tests'] == results['total_tests']:
+        results['status'] = 'healthy'
+        print(f"  └─ ✅ ALL TESTS PASSED ({results['passed_tests']}/{results['total_tests']})")
+    elif results['passed_tests'] > 0:
+        results['status'] = 'partial'
+        print(f"  └─ ⚠️  PARTIAL SUCCESS ({results['passed_tests']}/{results['total_tests']})")
+    else:
+        results['status'] = 'failed'
+        print(f"  └─ ❌ ALL TESTS FAILED ({results['passed_tests']}/{results['total_tests']})")
+    
+    return results
+
+
+def test_all_endpoints_comprehensive():
+    """Comprehensive test suite for all sandbox fusion endpoints"""
+    
+    # Define comprehensive test cases
+    test_cases = [
+        {
+            'name': 'Basic Math',
+            'code': 'print(2 + 2)',
+            'expected_output': '4'
+        },
+        {
+            'name': 'String Operations',
+            'code': 'print("Hello, " + "World!")',
+            'expected_output': 'Hello, World!'
+        },
+        {
+            'name': 'List Operations',
+            'code': '''
+numbers = [1, 2, 3, 4, 5]
+print(f"Sum: {sum(numbers)}")
+print(f"Length: {len(numbers)}")
+''',
+            'expected_output': 'Sum: 15'
+        },
+        {
+            'name': 'Dictionary Operations',
+            'code': '''
+data = {"name": "Test", "value": 42}
+print(f"Name: {data['name']}, Value: {data['value']}")
+''',
+            'expected_output': 'Name: Test, Value: 42'
+        },
+        {
+            'name': 'Loop and Conditionals',
+            'code': '''
+result = []
+for i in range(5):
+    if i % 2 == 0:
+        result.append(i)
+print(f"Even numbers: {result}")
+''',
+            'expected_output': 'Even numbers: [0, 2, 4]'
+        },
+        {
+            'name': 'Function Definition',
+            'code': '''
+def factorial(n):
+    if n <= 1:
+        return 1
+    return n * factorial(n-1)
+
+print(f"5! = {factorial(5)}")
+''',
+            'expected_output': '5! = 120'
+        },
+        {
+            'name': 'Exception Handling',
+            'code': '''
+try:
+    result = 10 / 2
+    print(f"Division result: {result}")
+except ZeroDivisionError:
+    print("Cannot divide by zero")
+''',
+            'expected_output': 'Division result: 5.0'
+        },
+        {
+            'name': 'Import Standard Library',
+            'code': '''
+import math
+print(f"Pi: {math.pi:.2f}")
+print(f"Square root of 16: {math.sqrt(16)}")
+''',
+            'expected_output': 'Pi: 3.14'
+        },
+        {
+            'name': 'Complex Calculation',
+            'code': '''
+import math
+
+# Calculate area of a circle
+radius = 5
+area = math.pi * radius ** 2
+print(f"Area of circle with radius {radius}: {area:.2f}")
+
+# Fibonacci sequence
+def fibonacci(n):
+    if n <= 1:
+        return n
+    return fibonacci(n-1) + fibonacci(n-2)
+
+fib_10 = fibonacci(10)
+print(f"10th Fibonacci number: {fib_10}")
+''',
+            'expected_output': 'Area of circle with radius 5: 78.54'
+        },
+        {
+            'name': 'Error Handling Test',
+            'code': '''
+try:
+    undefined_variable
+except NameError as e:
+    print("Caught NameError as expected")
+    print("Test passed")
+''',
+            'expected_output': 'Test passed'
+        }
+    ]
+    
+    print("🚀 Starting comprehensive endpoint testing...")
+    print(f"📊 Testing {len(SANDBOX_FUSION_ENDPOINTS)} endpoints with {len(test_cases)} test cases each")
+    print("=" * 80)
+    
+    # Test all endpoints concurrently
+    all_results = []
+    
+    # Use ThreadPoolExecutor for concurrent testing
+    with ThreadPoolExecutor(max_workers=min(len(SANDBOX_FUSION_ENDPOINTS), 8)) as executor:
+        future_to_endpoint = {
+            executor.submit(test_single_endpoint, endpoint, test_cases): endpoint 
+            for endpoint in SANDBOX_FUSION_ENDPOINTS
+        }
+        
+        for future in as_completed(future_to_endpoint):
+            endpoint = future_to_endpoint[future]
+            try:
+                result = future.result()
+                all_results.append(result)
+            except Exception as exc:
+                print(f'❌ Endpoint {endpoint} generated an exception: {exc}')
+                all_results.append({
+                    'endpoint': endpoint,
+                    'status': 'failed',
+                    'passed_tests': 0,
+                    'total_tests': len(test_cases),
+                    'test_results': [],
+                    'avg_execution_time': 0,
+                    'errors': [f'Exception during testing: {exc}']
+                })
+    
+    # Print comprehensive summary
+    print("\n" + "=" * 80)
+    print("📈 COMPREHENSIVE TEST RESULTS SUMMARY")
+    print("=" * 80)
+    
+    healthy_endpoints = [r for r in all_results if r['status'] == 'healthy']
+    partial_endpoints = [r for r in all_results if r['status'] == 'partial']
+    failed_endpoints = [r for r in all_results if r['status'] == 'failed']
+    
+    print(f"✅ Healthy endpoints: {len(healthy_endpoints)}/{len(SANDBOX_FUSION_ENDPOINTS)}")
+    print(f"⚠️  Partial endpoints: {len(partial_endpoints)}/{len(SANDBOX_FUSION_ENDPOINTS)}")
+    print(f"❌ Failed endpoints: {len(failed_endpoints)}/{len(SANDBOX_FUSION_ENDPOINTS)}")
+    
+    if healthy_endpoints:
+        print(f"\n🎉 HEALTHY ENDPOINTS ({len(healthy_endpoints)}):")
+        for result in healthy_endpoints:
+            print(f"  ✅ {result['endpoint']} (avg: {result['avg_execution_time']:.2f}s)")
+    
+    if partial_endpoints:
+        print(f"\n⚠️  PARTIAL ENDPOINTS ({len(partial_endpoints)}):")
+        for result in partial_endpoints:
+            print(f"  ⚠️  {result['endpoint']} ({result['passed_tests']}/{result['total_tests']} tests passed)")
+    
+    if failed_endpoints:
+        print(f"\n❌ FAILED ENDPOINTS ({len(failed_endpoints)}):")
+        for result in failed_endpoints:
+            print(f"  ❌ {result['endpoint']} (0/{result['total_tests']} tests passed)")
+            if result['errors']:
+                for error in result['errors'][:3]:  # Show first 3 errors
+                    print(f"     └─ {error}")
+    
+    # Performance statistics
+    healthy_times = [r['avg_execution_time'] for r in healthy_endpoints if r['avg_execution_time'] > 0]
+    if healthy_times:
+        print(f"\n⚡ PERFORMANCE STATISTICS:")
+        print(f"  Fastest endpoint: {min(healthy_times):.2f}s")
+        print(f"  Slowest endpoint: {max(healthy_times):.2f}s")
+        print(f"  Average response time: {sum(healthy_times)/len(healthy_times):.2f}s")
+    
+    # Overall health score
+    total_tests = len(SANDBOX_FUSION_ENDPOINTS) * len(test_cases)
+    passed_tests = sum(r['passed_tests'] for r in all_results)
+    health_score = (passed_tests / total_tests) * 100
+    
+    print(f"\n🏥 OVERALL SYSTEM HEALTH: {health_score:.1f}%")
+    print(f"   ({passed_tests}/{total_tests} total tests passed)")
+    
+    if health_score >= 90:
+        print("   🟢 Excellent - System is performing well")
+    elif health_score >= 70:
+        print("   🟡 Good - Some endpoints may need attention")
+    elif health_score >= 50:
+        print("   🟠 Fair - Multiple endpoints having issues")
+    else:
+        print("   🔴 Poor - System requires immediate attention")
+    
+    return all_results
+
+
+def _test():
+    """Original test function"""
+    # test_code = """import sympy as sp\nX=sp.symbols('X')\npoly_factor = (X**2 - (sp.sqrt(34)+sp.sqrt(14))*X + 2*sp.sqrt(119))*(X**2 - 2*(sp.sqrt(11)+sp.sqrt(6))*X + 4*sp.sqrt(66))\npoly_original = X**4 - sp.sqrt(34)*X**3 - sp.sqrt(14)*X**3 - 2*sp.sqrt(11)*X**3 - 2*sp.sqrt(6)*X**3 + 2*sp.sqrt(374)*X**2 + 2*sp.sqrt(154)*X**2 + 2*sp.sqrt(119)*X**2 + 4*sp.sqrt(66)*X**2 + 4*sp.sqrt(51)*X**2 + 4*sp.sqrt(21)*X**2 - 4*sp.sqrt(1309)*X - 4*sp.sqrt(714)*X - 8*sp.sqrt(561)*X - 8*sp.sqrt(231)*X + 8*sp.sqrt(7854)\nprint('expanded factor matches?', sp.simplify(poly_factor - poly_original) == 0)\nprint('Difference simplified:', sp.simplify(poly_factor - poly_original))\n"""
+    # params = {"code": test_code}
+    # params = {"code": "x = 1.25\nprint(x*x)"}
+    params = "print(1234)"
+    # '![fig-001](workspace/tools/CodeInterpreter/ac1b42e5-19fb-460e-b3a3-5f1029658efd.png)'
+    executor = PythonInterpreter()
+    out = executor.call(params)
+    from pprint import pprint
+    pprint(out)
+
+
+if __name__ == '__main__':
+    # Run comprehensive endpoint testing
+    test_all_endpoints_comprehensive()
+    
+    print("\n" + "=" * 80)
+    print("🔧 Running original test...")
+    print("=" * 80)
+    
+    # Also run the original test
+    _test()

utils/date.py

@@ -0,0 +1,71 @@
+import random
+from datetime import datetime, timedelta, timezone
+
+DEFAULT_DATE_FORMAT = "%Y-%m-%d"
+
+wdays = {
+    "en": [
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday",
+        "Sunday",
+    ],
+    "zh": [
+        "星期一",
+        "星期二",
+        "星期三",
+        "星期四",
+        "星期五",
+        "星期六",
+        "星期日",
+    ],
+}
+
+
+def get_date_now() -> list[int]:
+    beijing_time = datetime.now(timezone.utc) + timedelta(hours=8)
+    date = beijing_time.timetuple()
+    date = [int(d) for d in [date.tm_year, date.tm_mon, date.tm_mday, date.tm_wday]]
+    return date
+
+
+def get_date_rand(before_days: int = 365, after_days: int = 365) -> list[int]:
+    random_timedelta = timedelta(days=random.randint(-before_days, after_days))
+    rand_time = datetime.now(timezone.utc) + random_timedelta
+    date = rand_time.timetuple()
+    date = [int(d) for d in [date.tm_year, date.tm_mon, date.tm_mday, date.tm_wday]]
+    return date
+
+
+def str2date(date_str, date_format: str = DEFAULT_DATE_FORMAT) -> list[int]:
+    time = datetime.strptime(date_str, date_format)
+    date = time.timetuple()
+    date = [int(d) for d in [date.tm_year, date.tm_mon, date.tm_mday, date.tm_wday]]
+    return date
+
+
+def date2str(
+    date,
+    sep="-",
+    with_week: bool = False,
+    language: str = "en",
+    date_format: str = DEFAULT_DATE_FORMAT,
+) -> str:
+    # YYYY-MM-DD
+    if isinstance(date, str):
+        date = str2date(date, date_format=date_format)
+
+    date_str = sep.join([f"{date[0]:04d}", f"{date[1]:02d}", f"{date[2]:02d}"])
+    if with_week:
+        wday = wdays[language][date[3]]
+        date_str = f"{date_str} {wday}"
+    return date_str
+
+
+if __name__ == "__main__":
+    rand_date = get_date_now()
+    print(date2str(rand_date, with_week=True))
+    print(date2str(rand_date, with_week=True, language="zh"))

utils/logs.py

@@ -0,0 +1,51 @@
+# coding=utf-8
+import os
+import sys
+import logging
+
+
+import platform
+
+
+def check_macos():
+    os_name = platform.system()
+    if os_name == 'Darwin':
+        return True
+    return False
+
+def setup_logger(level = None, logfile_name: str = 'search-agent'):
+    if level is None:
+        if os.getenv('SEARCH_AGENT_DEBUG', '0').strip().lower() in ('1', 'true'):
+            level = logging.DEBUG
+        else:
+            level = logging.INFO
+
+    formatter = logging.Formatter('%(asctime)s - %(filename)s - %(lineno)d - %(levelname)s - %(message)s')
+
+    handler = logging.StreamHandler()
+    # Do not run handler.setLevel(level) so that users can change the level via logger.setLevel later
+    handler.setFormatter(formatter)
+
+    # agent path
+    if check_macos():
+        agent_path = 'logs'
+    else:
+        agent_path = os.getenv('AGENT_PATH', 'logs')
+        if len(agent_path) > 0:
+            agent_path = agent_path + '/logs'
+    # check path
+    if not os.path.exists(agent_path):
+        os.makedirs(agent_path)
+    file_handler = logging.FileHandler(f'{agent_path}/{logfile_name}.log')
+    file_handler.setFormatter(formatter)
+
+    _logger = logging.getLogger(logfile_name)
+    _logger.setLevel(level)
+    _logger.addHandler(handler)
+    _logger.addHandler(file_handler)
+    return _logger
+
+
+logger = setup_logger(logfile_name='search-agent')
+access_logger = setup_logger(logfile_name='search-agent-access')
+error_logger = setup_logger(logfile_name='search-agent-error')

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", "")
+
+
+@staticmethod
+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 = "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}",
+            }
+            print(headers)
+            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"}'))