refactor

api/core/agent/base_agent_runner.py

@@ -325,7 +325,7 @@ class BaseAgentRunner(AppRunner):
                            tool_name: str,
                            tool_input: Union[str, dict],
                            thought: str, 
-                           observation: Union[str, str], 
+                           observation: Union[str, dict], 
                            tool_invoke_meta: Union[str, dict],
                            answer: str,
                            messages_ids: list[str],

api/core/agent/cot_agent_runner.py

@@ -1,5 +1,6 @@
 import json
 import re
+from abc import abstractmethod
 from collections.abc import Generator
 from typing import Literal, Union
 
@@ -12,12 +13,10 @@ from core.model_runtime.entities.message_entities import (
     AssistantPromptMessage,
     PromptMessage,
     PromptMessageTool,
-    SystemPromptMessage,
     ToolPromptMessage,
-    UserPromptMessage,
 )
-from core.model_runtime.utils.encoders import jsonable_encoder
 from core.tools.entities.tool_entities import ToolInvokeMeta
+from core.tools.tool.tool import Tool
 from core.tools.tool_engine import ToolEngine
 from models.model import Message
 
@@ -25,6 +24,7 @@ from models.model import Message
 class CotAgentRunner(BaseAgentRunner):
     _is_first_iteration = True
     _ignore_observation_providers = ['wenxin']
+    _historic_prompt_messages: list[PromptMessage] = []
 
     def run(self, message: Message,
         query: str,
@@ -132,6 +132,7 @@ class CotAgentRunner(BaseAgentRunner):
 
             # recalc llm max tokens
             self.recalc_llm_max_tokens(self.model_config, prompt_messages)
+
             # invoke model
             chunks: Generator[LLMResultChunk, None, None] = model_instance.invoke_llm(
                 prompt_messages=prompt_messages,
@@ -164,30 +165,12 @@ class CotAgentRunner(BaseAgentRunner):
                 ), PublishFrom.APPLICATION_MANAGER)
 
             for chunk in react_chunks:
-                if isinstance(chunk, dict):
-                    scratchpad.agent_response += json.dumps(chunk)
-                    try:
-                        if scratchpad.action:
-                            raise Exception("")
-                        scratchpad.action_str = json.dumps(chunk)
-                        scratchpad.action = AgentScratchpadUnit.Action(
-                            action_name=chunk['action'],
-                            action_input=chunk['action_input']
-                        )
-                    except:
-                        scratchpad.thought += json.dumps(chunk)
-                        yield LLMResultChunk(
-                            model=self.model_config.model,
-                            prompt_messages=prompt_messages,
-                            system_fingerprint='',
-                            delta=LLMResultChunkDelta(
-                                index=0,
-                                message=AssistantPromptMessage(
-                                    content=json.dumps(chunk, ensure_ascii=False) # if ensure_ascii=True, the text in webui maybe garbled text
-                                ),
-                                usage=None
-                            )
-                        )
+                if isinstance(chunk, AgentScratchpadUnit.Action):
+                    action = chunk
+                    # detect action
+                    scratchpad.agent_response += json.dumps(chunk.dict())
+                    scratchpad.action_str = json.dumps(chunk.dict())
+                    scratchpad.action = action
                 else:
                     scratchpad.agent_response += chunk
                     scratchpad.thought += chunk
@@ -206,26 +189,28 @@ class CotAgentRunner(BaseAgentRunner):
 
             scratchpad.thought = scratchpad.thought.strip() or 'I am thinking about how to help you'
             agent_scratchpad.append(scratchpad)
-                        
+            
             # get llm usage
             if 'usage' in usage_dict:
                 increase_usage(llm_usage, usage_dict['usage'])
             else:
                 usage_dict['usage'] = LLMUsage.empty_usage()
             
