| |
| """ |
| Agent template module for handling tool calling and function execution. |
| |
| This module provides base classes and utilities for creating agent templates |
| that support tool calling in conversational AI systems. It includes support |
| for various agent formats like ReAct, function calling, and parallel execution. |
| """ |
| import ast |
| import json |
| from abc import ABC, abstractmethod |
| from dataclasses import asdict, dataclass |
| from typing import Any, Dict, List, Literal, Optional, Tuple, Union |
|
|
| from swift.infer_engine import Function |
| from swift.template import Prompt, split_str_parts_by |
|
|
|
|
| @dataclass |
| class AgentKeyword: |
| action: str = 'Action:' |
| action_input: str = 'Action Input:' |
| observation: str = 'Observation:' |
|
|
|
|
| @dataclass |
| class ToolDesc: |
| name_for_model: str |
| name_for_human: str |
| description_for_model: str |
| parameters: str |
| args_format: str |
|
|
|
|
| class ReactCompatMixin: |
| """ |
| Mixin class providing ReAct-style agent compatibility. |
| |
| This mixin handles parsing and formatting of tool calls in the ReAct format, |
| where actions and inputs are marked with specific keywords in the text. |
| """ |
| keyword = AgentKeyword() |
|
|
| @staticmethod |
| def _split_action_action_input(response: str, keyword: AgentKeyword) -> List[Function]: |
| agent_parts = split_str_parts_by(response, list(asdict(keyword).values())) |
| functions = [] |
| action_content = None |
|
|
| for part in agent_parts: |
| key, content = part['key'].lower(), part['content'] |
| if action_content is None and key == keyword.action.lower(): |
| action_content = content |
| elif action_content is not None and key == keyword.action_input.lower(): |
| functions.append(Function(name=action_content, arguments=content)) |
| action_content = None |
|
|
| return functions |
|
|
| def get_toolcall(self, response: str) -> List[Function]: |
| """ |
| Extract tool calls from an agent response. |
| |
| Args: |
| response: The agent's response text. |
| |
| Returns: |
| List of Function objects representing tool calls. |
| """ |
| functions = self._split_action_action_input(response, self.keyword) |
| if len(functions) == 0 and self.keyword != ReactCompatMixin.keyword: |
| |
| functions = self._split_action_action_input(response, ReactCompatMixin.keyword) |
| return functions |
|
|
| def _format_tool_responses( |
| self, |
| assistant_content: str, |
| tool_messages, |
| ) -> Tuple[str, 'Prompt']: |
| """ |
| Format tool execution results into the conversation. |
| |
| Args: |
| assistant_content: The assistant's message containing tool calls. |
| tool_messages: List of tool execution result messages. |
| |
| Returns: |
| Tuple of (formatted assistant content, formatted tool responses). |
| """ |
| assert len(tool_messages) > 0 |
| with_action = self.keyword.action in assistant_content and self.keyword.action_input in assistant_content |
| if with_action: |
| if not assistant_content.endswith(self.keyword.observation): |
| if not assistant_content.endswith('\n'): |
| assistant_content += '\n' |
| assistant_content += self.keyword.observation |
| res = [] |
| for i, tool_message in enumerate(tool_messages): |
| if i > 0: |
| res.append(self.keyword.observation) |
| tool_content = tool_message['content'] |
| res.append(tool_content) |
| if not tool_content.endswith('\n'): |
| res.append('\n') |
| else: |
| res = [] |
| for tool_message in tool_messages: |
| res.append(tool_message['content']) |
| return assistant_content, res |
|
|
| @staticmethod |
| def _parse_tool_call(content) -> Dict[str, Any]: |
| obj = BaseAgentTemplate._parse_json(content) |
| name = obj['name'] |
| arguments = obj.get('arguments') |
| if arguments is None: |
| arguments = obj.get('parameters') |
| arguments = BaseAgentTemplate._parse_json(arguments) |
| assert arguments is not None, f'content: {content}' |
| return {'name': name, 'arguments': arguments} |
|
|
| def _format_tool_calls(self, tool_call_messages) -> str: |
| """ |
| Format tool call messages into ReAct format. |
| |
| Args: |
| tool_call_messages: List of messages containing tool call information. |
| |
| Returns: |
| Formatted string with Action, Action Input, and Observation markers. |
| """ |
| |
| tool_calls = [] |
| for message in tool_call_messages: |
| tool_call = self._parse_tool_call(message['content']) |
| tool_calls.append(f'{self.keyword.action} {tool_call["name"]}\n' |
| f'{self.keyword.action_input} {tool_call["arguments"]}\n') |
| tool_calls.append(self.keyword.observation) |
| return ''.join(tool_calls) |
|
|
|
|
| class BaseAgentTemplate(ReactCompatMixin, ABC): |
| """ |
| Abstract base class for agent templates. |
| |
| This class provides common functionality for parsing and formatting tools, |
| as well as handling tool calls in different formats. Subclasses must |
| implement the following methods to define their specific behavior: |
| - `_format_tools`: Format tool definitions for the prompt |
| - `_format_tool_calls`: Format tool call messages |
| - `_format_tool_responses`: Format tool execution results |
| - `get_toolcall`: Extract tool calls from agent responses |
| """ |
|
|
| @staticmethod |
| def _get_tool_name(tool): |
| return tool.get('name_for_model') or tool.get('name') |
|
|
| @staticmethod |
| def unwrap_tool(tool): |
| assert isinstance(tool, dict), f'tool: {tool}' |
| if 'type' in tool and 'function' in tool: |
| tool = tool['function'] |
| return tool |
|
|
| @staticmethod |
| def wrap_tool(tool): |
| assert isinstance(tool, dict), f'tool: {tool}' |
| if 'type' not in tool and 'function' not in tool: |
| tool = {'type': 'function', 'function': tool} |
| return tool |
|
|
| @staticmethod |
| def _parse_tool(tool, lang: Literal['zh', 'en']) -> ToolDesc: |
| tool = BaseAgentTemplate.unwrap_tool(tool) |
| name_for_model = BaseAgentTemplate._get_tool_name(tool) |
| name_for_human = tool.get('name_for_human') or name_for_model |
|
|
| description = tool.get('description') |
| if description is None: |
| description = tool.get('description_for_model') |
| parameters = tool.get('parameters') or {} |
| parameters = parameters if isinstance(parameters, str) else json.dumps(parameters, ensure_ascii=False) |
| args_format = '此工具的输入应为JSON对象。' if lang == 'zh' else 'Format the arguments as a JSON object.' |
| tool_desc = ToolDesc( |
| name_for_model=name_for_model, |
| name_for_human=name_for_human, |
| description_for_model=description, |
| parameters=parameters, |
| args_format=args_format) |
| assert name_for_model is not None and description is not None, f'tool_desc: {tool_desc}' |
| return tool_desc |
|
|
| @staticmethod |
| def _parse_json(json_str: str) -> Optional[Any]: |
| """ |
| Parse a JSON string with fallback to ast.literal_eval. |
| |
| Args: |
| json_str: String to parse, or already parsed object. |
| |
| Returns: |
| Parsed object, or None if parsing fails. |
| """ |
| if not isinstance(json_str, str): |
| return json_str |
| try: |
| res = json.loads(json_str) |
| except json.JSONDecodeError: |
| try: |
| res = ast.literal_eval(json_str) |
| except Exception: |
| return |
| return res |
|
|
| @abstractmethod |
| def _format_tools(self, |
| tools: List[Union[str, dict]], |
| system: Optional[str] = None, |
| user_message: Optional[dict] = None) -> str: |
| """ |
| Format tools for inclusion in the agent prompt. |
| |
| Args: |
| tools: List of tool definitions (strings or dictionaries). |
| system: System prompt text. |
| user_message: Optional user message to incorporate. |
| |
| Returns: |
| Formatted string to include in the prompt. |
| """ |
| pass |
|
|
