upload

app.py

@@ -0,0 +1,85 @@
+import os
+os.system("pip install 'https://modelscope-studios.oss-cn-zhangjiakou.aliyuncs.com/SDK/gradio/gradio-4.44.0-py3-none-any.whl?OSSAccessKeyId=LTAI5tCGZWFdkWKivGKCtvTD&Expires=361727611665&Signature=iynlOFVFiaF3OmxatNMHUBPfb3o%3D'")
+os.system("pip install starlette==0.38.6 fastapi==0.112.4")
+
+from typing import List, Tuple, Union
+from web_ui import WebUI
+import math
+
+from qwen_agent.agents import Assistant
+from qwen_agent.tools.base import register_tool
+from qwen_agent.tools.doc_parser import Record
+from qwen_agent.tools.search_tools.base_search import RefMaterialOutput, BaseSearch
+from qwen_agent.log import logger
+from qwen_agent.gui.gradio import gr
+
+POSITIVE_INFINITY = math.inf
+
+@register_tool('no_search')
+class NoSearch(BaseSearch):
+    def call(self, params: Union[str, dict], docs: List[Union[Record, str, List[str]]] = None, **kwargs) -> list:
+        """The basic search algorithm
+
+        Args:
+            params: The dict parameters.
+            docs: The list of parsed doc, each doc has unique url.
+
+        Returns:
+            The list of retrieved chunks from each doc.
+
+        """
+        params = self._verify_json_format_args(params)
+        # Compatible with the parameter passing of the qwen-agent version <= 0.0.3
+        max_ref_token = kwargs.get('max_ref_token', self.max_ref_token)
+
+        # The query is a string that may contain only the original question,
+        # or it may be a json string containing the generated keywords and the original question
+        if not docs:
+            return []
+        return self._get_the_front_part(docs, max_ref_token)
+
+    @staticmethod
+    def _get_the_front_part(docs: List[Record], max_ref_token: int) -> list:
+        all_tokens = 0
+        _ref_list = []
+        for doc in docs:
+            text = []
+            for page in doc.raw:
+                text.append(page.content)
+                all_tokens += page.token
+            now_ref_list = RefMaterialOutput(url=doc.url, text=text).to_dict()
+            _ref_list.append(now_ref_list)
+
+        logger.info(f'Using tokens: {all_tokens}')
+        if all_tokens > max_ref_token:
+            raise gr.Error(f"Your document files (around {all_tokens} tokens) exceed the maximum context length ({max_ref_token} tokens).")
+        return _ref_list
+
+    def sort_by_scores(self,
+                       query: str,
+                       docs: List[Record],
+                       max_ref_token: int,
+                       **kwargs) -> List[Tuple[str, int, float]]:
+        raise NotImplementedError
+
+def app_gui():
+    # Define the agent
+    bot = Assistant(llm={
+                    'model': 'pre-qwen-turbo-1m-1101-blade-opt',
+                    'generate_cfg': {
+                        'max_input_tokens': 1000000,
+                        'max_retries': 10,
+                    }},
+                    name='Qwen-Turbo-1M',
+                    description='Qwen-Turbo natively supports input length of up to 1M tokens. You can upload documents for Q&A, supporting file types: PDF/Word/PPT/TXT/HTML.',
+                    rag_cfg={'max_ref_token': 1000000, 'rag_searchers': ['no_search']},
+                )
+    chatbot_config = {
+        'input.placeholder': "Type \"/clear\" to clear the history",
+        'verbose': True,
+    }
+    WebUI(bot, chatbot_config=chatbot_config).run()
+
+if __name__ == '__main__':
+    import patching # patch qwen-agent to accelerate 1M processing
+    app_gui()

assets/app.css