-            self.save_agent_thought(agent_thought=agent_thought,
-                                    tool_name=scratchpad.action.action_name if scratchpad.action else '',
-                                    tool_input={
-                                        scratchpad.action.action_name: scratchpad.action.action_input
-                                    } if scratchpad.action else '',
-                                    tool_invoke_meta={},
-                                    thought=scratchpad.thought,
-                                    observation='',
-                                    answer=scratchpad.agent_response,
-                                    messages_ids=[],
-                                    llm_usage=usage_dict['usage'])
+            self.save_agent_thought(
+                agent_thought=agent_thought,
+                tool_name=scratchpad.action.action_name if scratchpad.action else '',
+                tool_input={
+                    scratchpad.action.action_name: scratchpad.action.action_input
+                } if scratchpad.action else {},
+                tool_invoke_meta={},
+                thought=scratchpad.thought,
+                observation={},
+                answer=scratchpad.agent_response,
+                messages_ids=[],
+                llm_usage=usage_dict['usage']
+            )
             
-            if scratchpad.action and scratchpad.action.action_name.lower() != "final answer":
+            if not scratchpad.is_final():
                 self.queue_manager.publish(QueueAgentThoughtEvent(
                     agent_thought_id=agent_thought.id
                 ), PublishFrom.APPLICATION_MANAGER)
@@ -237,103 +222,34 @@ class CotAgentRunner(BaseAgentRunner):
                 if scratchpad.action.action_name.lower() == "final answer":
                     # action is final answer, return final answer directly
                     try:
-                        final_answer = scratchpad.action.action_input if \
-                            isinstance(scratchpad.action.action_input, str) else \
-                                json.dumps(scratchpad.action.action_input)
+                        final_answer = json.dumps(scratchpad.action.action_input)
                     except json.JSONDecodeError:
                         final_answer = f'{scratchpad.action.action_input}'
                 else:
                     function_call_state = True
-
                     # action is tool call, invoke tool
-                    tool_call_name = scratchpad.action.action_name
-                    tool_call_args = scratchpad.action.action_input
-                    tool_instance = tool_instances.get(tool_call_name)
-                    if not tool_instance:
-                        answer = f"there is not a tool named {tool_call_name}"
-                        self.save_agent_thought(
-                            agent_thought=agent_thought, 
-                            tool_name='',
-                            tool_input='',
-                            tool_invoke_meta=ToolInvokeMeta.error_instance(
-                                f"there is not a tool named {tool_call_name}"
-                            ).to_dict(),
-                            thought=None, 
-                            observation={
-                                tool_call_name: answer
-                            }, 
-                            answer=answer,
-                            messages_ids=[]
-                        )
-                        self.queue_manager.publish(QueueAgentThoughtEvent(
-                            agent_thought_id=agent_thought.id
-                        ), PublishFrom.APPLICATION_MANAGER)
-                    else:
-                        if isinstance(tool_call_args, str):
-                            try:
-                                tool_call_args = json.loads(tool_call_args)
-                            except json.JSONDecodeError:
-                                pass
+                    tool_invoke_response, tool_invoke_meta = self._handle_invoke_action(
+                        action=scratchpad.action, 
+                        tool_instances=tool_instances
+                    )
+                    scratchpad.observation = tool_invoke_response
+                    scratchpad.agent_response = tool_invoke_response
 
-                        # invoke tool
-                        tool_invoke_response, message_files, tool_invoke_meta = ToolEngine.agent_invoke(
-                            tool=tool_instance,
-                            tool_parameters=tool_call_args,
-                            user_id=self.user_id,
-                            tenant_id=self.tenant_id,
-                            message=self.message,
-                            invoke_from=self.application_generate_entity.invoke_from,
-                            agent_tool_callback=self.agent_callback
-                        )
-                        # publish files
-                        for message_file, save_as in message_files:
-                            if save_as:
-                                self.variables_pool.set_file(tool_name=tool_call_name, value=message_file.id, name=save_as)
+                    self.save_agent_thought(
+                        agent_thought=agent_thought,
+                        tool_name=scratchpad.action.action_name,
+                        tool_input={scratchpad.action.action_name: scratchpad.action.action_input},
+                        thought=scratchpad.thought,
+                        observation={scratchpad.action.action_name: tool_invoke_response},
+                        tool_invoke_meta=tool_invoke_meta.to_dict(),
+                        answer=scratchpad.agent_response,
+                        messages_ids=message_file_ids,
+                        llm_usage=usage_dict['usage']
+                    )
 
