wip

Author: tastelikefeet

modelscope_agent/callbacks/base.py

@@ -11,20 +11,20 @@ class Callback:
     def __init__(self, config: DictConfig):
         self.config = config
 
-    def on_task_begin(self, run_status: RunStatus, messages: List[Message]):
+    async def on_task_begin(self, run_status: RunStatus, messages: List[Message]):
         pass
 
-    def on_generate_response(self, run_status: RunStatus, messages: List[Message]):
+    async def on_generate_response(self, run_status: RunStatus, messages: List[Message]):
         pass
 
-    def after_generate_response(self, run_status: RunStatus, messages: List[Message]):
+    async def after_generate_response(self, run_status: RunStatus, messages: List[Message]):
         pass
 
-    def on_tool_call(self, run_status: RunStatus, messages: List[Message]):
+    async def on_tool_call(self, run_status: RunStatus, messages: List[Message]):
         pass
 
-    def after_tool_call(self, run_status: RunStatus, messages: List[Message]):
+    async def after_tool_call(self, run_status: RunStatus, messages: List[Message]):
         pass
 
-    def on_task_end(self, run_status: RunStatus, messages: List[Message]):
+    async def on_task_end(self, run_status: RunStatus, messages: List[Message]):
         pass

modelscope_agent/cli/code/artifact_callback.py

@@ -15,35 +15,38 @@ def __init__(self, config: DictConfig):
         super().__init__(config)
         self.file_system = FileSystemTool(config)
 
+    async def on_task_begin(self, run_status: RunStatus, messages: List[Message]):
+        await self.file_system.connect()
+
     @staticmethod
     def extract_metadata(config: DictConfig, llm: LLM, messages: List[Message]):
         assert messages[0].role == 'system' and  messages[1].role == 'user'
-        _system = """Here gives a LLM system field, and a user query field, you need to extract the code file information of it, and wraps the final result in <result></result>.
+        _system = """You are a file name parser, I will give a user query field to you, you need to extract the code file name from it, and wraps the final result in <result></result>.
+Always remember your task is not generating the code, but parse the file name from the query.
 Here shows an example:
-system is: You are a code engineer, you should help me to write a code file, which is a part of a complex job. The rules you need to follow are: ...
 query is: You should write the index.js file, the file you need to use is main.css and nav.js, the interface in the code is ...
 
 Your answer should be: <result>index.js</result>   
 """
-        _query = (f'The input system is: {messages[0].content}\n\n'
-                  f'The input query is: {messages[1].content}\n\n'
-                  'Now give the code file name:\n')
+        _query = (f'The input query is: {messages[1].content}\n\n'
+                  'Now give the code file name and wraps with <result></result>:\n')
         _messages = [
             Message(role='system', content=_system),
             Message(role='user', content=_query)
         ]
         if getattr(config.generation_config, 'stream', False):
             message = None
-            for msg in llm.generate(messages):
+            for msg in llm.generate(_messages):
                 message = llm.merge_stream_message(message, msg)
 
             _response_message = message
         else:
-            _response_message = llm.generate(messages)
-        assert '<result>' in _response_message[-1].content and '</result>' in _response_message[-1].content
-        return re.findall(r'<result>(.*?)</result>', _response_message[-1].content)[0]
+            _response_message = llm.generate(_messages)
+        if not ('<result>' in _response_message.content and '</result>' in _response_message.content):
+            raise AssertionError(f'Could not extract information from {_response_message.content}')
+        return re.findall(r'<result>(.*?)</result>', _response_message.content)[0]
 
-    def after_generate_response(self, run_status: RunStatus, messages: List[Message]):
+    async def after_generate_response(self, run_status: RunStatus, messages: List[Message]):
         last_message_content = messages[-1].content
         if '</code>' in last_message_content:
             code = ''
@@ -63,8 +66,11 @@ def after_generate_response(self, run_status: RunStatus, messages: List[Message]
                         code += message.content
             if code:
                 code_file = self.extract_metadata(self.config, run_status.llm, messages)
-                self.file_system.create_directory('./output')
-                self.file_system.write_file(code_file, code)
+                try:
+                    # await self.file_system.create_directory('output')
+                    await self.file_system.write_file(code_file, code)
+                except Exception as e:
+                    print(e)
                 messages.append(Message(role='assistant', content=f'Original query: {messages[1].content}'
                                                                   f'Task sunning successfully, '
                                                                   f'the code has been saved in the {code_file} file.'))

modelscope_agent/cli/code/coding.yaml

@@ -1,6 +1,6 @@
 llm:
   service: openai
-  model: claude-3-7-sonnet-20250219
+  model: qwen-plus-latest
   openai_api_key:
   openai_base_url: https://dashscope.aliyuncs.com/compatible-mode/v1
 
@@ -10,13 +10,12 @@ generation_config:
   top_k: 50
   stream: false
   extra_body:
-    enable_thinking: false
     dashscope_extend_params:
       provider: idealab
 
 prompt:
   system: |
-    You are a senior software architect. Your responsibility is to break down original requirements into implementable modules and assign tasks for each module into subtasks. The initiation of subtasks requires calling the `split_complex_task` tool, which can start all sub tasks as you need at one time. In this process, you need to answer the following questions:
+    You are a senior software architect. Your responsibility is to break down original requirements into implementable modules and assign tasks for each module into subtasks. The initiation of subtasks requires calling the `split_to_sub_task` tool, which can start all sub tasks as you need at one time. In this process, you need to answer the following questions:
 
     1. What is the original requirement? Does it involve frontend or backend code? What programming language is needed?
     2. How many modules should it be split into? What are the interfaces for each module?
@@ -33,6 +32,7 @@ prompt:
     3. The site will display specific categories, each category can showcase different product showcases
     4. Products can be clicked to purchase or favorite, so I need to design a complete favorites functionality
     5. Due to the complexity of the code engineering, I cannot complete this complex goal in a single file, so I need to split the tasks, which task should in charge of one single code file.
+    6. I should give a very detail design of the page functions and file locations, in case the sub tasks work abnormally
     ...
     
     The subtasks I need to split are:
@@ -51,11 +51,11 @@ prompt:
     You should **DO A TOOL CALLING** with multi sub tasks information, here shows example of tool args:
     [
       {
-        "system": "You are a software engineer which helps me to finish a part of my job. You need to follow these instructions: 1. ... 2. ...",
+        "system": "You are a software engineer which helps me to finish a part of my job. You need to follow these instructions: 1. You should generate code by yourself, do not call `split_to_sub_task` anymore.\n 2. Do not give fake image addresses 3. You should keep the page as beautiful as you can 4. DO not add ``` around the code, wrap the code with <code></code>  5. Detail function and interface requirements here... 6. ...",
         "query": "The original query is to write an e-commerce website with Christmas atmosphere your part of job is the index.html page, the interface design should be: 1. ... 2. ..."
       },
       {
-        "system": "You are a software engineer which helps me to finish a part of my job. You need to follow these instructions: 1. ... 2. ...",
+        "system": "You are a software engineer which helps me to finish a part of my job. You need to follow these instructions: 1. You should generate code by yourself, do not call `split_to_sub_task` anymore.\n 2. Do not give fake image addresses 4. DO not add ``` around the code, wrap the code with <code></code>  5. Detail function and interface requirements here... 6. ...",
         "query": "The original query is to write an e-commerce website with Christmas atmosphere your part of job is the index.js code file, the interface design should be: 1. ... 2. ..."
       },
     ...

modelscope_agent/engine/simple_engine.py

@@ -1,5 +1,6 @@
 import importlib
 import inspect
+import json
 import sys
 from typing import List, Optional, Dict
 
@@ -94,9 +95,9 @@ def _register_callback_from_config(self):
                 else:
                     self.callbacks.append(callbacks_mapping[_callback]())
 
-    def _loop_callback(self, point, messages: List[Message]):
+    async def _loop_callback(self, point, messages: List[Message]):
         for callback in self.callbacks:
-            getattr(callback, point)(self.run_status, messages)
+            await getattr(callback, point)(self.run_status, messages)
 
     async def _parallel_tool_call(self, messages: List[Message]):
         tool_call_result = await self.tool_manager.parallel_call_tool(messages[-1].tool_calls)
@@ -106,7 +107,6 @@ async def _parallel_tool_call(self, messages: List[Message]):
                 role='tool',
                 content=tool_call_result,
                 tool_call_id=tool_call_query['id'],
-                name=tool_call_query['tool_name']
             )
             messages.append(_new_message)
             logger.info(_new_message.content)
@@ -172,7 +172,8 @@ def handle_stream_message(self):
 
     def log_output(self, content: str, tag='Default workflow'):
         for line in content.split('\n'):
-            logger.info(f'[{tag}] {line}')
+            for _line in line.split('\\n'):
+                logger.info(f'[{tag}] {_line}')
 
     async def run(self, prompt, **kwargs):
         try:
@@ -182,11 +183,11 @@ async def run(self, prompt, **kwargs):
             self._prepare_rag()
             tag = kwargs.get('tag', 'Default workflow')
             messages = self._prepare_messages(prompt)
-            self._loop_callback('on_task_begin', messages)
+            await self._loop_callback('on_task_begin', messages)
             if self.planer:
                 self.planer.generate_plan(messages, self.run_status)
             while not self.run_status.should_stop:
-                self._loop_callback('on_generate_response', messages)
+                await self._loop_callback('on_generate_response', messages)
                 messages = self._refine_memory(messages)
                 messages = self._update_plan(messages)
                 tools = await self.tool_manager.get_tools()
@@ -199,15 +200,15 @@ async def run(self, prompt, **kwargs):
                     self.log_output(_response_message.content, tag=tag)
                 if _response_message.tool_calls:
                     for tool_call in _response_message.tool_calls:
-                        self.log_output(str(tool_call), tag=tag)
-                self._loop_callback('after_generate_response', messages)
-                self._loop_callback('on_tool_call', messages)
+                        self.log_output(json.dumps(tool_call), tag=tag)
+                await self._loop_callback('after_generate_response', messages)
+                await self._loop_callback('on_tool_call', messages)
                 if messages[-1].tool_calls:
                     await self._parallel_tool_call(messages)
                 else:
                     self.run_status.should_stop = True
-                self._loop_callback('after_tool_call', messages)
-            self._loop_callback('on_task_end', messages)
+                await self._loop_callback('after_tool_call', messages)
+            await self._loop_callback('on_task_end', messages)
             await self._cleanup_tools()
             return messages
         except Exception as e:

modelscope_agent/llm/claude.py

@@ -1,29 +1,28 @@
 import inspect
-from typing import Any
+from typing import Any, List
 
-from modelscope_agent.utils.llm_utils import retry
+from omegaconf import DictConfig
 
+from modelscope_agent.llm.openai_llm import OpenAI
+from modelscope_agent.llm.utils import Tool
+from modelscope_agent.utils.llm_utils import retry
 
-class Claude:
 
-    def __init__(self, system):
-        self.system = system
-        self.client = OpenAI(
-            api_key=self.token,
-            base_url=self.base_url,
-        )
+class Claude(OpenAI):
 
-    @retry(max_attempts=5)
-    def generate(self, messages, model, tools=None, **kwargs) -> Any:
-        _e = None
-        parameters = inspect.signature(self.client.chat.completions.create).parameters
-        kwargs = {key: value for key, value in kwargs.items() if key in parameters}
-        completion = self.client.chat.completions.create(
-            model=model,
-            messages=messages,
-            tools=tools,
-            parallel_tool_calls=False,
-            **kwargs
-        )
-        return completion
+    def __init__(self, config: DictConfig):
+        super().__init__(config, base_url=config.llm.claude_base_url, api_key=config.llm.claude_api_key)
 
+    def format_tools(self, tools: List[Tool]):
+        if tools:
+            tools = [
+                {
+                    'name': f'{tool.get("server_name")}---{tool["tool_name"]}' if tool.get('server_name') else tool[
+                        'tool_name'],
+                    'description': tool['description'],
+                    'input_schema': tool['parameters']
+                } for tool in tools
+            ]
+        else:
+            tools = None
+        return tools

modelscope_agent/llm/openai_llm.py

@@ -27,15 +27,7 @@ def __init__(self, config: DictConfig, base_url: Optional[str] = None,  api_key:
         )
         self.args: Dict = OmegaConf.to_container(getattr(config, 'generation_config', {}))
 
-    @retry(max_attempts=3)
-    def generate(self, messages: List[Message], tools: List[Tool] = None, **kwargs) -> Message | Generator[Message, None, None]:
-        parameters = inspect.signature(self.client.chat.completions.create).parameters
-        args = self.args.copy()
-        args.update(kwargs)
-        stream = args.get('stream', False)
-
-        args = {key: value for key, value in args.items() if key in parameters}
-
+    def format_tools(self, tools: List[Tool]):
         if tools:
             tools = [
                 {
@@ -49,7 +41,17 @@ def generate(self, messages: List[Message], tools: List[Tool] = None, **kwargs)
             ]
         else:
             tools = None
-        completion = self._call_llm(messages, tools, **args)
+        return tools
+
+    @retry(max_attempts=3)
+    def generate(self, messages: List[Message], tools: List[Tool] = None, **kwargs) -> Message | Generator[Message, None, None]:
+        parameters = inspect.signature(self.client.chat.completions.create).parameters
+        args = self.args.copy()
+        args.update(kwargs)
+        stream = args.get('stream', False)
+
+        args = {key: value for key, value in args.items() if key in parameters}
+        completion = self._call_llm(messages, self.format_tools(tools), **args)
 
         # 考虑到复杂任务可能存在 单次调用llm生成不完整的情况。需要调用continue_gen判断是否应多次调用以获得完整输出
         if stream:
@@ -125,16 +127,19 @@ def stream_format_output_message(self, completion_chunk) -> Message:
 
     def format_output_message(self, completion) -> Message:
         content = completion.choices[0].message.content or ''
-        reasoning_content = completion.choices[0].message.reasoning_content or ''
+        if hasattr(completion.choices[0].message, 'reasoning_content'):
+            reasoning_content = completion.choices[0].message.reasoning_content or ''
+        else:
+            reasoning_content = ''
         tool_calls = None
         if completion.choices[0].message.tool_calls:
             tool_calls = [ToolCall(
                     id=tool_call.id,
-                    index=tool_call.index,
+                    index=getattr(tool_call, 'index', idx),
                     type=tool_call.type,
                     arguments=tool_call.function.arguments,
                     tool_name=tool_call.function.name
-                ) for tool_call in completion.choices[0].message.tool_calls
+                ) for idx, tool_call in enumerate(completion.choices[0].message.tool_calls)
             ]
         return Message(role='assistant', content=content, reasoning_content=reasoning_content, tool_calls=tool_calls, id=completion.id)
 

modelscope_agent/tools/filesystem.yaml

@@ -4,4 +4,4 @@ tools:
     args:
       - "-y"
       - "@modelcontextprotocol/server-filesystem"
-      - "./output"
+      - "."

modelscope_agent/tools/filesystem_tool.py

@@ -25,10 +25,10 @@ async def call_tool(self, server_name: str, *, tool_name: str, tool_args: dict):
         return await self.mcp_client.call_tool(server_name, tool_name, tool_args)
 
     async def create_directory(self, path: str):
-        return await self.call_tool(tool_name='create_directory', tool_args={'path': path})
+        return await self.call_tool('filesystem', tool_name='create_directory', tool_args={'path': path})
 
     async def write_file(self, path: str, content: str):
-        return await self.call_tool(tool_name='write_file', tool_args={'path': path, 'content': content})
+        return await self.call_tool('filesystem', tool_name='write_file', tool_args={'path': path, 'content': content})
 
     async def read_file(self, path: str):
-        return await self.call_tool(tool_name='read_file', tool_args={'path': path})
+        return await self.call_tool('filesystem', tool_name='read_file', tool_args={'path': path})

modelscope_agent/tools/mcp_client.py

@@ -66,7 +66,7 @@ async def get_tools(self) -> Dict:
     @staticmethod
     def print_tools(server_name: str, tools: ListToolsResult):
         tools = tools.tools
-        sep = "\n"
+        sep = ","
         if len(tools) > 10:
             tools = [tool.name for tool in tools][:10]
             logger.info(f'\nConnected to server "{server_name}" '

modelscope_agent/tools/split_task.py

@@ -26,9 +26,19 @@ async def get_tools(self):
                                'you plan the framework, include code files and classes and functions, and give the detail '
                                'information to the system and query field of the subtask, then '
                                'let each subtask to write a single file',
-                parameters={
-                    'tasks': 'List type, each element is a dict, which contains two fields: system and query to start the sub task.',
-                }
+                parameters= {
+                        "type": "object",
+                        "properties": {
+                            "tasks": {
+                                "type": "array",
+                                "description": "Each element is a dict, which contains two fields: system and query to start the sub task."
+                            }
+                        },
+                        "required": [
+                            "tasks"
+                        ],
+                        "additionalProperties": False
+                    }
         )]
         }
 
@@ -43,12 +53,12 @@ async def call_tool(self, server_name: str, *, tool_name: str, tool_args: dict):
             config = DictConfig(self.config)
             config.prompt.system = system
             config.prompt.query = query
-            # config.tools = DictConfig({})
+            delattr(config.tools, 'split_task')
             trust_remote_code = getattr(config, 'trust_remote_code', False)
             engine = SimpleEngine(config=config, trust_remote_code=trust_remote_code)
             sub_tasks.append(engine.run(query, tag=f'workflow {i}'))
         result = await asyncio.gather(*sub_tasks)
         res = []
         for messages in result:
             res.append(messages[-1].content)
-        return result
+        return res