@@ -0,0 +1,147 @@
+/* code highlight: https://python-markdown.github.io/extensions/code_hilite/ */
+.codehilite .hll { background-color: #ffffcc }
+.codehilite  { background: #f8f8f8; }
+.codehilite .c { color: #408080; font-style: italic } /* Comment */
+.codehilite .err { border: 1px solid #FF0000 } /* Error */
+.codehilite .k { color: #008000; font-weight: bold } /* Keyword */
+.codehilite .o { color: #666666 } /* Operator */
+.codehilite .ch { color: #408080; font-style: italic } /* Comment.Hashbang */
+.codehilite .cm { color: #408080; font-style: italic } /* Comment.Multiline */
+.codehilite .cp { color: #BC7A00 } /* Comment.Preproc */
+.codehilite .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */
+.codehilite .c1 { color: #408080; font-style: italic } /* Comment.Single */
+.codehilite .cs { color: #408080; font-style: italic } /* Comment.Special */
+.codehilite .gd { color: #A00000 } /* Generic.Deleted */
+.codehilite .ge { font-style: italic } /* Generic.Emph */
+.codehilite .gr { color: #FF0000 } /* Generic.Error */
+.codehilite .gh { color: #000080; font-weight: bold } /* Generic.Heading */
+.codehilite .gi { color: #00A000 } /* Generic.Inserted */
+.codehilite .go { color: #888888 } /* Generic.Output */
+.codehilite .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
+.codehilite .gs { font-weight: bold } /* Generic.Strong */
+.codehilite .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
+.codehilite .gt { color: #0044DD } /* Generic.Traceback */
+.codehilite .kc { color: #008000; font-weight: bold } /* Keyword.Constant */
+.codehilite .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
+.codehilite .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
+.codehilite .kp { color: #008000 } /* Keyword.Pseudo */
+.codehilite .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
+.codehilite .kt { color: #B00040 } /* Keyword.Type */
+.codehilite .m { color: #666666 } /* Literal.Number */
+.codehilite .s { color: #BA2121 } /* Literal.String */
+.codehilite .na { color: #7D9029 } /* Name.Attribute */
+.codehilite .nb { color: #008000 } /* Name.Builtin */
+.codehilite .nc { color: #0000FF; font-weight: bold } /* Name.Class */
+.codehilite .no { color: #880000 } /* Name.Constant */
+.codehilite .nd { color: #AA22FF } /* Name.Decorator */
+.codehilite .ni { color: #999999; font-weight: bold } /* Name.Entity */
+.codehilite .ne { color: #D2413A; font-weight: bold } /* Name.Exception */
+.codehilite .nf { color: #0000FF } /* Name.Function */
+.codehilite .nl { color: #A0A000 } /* Name.Label */
+.codehilite .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
+.codehilite .nt { color: #008000; font-weight: bold } /* Name.Tag */
+.codehilite .nv { color: #19177C } /* Name.Variable */
+.codehilite .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
+.codehilite .w { color: #bbbbbb } /* Text.Whitespace */
+.codehilite .mb { color: #666666 } /* Literal.Number.Bin */
+.codehilite .mf { color: #666666 } /* Literal.Number.Float */
+.codehilite .mh { color: #666666 } /* Literal.Number.Hex */
+.codehilite .mi { color: #666666 } /* Literal.Number.Integer */
+.codehilite .mo { color: #666666 } /* Literal.Number.Oct */
+.codehilite .sa { color: #BA2121 } /* Literal.String.Affix */
+.codehilite .sb { color: #BA2121 } /* Literal.String.Backtick */
+.codehilite .sc { color: #BA2121 } /* Literal.String.Char */
+.codehilite .dl { color: #BA2121 } /* Literal.String.Delimiter */
+.codehilite .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
+.codehilite .s2 { color: #BA2121 } /* Literal.String.Double */
+.codehilite .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
+.codehilite .sh { color: #BA2121 } /* Literal.String.Heredoc */
+.codehilite .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
+.codehilite .sx { color: #008000 } /* Literal.String.Other */
+.codehilite .sr { color: #BB6688 } /* Literal.String.Regex */
+.codehilite .s1 { color: #BA2121 } /* Literal.String.Single */
+.codehilite .ss { color: #19177C } /* Literal.String.Symbol */
+.codehilite .bp { color: #008000 } /* Name.Builtin.Pseudo */
+.codehilite .fm { color: #0000FF } /* Name.Function.Magic */
+.codehilite .vc { color: #19177C } /* Name.Variable.Class */
+.codehilite .vg { color: #19177C } /* Name.Variable.Global */
+.codehilite .vi { color: #19177C } /* Name.Variable.Instance */
+.codehilite .vm { color: #19177C } /* Name.Variable.Magic */
+.codehilite .il { color: #666666 } /* Literal.Number.Integer.Long */
+
+.preview_header {
+  font-size: 18px;
+  font-weight: 500;
+  text-align: center;
+  margin-bottom: -12px;
+}
+
+.bot_cover {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  min-height: 650px;
+  border: 1px solid rgb(229, 231, 235);
+  border-radius: 8px;
+  padding: 20px 40px;
+}
+
+.bot_avatar {
+  width: 100px;
+  height: 100px;
+  border-radius: 50%;
+  overflow: hidden;
+}
+
+.bot_avatar img {
+  width: 100px;
+  height: 100px;
+}
+
+.bot_name {
+  font-size: 36px;
+  margin-top: 10px;
+}
+
+.bot_desp {
+  color: #ddd;
+}
+
+.publish_link_container > a {
+  display: block;
+  border-radius: var(--button-large-radius);
+  padding: var(--button-large-padding);
+  font-weight: var(--button-large-text-weight);
+  font-size: var(--button-large-text-size);
+  border: var(--button-border-width) solid var(--button-secondary-border-color);
+  background: var(--button-secondary-background-fill);
+  color: var(--button-secondary-text-color) !important;
+  cursor: pointer;
+  text-decoration: none !important;
+  text-align: center;
+}
+
+.publish_link_container > .disabled {
+  cursor: not-allowed;
+  opacity: .5;
+  filter: grayscale(30%);
+}
+
+.markdown-body .message {
+  white-space: pre-wrap;
+}
+
+.markdown-body details {
+  white-space: nowrap;
+}
+.markdown-body .bot details:not(:last-child) {
+  margin-bottom: 1px;
+}
+.markdown-body summary {
+  background-color: #4b5563;
+  color: #eee;
+  padding: 0 4px;
+  border-radius: 4px;
+  font-size: 0.9em;
+}

assets/appBot.css

@@ -0,0 +1,129 @@
+/* code highlight: https://python-markdown.github.io/extensions/code_hilite/ */
+.codehilite .hll { background-color: #ffffcc }
+.codehilite  { background: #f8f8f8; }
+.codehilite .c { color: #408080; font-style: italic } /* Comment */
+.codehilite .err { border: 1px solid #FF0000 } /* Error */
+.codehilite .k { color: #008000; font-weight: bold } /* Keyword */
+.codehilite .o { color: #666666 } /* Operator */
+.codehilite .ch { color: #408080; font-style: italic } /* Comment.Hashbang */
+.codehilite .cm { color: #408080; font-style: italic } /* Comment.Multiline */
+.codehilite .cp { color: #BC7A00 } /* Comment.Preproc */
+.codehilite .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */
+.codehilite .c1 { color: #408080; font-style: italic } /* Comment.Single */
+.codehilite .cs { color: #408080; font-style: italic } /* Comment.Special */
+.codehilite .gd { color: #A00000 } /* Generic.Deleted */
+.codehilite .ge { font-style: italic } /* Generic.Emph */
+.codehilite .gr { color: #FF0000 } /* Generic.Error */
+.codehilite .gh { color: #000080; font-weight: bold } /* Generic.Heading */
+.codehilite .gi { color: #00A000 } /* Generic.Inserted */
+.codehilite .go { color: #888888 } /* Generic.Output */
+.codehilite .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
+.codehilite .gs { font-weight: bold } /* Generic.Strong */
+.codehilite .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
+.codehilite .gt { color: #0044DD } /* Generic.Traceback */
+.codehilite .kc { color: #008000; font-weight: bold } /* Keyword.Constant */
+.codehilite .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
+.codehilite .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
+.codehilite .kp { color: #008000 } /* Keyword.Pseudo */
+.codehilite .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
+.codehilite .kt { color: #B00040 } /* Keyword.Type */
+.codehilite .m { color: #666666 } /* Literal.Number */
+.codehilite .s { color: #BA2121 } /* Literal.String */
+.codehilite .na { color: #7D9029 } /* Name.Attribute */
+.codehilite .nb { color: #008000 } /* Name.Builtin */
+.codehilite .nc { color: #0000FF; font-weight: bold } /* Name.Class */
+.codehilite .no { color: #880000 } /* Name.Constant */
+.codehilite .nd { color: #AA22FF } /* Name.Decorator */
+.codehilite .ni { color: #999999; font-weight: bold } /* Name.Entity */
+.codehilite .ne { color: #D2413A; font-weight: bold } /* Name.Exception */
+.codehilite .nf { color: #0000FF } /* Name.Function */
+.codehilite .nl { color: #A0A000 } /* Name.Label */
+.codehilite .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
+.codehilite .nt { color: #008000; font-weight: bold } /* Name.Tag */
+.codehilite .nv { color: #19177C } /* Name.Variable */
+.codehilite .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
+.codehilite .w { color: #bbbbbb } /* Text.Whitespace */
+.codehilite .mb { color: #666666 } /* Literal.Number.Bin */
+.codehilite .mf { color: #666666 } /* Literal.Number.Float */
+.codehilite .mh { color: #666666 } /* Literal.Number.Hex */
+.codehilite .mi { color: #666666 } /* Literal.Number.Integer */
+.codehilite .mo { color: #666666 } /* Literal.Number.Oct */
+.codehilite .sa { color: #BA2121 } /* Literal.String.Affix */
+.codehilite .sb { color: #BA2121 } /* Literal.String.Backtick */
+.codehilite .sc { color: #BA2121 } /* Literal.String.Char */
+.codehilite .dl { color: #BA2121 } /* Literal.String.Delimiter */
+.codehilite .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
+.codehilite .s2 { color: #BA2121 } /* Literal.String.Double */
+.codehilite .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
+.codehilite .sh { color: #BA2121 } /* Literal.String.Heredoc */
+.codehilite .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
+.codehilite .sx { color: #008000 } /* Literal.String.Other */
+.codehilite .sr { color: #BB6688 } /* Literal.String.Regex */
+.codehilite .s1 { color: #BA2121 } /* Literal.String.Single */
+.codehilite .ss { color: #19177C } /* Literal.String.Symbol */
+.codehilite .bp { color: #008000 } /* Name.Builtin.Pseudo */
+.codehilite .fm { color: #0000FF } /* Name.Function.Magic */
+.codehilite .vc { color: #19177C } /* Name.Variable.Class */
+.codehilite .vg { color: #19177C } /* Name.Variable.Global */
+.codehilite .vi { color: #19177C } /* Name.Variable.Instance */
+.codehilite .vm { color: #19177C } /* Name.Variable.Magic */
+.codehilite .il { color: #666666 } /* Literal.Number.Integer.Long */
+
+.preview_header {
+  font-size: 24px;
+  font-weight: 500;
+  text-align: center;
+}
+
+.bot_cover {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  min-height: 300px;
+  border: 1px solid rgb(229, 231, 235);
+  padding: 20px 20px;
+}
+
+.bot_avatar {
+  width: 100px;
+  height: 100px;
+  border-radius: 50%;
+  overflow: hidden;
+}
+
+.bot_avatar img {
+  width: 100px;
+  height: 100px;
+}
+
+.bot_name {
+  font-size: 36px;
+  margin-top: 10px;
+}
+
+/* .bot_desp {
+  color: #ddd;
+} */
+
+.container {
+  /* flex-direction: row-reverse; */
+}
+
+.markdown-body .message {
+  white-space: pre-wrap;
+}
+
+.markdown-body details {
+  white-space: nowrap;
+}
+.markdown-body .bot details:not(:last-child) {
+  margin-bottom: 1px;
+}
+.markdown-body summary {
+  background-color: #4b5563;
+  color: #eee;
+  padding: 0 4px;
+  border-radius: 4px;
+  font-size: 0.9em;
+}

patching.py

@@ -0,0 +1,276 @@
+import os
+import re
+from typing import List, Union, Iterator
+from http import HTTPStatus
+from time import time
+import time
+import json
+
+
+from qwen_agent.agents import Assistant
+from qwen_agent.agents import assistant
+from qwen_agent.agents.assistant import Assistant, get_basename_from_url
+from qwen_agent.memory.memory import Memory
+from qwen_agent.llm.schema import ASSISTANT, USER, Message, SYSTEM, CONTENT
+from qwen_agent.llm.qwen_dashscope import QwenChatAtDS
+import qwen_agent.llm.base
+from qwen_agent.llm.base import ModelServiceError
+from qwen_agent.utils.utils import extract_text_from_message, print_traceback
+from qwen_agent.utils.tokenization_qwen import count_tokens, tokenizer
+from qwen_agent.utils.utils import (get_file_type, hash_sha256, is_http_url,
+                                    sanitize_chrome_file_path, save_url_to_local_work_dir)
+from qwen_agent.log import logger
+from qwen_agent.gui.gradio import gr
+from qwen_agent.tools.storage import KeyNotExistsError
+from qwen_agent.tools.simple_doc_parser import (SimpleDocParser, PARSER_SUPPORTED_FILE_TYPES, parse_pdf, 
+                                    parse_word, parse_ppt, parse_txt, parse_html_bs, parse_csv,
+                                    parse_tsv, parse_excel, get_plain_doc)
+
+
+
+
+def memory_run(self, messages: List[Message], lang: str = 'en', **kwargs) -> Iterator[List[Message]]:
+        """This agent is responsible for processing the input files in the message.
+
+         This method stores the files in the knowledge base, and retrievals the relevant parts
+         based on the query and returning them.
+         The currently supported file types include: .pdf, .docx, .pptx, .txt, .csv, .tsv, .xlsx, .xls and html.
+
+         Args:
+             messages: A list of messages.
+             lang: Language.
+
+        Yields:
+            The message of retrieved documents.
+        """
+        # process files in messages
+        rag_files = self.get_rag_files(messages)
+
+        if not rag_files:
+            yield [Message(role=ASSISTANT, content='', name='memory')]
+        else:
+            query = ''
+            # Only retrieval content according to the last user query if exists
+            if messages and messages[-1].role == USER:
+                query = extract_text_from_message(messages[-1], add_upload_info=False)
+
+            content = self.function_map['retrieval'].call(
+                {
+                    'query': query,
+                    'files': rag_files
+                },
+                **kwargs,
+            )
+            if not isinstance(content, str):
+                content = json.dumps(content, ensure_ascii=False, indent=4)
+
+            yield [Message(role=ASSISTANT, content=content, name='memory')]
+
+Memory._run = memory_run
+
+
+def SimpleDocParser_call(self, params: Union[str, dict], **kwargs) -> Union[str, list]:
+    params = self._verify_json_format_args(params)
+    path = params['url']
+    cached_name_ori = f'{hash_sha256(path)}_ori'
+    try:
+        # Directly load the parsed doc
+        parsed_file = self.db.get(cached_name_ori)
+        # [PATCH]: disable json5 for faster processing
+        # try:
+        #     parsed_file = json5.loads(parsed_file)
+        # except ValueError:
+        #     logger.warning(f'Encountered ValueError raised by json5. Fall back to json. File: {cached_name_ori}')
+        parsed_file = json.loads(parsed_file)
+        logger.info(f'Read parsed {path} from cache.')
+    except KeyNotExistsError:
+        logger.info(f'Start parsing {path}...')
+        time1 = time.time()
+
+        f_type = get_file_type(path)
+        if f_type in PARSER_SUPPORTED_FILE_TYPES:
+            if path.startswith('https://') or path.startswith('http://') or re.match(
+                    r'^[A-Za-z]:\\', path) or re.match(r'^[A-Za-z]:/', path):
+                path = path
+            else:
+                path = sanitize_chrome_file_path(path)
+
+        os.makedirs(self.data_root, exist_ok=True)
+        if is_http_url(path):
+            # download online url
+            tmp_file_root = os.path.join(self.data_root, hash_sha256(path))
+            os.makedirs(tmp_file_root, exist_ok=True)
+            path = save_url_to_local_work_dir(path, tmp_file_root)
+
+        if f_type == 'pdf':
+            parsed_file = parse_pdf(path, self.extract_image)
+        elif f_type == 'docx':
+            parsed_file = parse_word(path, self.extract_image)
+        elif f_type == 'pptx':
+            parsed_file = parse_ppt(path, self.extract_image)
+        elif f_type == 'txt':
+            parsed_file = parse_txt(path)
+        elif f_type == 'html':
+            parsed_file = parse_html_bs(path, self.extract_image)
+        elif f_type == 'csv':
+            parsed_file = parse_csv(path, self.extract_image)
+        elif f_type == 'tsv':
+            parsed_file = parse_tsv(path, self.extract_image)
+        elif f_type in ['xlsx', 'xls']:
+            parsed_file = parse_excel(path, self.extract_image)
+        else:
+            raise ValueError(
+                f'Failed: The current parser does not support this file type! Supported types: {"/".join(PARSER_SUPPORTED_FILE_TYPES)}'
+            )
+        for page in parsed_file:
+            for para in page['content']:
+                # Todo: More attribute types
+                para['token'] = count_tokens(para.get('text', para.get('table')))
+        time2 = time.time()
+        logger.info(f'Finished parsing {path}. Time spent: {time2 - time1} seconds.')
+        # Cache the parsing doc
+        self.db.put(cached_name_ori, json.dumps(parsed_file, ensure_ascii=False, indent=2))
+
+    if not self.structured_doc:
+        return get_plain_doc(parsed_file)
+    else:
+        return parsed_file
+
+SimpleDocParser.call = SimpleDocParser_call
+
+
+def _truncate_input_messages_roughly(messages: List[Message], max_tokens: int) -> List[Message]:
+    sys_msg = messages[0]
+    assert sys_msg.role == SYSTEM  # The default system is prepended if none exists
+    if len([m for m in messages if m.role == SYSTEM]) >= 2:
+        raise gr.Error(
+            'The input messages must contain no more than one system message. '
+            ' And the system message, if exists, must be the first message.',
+        )
+
+    turns = []
+    for m in messages[1:]:
+        if m.role == USER:
+            turns.append([m])
+        else:
+            if turns:
+                turns[-1].append(m)
+            else:
+                raise gr.Error(
+                    'The input messages (excluding the system message) must start with a user message.',
+                )
+
+    def _count_tokens(msg: Message) -> int:
+        return tokenizer.count_tokens(extract_text_from_message(msg, add_upload_info=True))
+
+    token_cnt = _count_tokens(sys_msg)
+    truncated = []
+    for i, turn in enumerate(reversed(turns)):
+        cur_turn_msgs = []
+        cur_token_cnt = 0
+        for m in reversed(turn):
+            cur_turn_msgs.append(m)
+            cur_token_cnt += _count_tokens(m)
+        # Check "i == 0" so that at least one user message is included
+        # [PATCH] Do not do truncate for this demo
+        # if (i == 0) or (token_cnt + cur_token_cnt <= max_tokens):
+        truncated.extend(cur_turn_msgs)
+        token_cnt += cur_token_cnt
+        # else:
+        #     break
+    # Always include the system message
+    truncated.append(sys_msg)
+    truncated.reverse()
+
+    if len(truncated) < 2:  # one system message + one or more user messages
+        raise gr.Error(
+            code='400',
+            message='At least one user message should be provided.',
+        )
+    if token_cnt > max_tokens:
+        raise gr.Error(
+            f'The input messages (around {token_cnt} tokens) exceed the maximum context length ({max_tokens} tokens).'
+        )
+    return truncated
+
+qwen_agent.llm.base._truncate_input_messages_roughly = _truncate_input_messages_roughly
+
+
+
+def format_knowledge_to_source_and_content(result: Union[str, List[dict]]) -> List[dict]:
+    knowledge = []
+    if isinstance(result, str):
+        result = f'{result}'.strip()
+        try:
+            # [PATCH]: disable json5 for faster processing
+            docs = json.loads(result)
+        except Exception:
+            print_traceback()
+            knowledge.append({'source': '上传的文档', 'content': result})
+            return knowledge
+    else:
+        docs = result
+    try:
+        _tmp_knowledge = []
+        assert isinstance(docs, list)
+        for doc in docs:
+            url, snippets = doc['url'], doc['text']
+            assert isinstance(snippets, list)
+            _tmp_knowledge.append({
+                'source': f'[文件]({get_basename_from_url(url)})',
+                'content': '\n\n...\n\n'.join(snippets)
+            })
+        knowledge.extend(_tmp_knowledge)
+    except Exception:
+        print_traceback()
+        knowledge.append({'source': '上传的文档', 'content': result})
+    return knowledge
+
+assistant.format_knowledge_to_source_and_content = format_knowledge_to_source_and_content
+
+
+HINT_PATTERN = "\n<summary>input tokens: {input_tokens}, prefill time: [[<PrefillCost>]]s, output tokens: {output_tokens}, decode speed: [[<DecodeSpeed>]] tokens/s</summary>"
+
+@staticmethod
+def _full_stream_output(response):
+    for chunk in response:
+        if chunk.status_code == HTTPStatus.OK:
+            # [PATCH]: add speed statistics
+            yield [Message(ASSISTANT, chunk.output.choices[0].message.content + HINT_PATTERN.format(
+                    input_tokens=chunk.usage.input_tokens,
+                    output_tokens=chunk.usage.output_tokens,)
+            )]
+        else:
+            raise ModelServiceError(code=chunk.code, message=chunk.message)
+
+QwenChatAtDS._full_stream_output = _full_stream_output
+
+def assistant_run(self,
+        messages,
+        lang="en",
+        knowledge="",
+        **kwargs):
+    
+    if any([len(message[CONTENT]) > 1 for message in messages]):
+        yield [Message(ASSISTANT, "Uploading and Parsing Files...")]
+    new_messages = self._prepend_knowledge_prompt(messages=messages, lang=lang, knowledge=knowledge, **kwargs)
+    start_prefill_time = time.time()
+    
+    yield [Message(ASSISTANT, "Qwen-Turbo is thinking...")]
+
+    start_decode_time = None
+    for chunk in super(Assistant, self)._run(messages=new_messages, lang=lang, **kwargs):
+    
+        if start_decode_time is None:
+            end_prefill_time = time.time()
+            start_decode_time = time.time() - 0.5
+
+        # [PATCH]: compute speed statstics
+        pattern = re.search(HINT_PATTERN.format(input_tokens="\d+", output_tokens="(\d+)").replace("[", "\[").replace("]", "\]"), chunk[0][CONTENT])
+        if pattern:
+            output_tokens = int(pattern.group(1))
+            chunk[0][CONTENT] = chunk[0][CONTENT].replace("[[<PrefillCost>]]", "%.2f" % (end_prefill_time - start_prefill_time)).replace("[[<DecodeSpeed>]]", "%.2f" % (output_tokens/(time.time() - start_decode_time)))
+
+        yield chunk
+
+Assistant._run = assistant_run

requirements.txt

@@ -0,0 +1,3 @@
+qwen-agent==0.0.10
+qwen-agent[gui]
+qwen-agent[rag]

web_ui.py

@@ -0,0 +1,366 @@
+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 CONTENT, FILE, IMAGE, NAME, ROLE, USER, 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 import gr, mgr
+
+        customTheme = gr.themes.Default(
+            primary_hue=gr.themes.utils.colors.blue,
+            radius_size=gr.themes.utils.sizes.radius_none,
+        )
+
+        with gr.Blocks(
+                css=os.path.join(os.path.dirname(__file__), 'assets/appBot.css'),
+                theme=customTheme,
+        ) as demo:
+            history = gr.State([])
+
+            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=650,
+                                          avatar_image_width=80,
+                                          flushing=False,
+                                          show_copy_button=False,
+                                          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,)
+
+                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_promise = input.submit(
+                    fn=self.add_text,
+                    inputs=[input, chatbot, history],
+                    outputs=[input, chatbot, history],
+                    queue=False,
+                )
+
+                if len(self.agent_list) > 1 and 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],
+                        [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 add_text(self, _input, _chatbot, _history):
+        from qwen_agent.gui.gradio import gr
+        if _input.text == "/clear":
+            _chatbot = []
+            _history.clear()
+            yield gr.update(interactive=False, value=""), _chatbot, _history
+            return
+
+        _history.append({
+            ROLE: USER,
+            CONTENT: [{
+                'text': _input.text
+            }],
+        })
+
+        if self.user_config[NAME]:
+            _history[-1][NAME] = self.user_config[NAME]
+
+        if _input.files:
+            for file in _input.files:
+                if file.mime_type.startswith('image/'):
+                    _history[-1][CONTENT].append({IMAGE: 'file://' + file.path})
+                else:
+                    _history[-1][CONTENT].append({FILE: file.path})
+
+        _chatbot.append([_input, None])
+
+        yield gr.update(interactive=False, value=None), _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):
+        if not _history:
+            if _agent_selector is not None:
+                yield _chatbot, _history, _agent_selector
+            else:
+                yield _chatbot, _history
+            return
+
+
+        if self.verbose:
+            logger.info('agent_run input:\n' + pprint.pformat(_history, indent=2))
+
+        num_input_bubbles = len(_chatbot) - 1
+        num_output_bubbles = 1
+        _chatbot[-1][1] = [None for _ in range(len(self.agent_list))]
+
+        agent_runner = self.agent_list[_agent_selector or 0]
+        if self.agent_hub:
+            agent_runner = self.agent_hub
+        responses = []
+        for responses in agent_runner.run(_history, **self.run_kwargs):
+            # usage = responses.usage
+            # responses = [Message(ASSISTANT, responses.output.choices[0].message.content)]
+
+            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)
+            # display_responses[-1][CONTENT] += "\n<summary>" + repr({"usage": usage}) + "</summary>"
+            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:
+            for res in responses:
+                res['content'] = re.sub(r"\n<summary>input tokens.*</summary>", "", res['content'])
+            _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):
+        from qwen_agent.gui.gradio import gr
+
+        return gr.update(interactive=True)
+
+    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 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 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,
+            )