-                            # publish message file
-                            self.queue_manager.publish(QueueMessageFileEvent(
-                                message_file_id=message_file.id
-                            ), PublishFrom.APPLICATION_MANAGER)
-                            # add message file ids
-                            message_file_ids.append(message_file.id)
-
-                        # publish files
-                        for message_file, save_as in message_files:
-                            if save_as:
-                                self.variables_pool.set_file(tool_name=tool_call_name,
-                                                                value=message_file.id,
-                                                                name=save_as)
-                            self.queue_manager.publish(QueueMessageFileEvent(
-                                message_file_id=message_file.id
-                            ), PublishFrom.APPLICATION_MANAGER)
-
-                        message_file_ids = [message_file.id for message_file, _ in message_files]
-
-                        observation = tool_invoke_response
-
-                        # save scratchpad
-                        scratchpad.observation = observation
-
-                        # save agent thought
-                        self.save_agent_thought(
-                            agent_thought=agent_thought, 
-                            tool_name=tool_call_name,
-                            tool_input={
-                                tool_call_name: tool_call_args
-                            },
-                            tool_invoke_meta={
-                                tool_call_name: tool_invoke_meta.to_dict()
-                            },
-                            thought=None,
-                            observation={
-                                tool_call_name: observation
-                            }, 
-                            answer=scratchpad.agent_response,
-                            messages_ids=message_file_ids,
-                        )
-                        self.queue_manager.publish(QueueAgentThoughtEvent(
-                            agent_thought_id=agent_thought.id
-                        ), PublishFrom.APPLICATION_MANAGER)
+                    self.queue_manager.publish(QueueAgentThoughtEvent(
+                        agent_thought_id=agent_thought.id
+                    ), PublishFrom.APPLICATION_MANAGER)
 
                 # update prompt tool message
                 for prompt_tool in prompt_messages_tools:
@@ -378,11 +294,78 @@ class CotAgentRunner(BaseAgentRunner):
             system_fingerprint=''
         )), PublishFrom.APPLICATION_MANAGER)
 
-    def _handle_stream_react(self, llm_response: Generator[LLMResultChunk, None, None], usage: dict) \
-        -> Generator[Union[str, dict], None, None]:
-        def parse_json(json_str):
+    def _handle_invoke_action(self, action: AgentScratchpadUnit.Action, 
+                              tool_instances: dict[str, Tool]) -> tuple[str, ToolInvokeMeta]:
+        """
+        handle invoke action
+        :param action: action
+        :param tool_instances: tool instances
+        :return: observation, meta
+        """
+        # action is tool call, invoke tool
+        tool_call_name = action.action_name
+        tool_call_args = action.action_input
+        tool_instance = tool_instances.get(tool_call_name)
+
+        if not tool_instance:
+            answer = f"there is not a tool named {tool_call_name}"
+            return answer, ToolInvokeMeta.error_instance(answer)
+        
+        if isinstance(tool_call_args, str):
             try:
-                return json.loads(json_str.strip())
+                tool_call_args = json.loads(tool_call_args)
+            except json.JSONDecodeError:
+                pass
+
+        # invoke tool
+        tool_invoke_response, message_files, tool_invoke_meta = ToolEngine.agent_invoke(
+            tool=tool_instance,
+            tool_parameters=tool_call_args,
+            user_id=self.user_id,
+            tenant_id=self.tenant_id,
+            message=self.message,
+            invoke_from=self.application_generate_entity.invoke_from,
+            agent_tool_callback=self.agent_callback
+        )
+
+        # publish files
+        for message_file, save_as in message_files:
+            if save_as:
+                self.variables_pool.set_file(tool_name=tool_call_name, value=message_file.id, name=save_as)
+
+            # publish message file
+            self.queue_manager.publish(QueueMessageFileEvent(
+                message_file_id=message_file.id
+            ), PublishFrom.APPLICATION_MANAGER)
+            # add message file ids
+            message_file_ids.append(message_file.id)
+
+        # publish files
+        for message_file, save_as in message_files:
+            if save_as:
+                self.variables_pool.set_file(
+                    tool_name=tool_call_name,
+                    value=message_file.id,
+                    name=save_as
+                )
+            self.queue_manager.publish(QueueMessageFileEvent(
+                message_file_id=message_file.id
+            ), PublishFrom.APPLICATION_MANAGER)
+
+        message_file_ids = [message_file.id for message_file, _ in message_files]
+
+        return tool_invoke_response, tool_invoke_meta
+
+    def _handle_stream_react(self, llm_response: Generator[LLMResultChunk, None, None], usage: dict) \
+        -> Generator[Union[str, AgentScratchpadUnit.Action], None, None]:
+        def parse_action(json_str):
+            try:
+                action = json.loads(json_str)
+                if 'action' in action and 'action_input' in action:
+                    return AgentScratchpadUnit.Action(
+                        action_name=action['action'],
+                        action_input=action['action_input'],
+                    )
             except:
                 return json_str
             
@@ -392,7 +375,7 @@ class CotAgentRunner(BaseAgentRunner):
                 return
             for block in code_blocks:
                 json_text = re.sub(r'^[a-zA-Z]+\n', '', block.strip(), flags=re.MULTILINE)
-                yield parse_json(json_text)
+                yield parse_action(json_text)
             
         code_block_cache = ''
         code_block_delimiter_count = 0
@@ -453,7 +436,7 @@ class CotAgentRunner(BaseAgentRunner):
 
                     if got_json:
                         got_json = False
-                        yield parse_json(json_cache)
+                        yield parse_action(json_cache)
                         json_cache = ''
                         json_quote_count = 0
                         in_json = False
@@ -467,7 +450,16 @@ class CotAgentRunner(BaseAgentRunner):
             yield code_block_cache
 
         if json_cache:
-            yield parse_json(json_cache)
+            yield parse_action(json_cache)
+
+    def _convert_dict_to_action(self, action: dict) -> AgentScratchpadUnit.Action:
+        """
+        convert dict to action
+        """
+        return AgentScratchpadUnit.Action(
+            action_name=action['action'],
+            action_input=action['action_input']
+        )
 
     def _fill_in_inputs_from_external_data_tools(self, instruction: str, inputs: dict) -> str:
         """
@@ -513,177 +505,42 @@ class CotAgentRunner(BaseAgentRunner):
                     current_scratchpad.observation = message.content
         
         return agent_scratchpad
-
-    def _check_cot_prompt_messages(self, mode: Literal["completion", "chat"], 
-                                      agent_prompt_message: AgentPromptEntity,
-    ):
-        """
-            check chain of thought prompt messages, a standard prompt message is like:
-                Respond to the human as helpfully and accurately as possible. 
-
-                {{instruction}}
-
-                You have access to the following tools:
-
-                {{tools}}
-
-                Use a json blob to specify a tool by providing an action key (tool name) and an action_input key (tool input).
-                Valid action values: "Final Answer" or {{tool_names}}
-
-                Provide only ONE action per $JSON_BLOB, as shown:
-
-                ```
-                {
-                "action": $TOOL_NAME,
-                "action_input": $ACTION_INPUT
-                }
-                ```
-        """
-
-        # parse agent prompt message
-        first_prompt = agent_prompt_message.first_prompt
-        next_iteration = agent_prompt_message.next_iteration
-
-        if not isinstance(first_prompt, str) or not isinstance(next_iteration, str):
-            raise ValueError("first_prompt or next_iteration is required in CoT agent mode")
-        
-        # check instruction, tools, and tool_names slots
-        if not first_prompt.find("{{instruction}}") >= 0:
-            raise ValueError("{{instruction}} is required in first_prompt")
-        if not first_prompt.find("{{tools}}") >= 0:
-            raise ValueError("{{tools}} is required in first_prompt")
-        if not first_prompt.find("{{tool_names}}") >= 0:
-            raise ValueError("{{tool_names}} is required in first_prompt")
-        
-        if mode == "completion":
-            if not first_prompt.find("{{query}}") >= 0:
-                raise ValueError("{{query}} is required in first_prompt")
-            if not first_prompt.find("{{agent_scratchpad}}") >= 0:
-                raise ValueError("{{agent_scratchpad}} is required in first_prompt")
-        
-        if mode == "completion":
-            if not next_iteration.find("{{observation}}") >= 0:
-                raise ValueError("{{observation}} is required in next_iteration")
-            
-    def _convert_scratchpad_list_to_str(self, agent_scratchpad: list[AgentScratchpadUnit]) -> str:
-        """
-            convert agent scratchpad list to str
-        """
-        next_iteration = self.app_config.agent.prompt.next_iteration
-
-        result = ''
-        for scratchpad in agent_scratchpad:
-            result += (scratchpad.thought or '') + (scratchpad.action_str or '') + \
-                next_iteration.replace("{{observation}}", scratchpad.observation or 'It seems that no response is available')
-
-        return result
     
-    def _organize_cot_prompt_messages(self, mode: Literal["completion", "chat"],
+    @abstractmethod
+    def _format_instructions(self, instruction: str, tools: list[PromptMessageTool],
+                                prompt_template: AgentPromptEntity
+        ) -> str:
+        pass
+    
+    @abstractmethod
+    def _format_scratchpads(self, scratchpad: list[AgentScratchpadUnit],
+        ) -> str:
+        """
+            format scratchpads
+        """
+        pass
+    
+    @abstractmethod
+    def _organize_historic_prompt_messages(self, mode: Literal["completion", "chat"],
+                                           prompt_messages: list[PromptMessage],
+                                           tools: list[PromptMessageTool],
+                                           agent_prompt_message: AgentPromptEntity,
+                                           instruction: str,
+        ) -> list[PromptMessage]:
+        """
+            organize historic prompt messages
+        """
+        pass
+
+    @abstractmethod
+    def _organize_current_prompt_messages(self, mode: Literal["completion", "chat"],
                                       prompt_messages: list[PromptMessage],
                                       tools: list[PromptMessageTool], 
-                                      agent_scratchpad: list[AgentScratchpadUnit],
                                       agent_prompt_message: AgentPromptEntity,
                                       instruction: str,
                                       input: str,
         ) -> list[PromptMessage]:
         """
-            organize chain of thought prompt messages, a standard prompt message is like:
-                Respond to the human as helpfully and accurately as possible. 
-
-                {{instruction}}
-
-                You have access to the following tools:
-
-                {{tools}}
-
-                Use a json blob to specify a tool by providing an action key (tool name) and an action_input key (tool input).
-                Valid action values: "Final Answer" or {{tool_names}}
-
-                Provide only ONE action per $JSON_BLOB, as shown:
-
-                ```
-                {{{{
-                "action": $TOOL_NAME,
-                "action_input": $ACTION_INPUT
-                }}}}
-                ```
+            organize current prompt messages
         """
-
-        self._check_cot_prompt_messages(mode, agent_prompt_message)
-
-        # parse agent prompt message
-        first_prompt = agent_prompt_message.first_prompt
-
-        # parse tools
-        tools_str = self._jsonify_tool_prompt_messages(tools)
-
-        # parse tools name
-        tool_names = '"' + '","'.join([tool.name for tool in tools]) + '"'
-
-        # get system message
-        system_message = first_prompt.replace("{{instruction}}", instruction) \
-                                     .replace("{{tools}}", tools_str) \
-                                     .replace("{{tool_names}}", tool_names)
-
-        # organize prompt messages
-        if mode == "chat":
-            # override system message
-            overridden = False
-            prompt_messages = prompt_messages.copy()
-            for prompt_message in prompt_messages:
-                if isinstance(prompt_message, SystemPromptMessage):
-                    prompt_message.content = system_message
-                    overridden = True
-                    break
-            
-            # convert tool prompt messages to user prompt messages
-            for idx, prompt_message in enumerate(prompt_messages):
-                if isinstance(prompt_message, ToolPromptMessage):
-                    prompt_messages[idx] = UserPromptMessage(
-                        content=prompt_message.content
-                    )
-
-            if not overridden:
-                prompt_messages.insert(0, SystemPromptMessage(
-                    content=system_message,
-                ))
-
-            # add assistant message
-            if len(agent_scratchpad) > 0 and not self._is_first_iteration:
-                prompt_messages.append(AssistantPromptMessage(
-                    content=(agent_scratchpad[-1].thought or '') + (agent_scratchpad[-1].action_str or ''),
-                ))
-            
-            # add user message
-            if len(agent_scratchpad) > 0 and not self._is_first_iteration:
-                prompt_messages.append(UserPromptMessage(
-                    content=(agent_scratchpad[-1].observation or 'It seems that no response is available'),
-                ))
-
-            self._is_first_iteration = False
-
-            return prompt_messages
-        elif mode == "completion":
-            # parse agent scratchpad
-            agent_scratchpad_str = self._convert_scratchpad_list_to_str(agent_scratchpad)
-            self._is_first_iteration = False
-            # parse prompt messages
-            return [UserPromptMessage(
-                content=first_prompt.replace("{{instruction}}", instruction)
-                                    .replace("{{tools}}", tools_str)
-                                    .replace("{{tool_names}}", tool_names)
-                                    .replace("{{query}}", input)
-                                    .replace("{{agent_scratchpad}}", agent_scratchpad_str),
-            )]
-        else:
-            raise ValueError(f"mode {mode} is not supported")
-            
-    def _jsonify_tool_prompt_messages(self, tools: list[PromptMessageTool]) -> str:
-        """
-            jsonify tool prompt messages
-        """
-        tools = jsonable_encoder(tools)
-        try:
-            return json.dumps(tools, ensure_ascii=False)
-        except json.JSONDecodeError:
-            return json.dumps(tools)
+        pass

api/core/agent/cot_chat_agent_runner.py

@@ -0,0 +1,65 @@
+import json
+from typing import Literal
+
+from core.agent.cot_agent_runner import CotAgentRunner
+from core.agent.entities import AgentPromptEntity, AgentScratchpadUnit
+from core.model_runtime.entities.message_entities import PromptMessage, PromptMessageTool
+
+
+class CotChatAgentRunner(CotAgentRunner):
+    def _format_instructions(self, instruction: str, tools: list[PromptMessageTool],
+                                prompt_template: AgentPromptEntity
+        ) -> str:
+        """
+        format instructions
+        """
+        result = prompt_template.first_prompt
+
+        # format tools
+        result = result.replace('{{tools}}', json.dumps(tools))
+
+        result = result.replace('{{tool_names}}', ', '.join([tool.name for tool in tools]))
+
+        # format instruction
+        result = result.replace('{{instruction}}', instruction)
+
+        return result
+
+    def _format_scratchpads(self, scratchpad: list[AgentScratchpadUnit]) -> str:
+        """
+            format scratchpads
+        """
+        result = ""
+
+        for unit in scratchpad:
+            if unit.is_final():
+                result += f"Final Answer: {unit.agent_response}"
+            else:
+                result += f"Thought: {unit.thought}\n\n"
+                if unit.action_str:
+                    result += f"Action: {unit.action_str}\n\n"
+                if unit.observation:
+                    result += f"Observation: {unit.observation}\n\n"
+
+        return result
+    
+    def _organize_historic_prompt_messages(self, mode: Literal["completion", "chat"],
+                                           prompt_messages: list[PromptMessage],
+                                           tools: list[PromptMessageTool],
+                                           agent_prompt_message: AgentPromptEntity,
+                                           instruction: str,
+        ) -> list[PromptMessage]:
+        """
+            organize historic prompt messages
+        """
+
+    def _organize_current_prompt_messages(self, mode: Literal["completion", "chat"],
+                                      prompt_messages: list[PromptMessage],
+                                      tools: list[PromptMessageTool], 
+                                      agent_prompt_message: AgentPromptEntity,
+                                      instruction: str,
+                                      input: str,
+        ) -> list[PromptMessage]:
+        """
+            organize current prompt messages
+        """

api/core/agent/cot_completion_agent_runner.py

@@ -0,0 +1,68 @@
+import json
+from typing import Literal
+
+from core.agent.cot_agent_runner import CotAgentRunner
+from core.agent.entities import AgentPromptEntity, AgentScratchpadUnit
+from core.model_runtime.entities.message_entities import PromptMessage, PromptMessageTool
+
+
+class CotCompletionAgentRunner(CotAgentRunner):
+    def _format_instructions(self, instruction: str, tools: list[PromptMessageTool],
+                                prompt_template: AgentPromptEntity
+        ) -> str:
+        """
+        format instructions
+        """
+        result = prompt_template.first_prompt
+
+        # format tools
+        result = result.replace('{{tools}}', json.dumps(tools))
+
+        result = result.replace('{{tool_names}}', ', '.join([tool.name for tool in tools]))
+
+        # format instruction
+        result = result.replace('{{instruction}}', instruction)
+
+        return result
+
+    def _format_scratchpads(self, scratchpad: list[AgentScratchpadUnit],
+        ) -> str:
+        """
+            format scratchpads
+        """
+        result = ""
+
+        for unit in scratchpad:
+            if unit.is_final():
+                result += f"Final Answer: {unit.agent_response}"
+            else:
+                result += f"Thought: {unit.thought}\n\n"
+                if unit.action_str:
+                    result += f"Action: {unit.action_str}\n\n"
+                if unit.observation:
+                    result += f"Observation: {unit.observation}\n\n"
+
+        return result
+    
+    def _organize_historic_prompt_messages(self, mode: Literal["completion", "chat"],
+                                           prompt_messages: list[PromptMessage],
+                                           tools: list[PromptMessageTool],
+                                           agent_prompt_message: AgentPromptEntity,
+                                           instruction: str,
+        ) -> list[PromptMessage]:
+        """
+            organize historic prompt messages
+        """
+        result = []
+
+
+    def _organize_current_prompt_messages(self, mode: Literal["completion", "chat"],
+                                      prompt_messages: list[PromptMessage],
+                                      tools: list[PromptMessageTool], 
+                                      agent_prompt_message: AgentPromptEntity,
+                                      instruction: str,
+                                      input: str,
+        ) -> list[PromptMessage]:
+        """
+            organize current prompt messages
+        """

api/core/agent/entities.py

@@ -40,6 +40,14 @@ class AgentScratchpadUnit(BaseModel):
     observation: Optional[str] = None
     action: Optional[Action] = None
 
+    def is_final(self) -> bool:
+        """
+        Check if the scratchpad unit is final.
+        """
+        return self.action is None or (
+            'final' in self.action.action_name.lower() and 
+            'answer' in self.action.action_name.lower()
+        )
 
 class AgentEntity(BaseModel):
     """