Upload folder using huggingface_hub

docs/function_call_guide.md

@@ -1,12 +1,12 @@
-# MiniMax-M2 函数调用（Function Call）功能指南
+# MiniMax-M2 Function Call Guide
 
-## 简介
+## Introduction
 
-MiniMax-M2 模型支持函数调用功能，使模型能够识别何时需要调用外部函数，并以结构化格式输出函数调用参数。本文档详细介绍了如何使用 MiniMax-M2 的函数调用功能。
+The MiniMax-M2 model supports function calling capabilities, enabling the model to identify when external functions need to be called and output function call parameters in a structured format. This document provides detailed instructions on how to use the function calling features of MiniMax-M2.
 
-## 基础示例
+## Basic Example
 
-以下 Python 脚本基于 OpenAI SDK 实现了一个天气查询函数的调用示例：
+The following Python script implements a weather query function call example based on the OpenAI SDK:
 
 ```python
 from openai import OpenAI
@@ -50,20 +50,20 @@ print(f"Arguments: {tool_call.arguments}")
 print(f"Result: {get_weather(**json.loads(tool_call.arguments))}")
 ```
 
-**输出示例：**
+**Output Example:**
 ```
 Function called: get_weather
 Arguments: {"location": "San Francisco, CA", "unit": "celsius"}
 Result: Getting the weather for San Francisco, CA in celsius...
 ```
 
-## 手动解析模型输出
+## Manually Parsing Model Output
 
-如果您无法使用已支持 MiniMax-M2 的推理引擎的内置解析器，或者需要使用其他推理框架（如 transformers、TGI 等），可以使用以下方法手动解析模型的原始输出。这种方法需要您自己解析模型输出的 XML 标签格式。
+If you cannot use the built-in parser of inference engines that support MiniMax-M2, or need to use other inference frameworks (such as transformers, TGI, etc.), you can manually parse the model's raw output using the following method. This approach requires you to parse the XML tag format of the model output yourself.
 
-### 使用 Transformers 的示例
+### Example Using Transformers
 
-以下是使用 transformers 库的完整示例：
+Here is a complete example using the transformers library:
 
 ```python
 from transformers import AutoTokenizer
@@ -87,7 +87,7 @@ def get_default_tools():
         }
     ]
 
-# 加载模型和分词器
+# Load model and tokenizer
 tokenizer = AutoTokenizer.from_pretrained(model_id)
 prompt = "What's the weather like in Shanghai today?"
 messages = [
@@ -95,10 +95,10 @@ messages = [
     {"role": "user", "content": prompt},
 ]
 
-# 启用函数调用工具
+# Enable function calling tools
 tools = get_default_tools()
 
-# 应用聊天模板，并加入工具定义
+# Apply chat template and include tool definitions
 text = tokenizer.apply_chat_template(
     messages,
     tokenize=False,
@@ -106,7 +106,7 @@ text = tokenizer.apply_chat_template(
     tools=tools
 )
 
-# 发送请求（这里使用任何推理服务）
+# Send request (using any inference service)
 import requests
 payload = {
     "model": "MiniMaxAI/MiniMax-M2",
@@ -120,35 +120,35 @@ response = requests.post(
     stream=False,
 )
 
-# 模型输出需要手动解析
+# Model output needs manual parsing
 raw_output = response.json()["choices"][0]["text"]
-print("原始输出:", raw_output)
+print("Raw output:", raw_output)
 
-# 使用下面的解析函数处理输出
+# Use the parsing function below to process the output
 function_calls = parse_tool_calls(raw_output, tools)
 ```
 
-## 🛠️ 函数调用的定义
+## 🛠️ Function Call Definition
 
-### 函数结构体
+### Function Structure
 
-函数调用需要在请求体中定义 `tools` 字段，每个函数由以下部分组成：
+Function calls need to define the `tools` field in the request body. Each function consists of the following parts:
 
 ```json
 {
   "tools": [
     {
       "name": "search_web",
-      "description": "搜索函数。",
+      "description": "Search function.",
       "parameters": {
         "properties": {
           "query_list": {
-            "description": "进行搜索的关键词，列表元素个数为1。",
+            "description": "Keywords for search, list should contain 1 element.",
             "items": { "type": "string" },
             "type": "array"
           },
           "query_tag": {
-            "description": "query的分类",
+            "description": "Category of query",
             "items": { "type": "string" },
             "type": "array"
           }
@@ -161,17 +161,17 @@ function_calls = parse_tool_calls(raw_output, tools)
 }
 ```
 
-**字段说明：**
-- `name`: 函数名称
-- `description`: 函数功能描述
-- `parameters`: 函数参数定义
-  - `properties`: 参数属性定义，key 是参数名，value 包含参数的详细描述
-  - `required`: 必填参数列表
-  - `type`: 参数类型（通常为 "object"）
+**Field Descriptions:**
+- `name`: Function name
+- `description`: Function description
+- `parameters`: Function parameter definition
+  - `properties`: Parameter property definition, where key is the parameter name and value contains detailed parameter description
+  - `required`: List of required parameters
+  - `type`: Parameter type (usually "object")
 
-### 模型内部处理格式
+### Internal Processing Format
 
-在 MiniMax-M2 模型内部处理时，函数定义会被转换为特殊格式并拼接到输入文本中。以下是一个完整的示例：
+When processing within the MiniMax-M2 model, function definitions are converted to a special format and concatenated to the input text. Here is a complete example:
 
 ```
 ]~!b[]~b]system
@@ -182,7 +182,7 @@ You may call one or more tools to assist with the user query.
 Here are the tools available in JSONSchema format:
 
 <tools>
-<tool>{"name": "search_web", "description": "搜索函数。", "parameters": {"type": "object", "properties": {"query_list": {"type": "array", "items": {"type": "string"}, "description": "进行搜索的关键词，列表元素个数为1。"}, "query_tag": {"type": "array", "items": {"type": "string"}, "description": "query的分类"}}, "required": ["query_list", "query_tag"]}}</tool>
+<tool>{"name": "search_web", "description": "Search function.", "parameters": {"type": "object", "properties": {"query_list": {"type": "array", "items": {"type": "string"}, "description": "Keywords for search, list should contain 1 element."}, "query_tag": {"type": "array", "items": {"type": "string"}, "description": "Category of query"}}, "required": ["query_list", "query_tag"]}}</tool>
 </tools>
 
 When making tool calls, use XML format to invoke tools and pass parameters:
@@ -195,25 +195,25 @@ When making tool calls, use XML format to invoke tools and pass parameters:
 </invoke>
 [e~[
 ]~b]user
-OpenAI 和 Gemini 的最近一次发布会都是什么时候?[e~[
+When were the latest announcements from OpenAI and Gemini?[e~[
 ]~b]ai
 <think>
 ```
 
-**格式说明：**
+**Format Description:**
 
-- `]~!b[]~b]system`: System 消息开始标记
-- `[e~[`: 消息结束标记
-- `]~b]user`: User 消息开始标记
-- `]~b]ai`: Assistant 消息开始标记
-- `]~b]tool`: Tool 结果消息开始标记
-- `<tools>...</tools>`: 工具定义区域，每个工具用 `<tool>` 标签包裹，内容为 JSON Schema
-- `<minimax:tool_call>...</minimax:tool_call>`: 工具调用区域
-- `<think>`: 生成时的思考过程标记（可选）
+- `]~!b[]~b]system`: System message start marker
+- `[e~[`: Message end marker
+- `]~b]user`: User message start marker
+- `]~b]ai`: Assistant message start marker
+- `]~b]tool`: Tool result message start marker
+- `<tools>...</tools>`: Tool definition area, each tool is wrapped with `<tool>` tag, content is JSON Schema
+- `<minimax:tool_call>...</minimax:tool_call>`: Tool call area
+- `<think>`: Thinking process marker during generation (optional)
 
-### 模型输出格式
+### Model Output Format
 
-MiniMax-M2使用结构化的 XML 标签格式：
+MiniMax-M2 uses structured XML tag format:
 
 ```xml
 <minimax:tool_call>
@@ -228,13 +228,13 @@ MiniMax-M2使用结构化的 XML 标签格式：
 </minimax:tool_call>
 ```
 
-每个函数调用使用 `<invoke name="函数名">` 标签，参数使用 `<parameter name="参数名">` 标签包裹。
+Each function call uses the `<invoke name="function_name">` tag, and parameters use the `<parameter name="parameter_name">` tag wrapper.
 
-## 手动解析函数调用结果
+## Manually Parsing Function Call Results
 
-### 解析函数调用
+### Parsing Function Calls
 
-MiniMax-M2使用结构化的 XML 标签，需要不同的解析方式。核心函数如下：
+MiniMax-M2 uses structured XML tags, which require a different parsing approach. The core function is as follows:
 
 ```python
 import re
@@ -243,7 +243,7 @@ from typing import Any, Optional, List, Dict
 
 
 def extract_name(name_str: str) -> str:
-    """从引号包裹的字符串中提取名称"""
+    """Extract name from quoted string"""
     name_str = name_str.strip()
     if name_str.startswith('"') and name_str.endswith('"'):
         return name_str[1:-1]
@@ -253,7 +253,7 @@ def extract_name(name_str: str) -> str:
 
 
 def convert_param_value(value: str, param_type: str) -> Any:
-    """根据参数类型转换参数值"""
+    """Convert parameter value based on parameter type"""
     if value.lower() == "null":
         return None
         
@@ -280,7 +280,7 @@ def convert_param_value(value: str, param_type: str) -> Any:
         except json.JSONDecodeError:
             return value
     else:
-        # 尝试 JSON 解析，失败则返回字符串
+        # Try JSON parsing, return string if failed
         try:
             return json.loads(value)
         except json.JSONDecodeError:
@@ -289,16 +289,16 @@ def convert_param_value(value: str, param_type: str) -> Any:
 
 def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> List[Dict]:
     """
-    从模型输出中提取所有工具调用
+    Extract all tool calls from model output
     
     Args:
-        model_output: 模型的完整输出文本
-        tools: 工具定义列表，用于获取参数类型信息，格式可以是：
+        model_output: Complete output text from the model
+        tools: Tool definition list for getting parameter type information, format can be:
                - [{"name": "...", "parameters": {...}}]
                - [{"type": "function", "function": {"name": "...", "parameters": {...}}}]
     
     Returns:
-        解析后的工具调用列表，每个元素包含 name 和 arguments 字段
+        Parsed tool call list, each element contains name and arguments fields
     
     Example:
         >>> tools = [{
@@ -321,30 +321,30 @@ def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> L
         >>> print(result)
         [{'name': 'get_weather', 'arguments': {'location': 'San Francisco', 'unit': 'celsius'}}]
     """
-    # 快速检查是否包含工具调用标记
+    # Quick check if tool call marker is present
     if "<minimax:tool_call>" not in model_output:
         return []
     
     tool_calls = []
     
     try:
-        # 匹配所有 <minimax:tool_call> 块
+        # Match all <minimax:tool_call> blocks
         tool_call_regex = re.compile(r"<minimax:tool_call>(.*?)</minimax:tool_call>", re.DOTALL)
         invoke_regex = re.compile(r"<invoke name=(.*?)</invoke>", re.DOTALL)
         parameter_regex = re.compile(r"<parameter name=(.*?)</parameter>", re.DOTALL)
         
-        # 遍历所有 tool_call 块
+        # Iterate through all tool_call blocks
         for tool_call_match in tool_call_regex.findall(model_output):
-            # 遍历该块中的所有 invoke
+            # Iterate through all invokes in this block
             for invoke_match in invoke_regex.findall(tool_call_match):
-                # 提取函数名
+                # Extract function name
                 name_match = re.search(r'^([^>]+)', invoke_match)
                 if not name_match:
                     continue
                 
                 function_name = extract_name(name_match.group(1))
                 
-                # 获取参数配置
+                # Get parameter configuration
                 param_config = {}
                 if tools:
                     for tool in tools:
@@ -355,7 +355,7 @@ def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> L
                                 param_config = params["properties"]
                             break
                 
-                # 提取参数
+                # Extract parameters
                 param_dict = {}
                 for match in parameter_regex.findall(invoke_match):
                     param_match = re.search(r'^([^>]+)>(.*)', match, re.DOTALL)
@@ -363,13 +363,13 @@ def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> L
                         param_name = extract_name(param_match.group(1))
                         param_value = param_match.group(2).strip()
                         
-                        # 去除首尾的换行符
+                        # Remove leading and trailing newlines
                         if param_value.startswith('\n'):
                             param_value = param_value[1:]
                         if param_value.endswith('\n'):
                             param_value = param_value[:-1]
                         
-                        # 获取参数类型并转换
+                        # Get parameter type and convert
                         param_type = "string"
                         if param_name in param_config:
                             if isinstance(param_config[param_name], dict) and "type" in param_config[param_name]:
@@ -383,16 +383,16 @@ def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> L
                 })
     
     except Exception as e:
-        print(f"解析工具调用失败: {e}")
+        print(f"Failed to parse tool calls: {e}")
         return []
     
     return tool_calls
 ```
 
-**使用示例：**
+**Usage Example:**
 
 ```python
-# 定义工具
+# Define tools
 tools = [
     {
         "name": "get_weather",
@@ -407,8 +407,8 @@ tools = [
     }
 ]
 
-# 模型输出
-model_output = """我来帮你查询天气。
+# Model output
+model_output = """Let me help you query the weather.
 <minimax:tool_call>
 <invoke name="get_weather">
 <parameter name="location">San Francisco</parameter>
@@ -416,28 +416,28 @@ model_output = """我来帮你查询天气。
 </invoke>
 </minimax:tool_call>"""
 
-# 解析工具调用
+# Parse tool calls
 tool_calls = parse_tool_calls(model_output, tools)
 
-# 输出结果
+# Output results
 for call in tool_calls:
-    print(f"调用函数: {call['name']}")
-    print(f"参数: {call['arguments']}")
-    # 输出: 调用函数: get_weather
-    #      参数: {'location': 'San Francisco', 'unit': 'celsius'}
+    print(f"Function called: {call['name']}")
+    print(f"Arguments: {call['arguments']}")
+    # Output: Function called: get_weather
+    #         Arguments: {'location': 'San Francisco', 'unit': 'celsius'}
 ```
 
-### 执行函数调用
+### Executing Function Calls
 
-解析完成后，您可以执行对应的函数并构建返回结果：
+After parsing is complete, you can execute the corresponding function and construct the return result:
 
 ```python
 def execute_function_call(function_name: str, arguments: dict):
-    """执行函数调用并返回结果"""
+    """Execute function call and return result"""
     if function_name == "get_weather":
-        location = arguments.get("location", "未知位置")
+        location = arguments.get("location", "Unknown location")
         unit = arguments.get("unit", "celsius")
-        # 构建函数执行结果
+        # Build function execution result
         return {
             "role": "tool", 
             "content": [
@@ -448,7 +448,7 @@ def execute_function_call(function_name: str, arguments: dict):
                     "location": location, 
                     "temperature": "25", 
                     "unit": unit, 
-                    "weather": "晴朗"
+                    "weather": "Sunny"
                 }, ensure_ascii=False)
               }
             ] 
@@ -456,14 +456,14 @@ def execute_function_call(function_name: str, arguments: dict):
     elif function_name == "search_web":
         query_list = arguments.get("query_list", [])
         query_tag = arguments.get("query_tag", [])
-        # 模拟搜索结果
+        # Simulate search results
         return {
             "role": "tool",
             "content": [
               {
                 "name": function_name,
                 "type": "text",
-                "text": f"搜索关键词: {query_list}, 分类: {query_tag}\n搜索结果: 相关信息已找到"
+                "text": f"Search keywords: {query_list}, Category: {query_tag}\nSearch results: Relevant information found"
               }
             ]
           }
@@ -471,12 +471,12 @@ def execute_function_call(function_name: str, arguments: dict):
     return None
 ```
 
-### 将函数执行结果返回给模型
+### Returning Function Execution Results to the Model
 
-成功解析函数调用后，您应将函数执行结果添加到对话历史中，以便模型在后续交互中能够访问和利用这些信息，拼接格式参考chat_template.jinja
+After successfully parsing function calls, you should add the function execution results to the conversation history so that the model can access and utilize this information in subsequent interactions. Refer to chat_template.jinja for concatenation format.
 
-## 参考资料
+## References
 
-- [MiniMax-M2 模型仓库](https://github.com/MiniMaxAI/MiniMax-M2)
-- [vLLM 项目主页](https://github.com/vllm-project/vllm)
-- [OpenAI Python SDK](https://github.com/openai/openai-python)
+- [MiniMax-M2 Model Repository](https://github.com/MiniMaxAI/MiniMax-M2)
+- [vLLM Project Homepage](https://github.com/vllm-project/vllm)
+- [OpenAI Python SDK](https://github.com/openai/openai-python)

docs/function_call_guide_cn.md

@@ -0,0 +1,482 @@
+# MiniMax-M2 函数调用（Function Call）功能指南
+
+## 简介
+
+MiniMax-M2 模型支持函数调用功能，使模型能够识别何时需要调用外部函数，并以结构化格式输出函数调用参数。本文档详细介绍了如何使用 MiniMax-M2 的函数调用功能。
+
+## 基础示例
+
+以下 Python 脚本基于 OpenAI SDK 实现了一个天气查询函数的调用示例：
+
+```python
+from openai import OpenAI
+import json
+
+client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
+
+def get_weather(location: str, unit: str):
+    return f"Getting the weather for {location} in {unit}..."
+
+tool_functions = {"get_weather": get_weather}
+
+tools = [{
+    "type": "function",
+    "function": {
+        "name": "get_weather",
+        "description": "Get the current weather in a given location",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "location": {"type": "string", "description": "City and state, e.g., 'San Francisco, CA'"},
+                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
+            },
+            "required": ["location", "unit"]
+        }
+    }
+}]
+
+response = client.chat.completions.create(
+    model=client.models.list().data[0].id,
+    messages=[{"role": "user", "content": "What's the weather like in San Francisco? use celsius."}],
+    tools=tools,
+    tool_choice="auto"
+)
+
+print(response)
+
+tool_call = response.choices[0].message.tool_calls[0].function
+print(f"Function called: {tool_call.name}")
+print(f"Arguments: {tool_call.arguments}")
+print(f"Result: {get_weather(**json.loads(tool_call.arguments))}")
+```
+
+**输出示例：**
+```
+Function called: get_weather
+Arguments: {"location": "San Francisco, CA", "unit": "celsius"}
+Result: Getting the weather for San Francisco, CA in celsius...
+```
+
+## 手动解析模型输出
+
+如果您无法使用已支持 MiniMax-M2 的推理引擎的内置解析器，或者需要使用其他推理框架（如 transformers、TGI 等），可以使用以下方法手动解析模型的原始输出。这种方法需要您自己解析模型输出的 XML 标签格式。
+
+### 使用 Transformers 的示例
+
+以下是使用 transformers 库的完整示例：
+
+```python
+from transformers import AutoTokenizer
+
+def get_default_tools():
+    return [
+        {
+          "name": "get_current_weather",
+          "description": "Get the latest weather for a location",
+          "parameters": {
+              "type": "object", 
+              "properties": {
+                  "location": {
+                      "type": "string", 
+                      "description": "A certain city, such as Beijing, Shanghai"
+                  }
+              }, 
+          }
+          "required": ["location"],
+          "type": "object"
+        }
+    ]
+
+# 加载模型和分词器
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+prompt = "What's the weather like in Shanghai today?"
+messages = [
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": prompt},
+]
+
+# 启用函数调用工具
+tools = get_default_tools()
+
+# 应用聊天模板，并加入工具定义
+text = tokenizer.apply_chat_template(
+    messages,
+    tokenize=False,
+    add_generation_prompt=True,
+    tools=tools
+)
+
+# 发送请求（这里使用任何推理服务）
+import requests
+payload = {
+    "model": "MiniMaxAI/MiniMax-M2",
+    "prompt": text,
+    "max_tokens": 4096
+}
+response = requests.post(
+    "http://localhost:8000/v1/completions",
+    headers={"Content-Type": "application/json"},
+    json=payload,
+    stream=False,
+)
+
+# 模型输出需要手动解析
+raw_output = response.json()["choices"][0]["text"]
+print("原始输出:", raw_output)
+
+# 使用下面的解析函数处理输出
+function_calls = parse_tool_calls(raw_output, tools)
+```
+
+## 🛠️ 函数调用的定义
+
+### 函数结构体
+
+函数调用需要在请求体中定义 `tools` 字段，每个函数由以下部分组成：
+
+```json
+{
+  "tools": [
+    {
+      "name": "search_web",
+      "description": "搜索函数。",
+      "parameters": {
+        "properties": {
+          "query_list": {
+            "description": "进行搜索的关键词，列表元素个数为1。",
+            "items": { "type": "string" },
+            "type": "array"
+          },
+          "query_tag": {
+            "description": "query的分类",
+            "items": { "type": "string" },
+            "type": "array"
+          }
+        },
+        "required": [ "query_list", "query_tag" ],
+        "type": "object"
+      }
+    }
+  ]
+}
+```
+
+**字段说明：**
+- `name`: 函数名称
+- `description`: 函数功能描述
+- `parameters`: 函数参数定义
+  - `properties`: 参数属性定义，key 是参数名，value 包含参数的详细描述
+  - `required`: 必填参数列表
+  - `type`: 参数类型（通常为 "object"）
+
+### 模型内部处理格式
+
+在 MiniMax-M2 模型内部处理���，函数定义会被转换为特殊格式并拼接到输入文本中。以下是一个完整的示例：
+
+```
+]~!b[]~b]system
+You are a helpful assistant.
+
+# Tools
+You may call one or more tools to assist with the user query.
+Here are the tools available in JSONSchema format:
+
+<tools>
+<tool>{"name": "search_web", "description": "搜索函数。", "parameters": {"type": "object", "properties": {"query_list": {"type": "array", "items": {"type": "string"}, "description": "进行搜索的关键词，列表元素个数为1。"}, "query_tag": {"type": "array", "items": {"type": "string"}, "description": "query的分类"}}, "required": ["query_list", "query_tag"]}}</tool>
+</tools>
+
+When making tool calls, use XML format to invoke tools and pass parameters:
+
+<minimax:tool_call>
+<invoke name="tool-name-1">
+<parameter name="param-key-1">param-value-1</parameter>
+<parameter name="param-key-2">param-value-2</parameter>
+...
+</invoke>
+[e~[
+]~b]user
+OpenAI 和 Gemini 的最近一次发布会都是什么时候?[e~[
+]~b]ai
+<think>
+```
+
+**格式说明：**
+
+- `]~!b[]~b]system`: System 消息开始标记
+- `[e~[`: 消息结束标记
+- `]~b]user`: User 消息开始标记
+- `]~b]ai`: Assistant 消息开始标记
+- `]~b]tool`: Tool 结果消息开始标记
+- `<tools>...</tools>`: 工具定义区域，每个工具用 `<tool>` 标签包裹，内容为 JSON Schema
+- `<minimax:tool_call>...</minimax:tool_call>`: 工具调用区域
+- `<think>`: 生成时的思考过程标记（可选）
+
+### 模型输出格式
+
+MiniMax-M2使用结构化的 XML 标签格式：
+
+```xml
+<minimax:tool_call>
+<invoke name="search_web">
+<parameter name="query_tag">["technology", "events"]</parameter>
+<parameter name="query_list">["\"OpenAI\" \"latest\" \"release\""]</parameter>
+</invoke>
+<invoke name="search_web">
+<parameter name="query_tag">["technology", "events"]</parameter>
+<parameter name="query_list">["\"Gemini\" \"latest\" \"release\""]</parameter>
+</invoke>
+</minimax:tool_call>
+```
+
+每个函数调用使用 `<invoke name="函数名">` 标签，参数使用 `<parameter name="参数名">` 标签包裹。
+
+## 手动解析函数调用结果
+
+### 解析函数调用
+
+MiniMax-M2使用结构化的 XML 标签，需要不同的解析方式。核心函数如下：
+
+```python
+import re
+import json
+from typing import Any, Optional, List, Dict
+
+
+def extract_name(name_str: str) -> str:
+    """从引号包裹的字符串中提取名称"""
+    name_str = name_str.strip()
+    if name_str.startswith('"') and name_str.endswith('"'):
+        return name_str[1:-1]
+    elif name_str.startswith("'") and name_str.endswith("'"):
+        return name_str[1:-1]
+    return name_str
+
+
+def convert_param_value(value: str, param_type: str) -> Any:
+    """根据参数类型转换参数值"""
+    if value.lower() == "null":
+        return None
+        
+    param_type = param_type.lower()
+    
+    if param_type in ["string", "str", "text"]:
+        return value
+    elif param_type in ["integer", "int"]:
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            return value
+    elif param_type in ["number", "float"]:
+        try:
+            val = float(value)
+            return val if val != int(val) else int(val)
+        except (ValueError, TypeError):
+            return value
+    elif param_type in ["boolean", "bool"]:
+        return value.lower() in ["true", "1"]
+    elif param_type in ["object", "array"]:
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            return value
+    else:
+        # 尝试 JSON 解析，失败则返回字符串
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            return value
+
+
+def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> List[Dict]:
+    """
+    从模型输出中提取所有工具调用
+    
+    Args:
+        model_output: 模型的完整输出文本
+        tools: 工具定义列表，用于获取参数类型信息，格式可以是：
+               - [{"name": "...", "parameters": {...}}]
+               - [{"type": "function", "function": {"name": "...", "parameters": {...}}}]
+    
+    Returns:
+        解析后的工具调用列表，每个元素包含 name 和 arguments 字段
+    
+    Example:
+        >>> tools = [{
+        ...     "name": "get_weather",
+        ...     "parameters": {
+        ...         "type": "object",
+        ...         "properties": {
+        ...             "location": {"type": "string"},
+        ...             "unit": {"type": "string"}
+        ...         }
+        ...     }
+        ... }]
+        >>> output = '''<minimax:tool_call>
+        ... <invoke name="get_weather">
+        ... <parameter name="location">San Francisco</parameter>
+        ... <parameter name="unit">celsius</parameter>
+        ... </invoke>
+        ... </minimax:tool_call>'''
+        >>> result = parse_tool_calls(output, tools)
+        >>> print(result)
+        [{'name': 'get_weather', 'arguments': {'location': 'San Francisco', 'unit': 'celsius'}}]
+    """
+    # 快速检查是否包含工具调用标记
+    if "<minimax:tool_call>" not in model_output:
+        return []
+    
+    tool_calls = []
+    
+    try:
+        # 匹配所有 <minimax:tool_call> 块
+        tool_call_regex = re.compile(r"<minimax:tool_call>(.*?)</minimax:tool_call>", re.DOTALL)
+        invoke_regex = re.compile(r"<invoke name=(.*?)</invoke>", re.DOTALL)
+        parameter_regex = re.compile(r"<parameter name=(.*?)</parameter>", re.DOTALL)
+        
+        # 遍历所有 tool_call 块
+        for tool_call_match in tool_call_regex.findall(model_output):
+            # 遍历该块中的所有 invoke
+            for invoke_match in invoke_regex.findall(tool_call_match):
+                # 提取函数名
+                name_match = re.search(r'^([^>]+)', invoke_match)
+                if not name_match:
+                    continue
+                
+                function_name = extract_name(name_match.group(1))
+                
+                # 获取参数配置
+                param_config = {}
+                if tools:
+                    for tool in tools:
+                        tool_name = tool.get("name") or tool.get("function", {}).get("name")
+                        if tool_name == function_name:
+                            params = tool.get("parameters") or tool.get("function", {}).get("parameters")
+                            if isinstance(params, dict) and "properties" in params:
+                                param_config = params["properties"]
+                            break
+                
+                # 提取参数
+                param_dict = {}
+                for match in parameter_regex.findall(invoke_match):
+                    param_match = re.search(r'^([^>]+)>(.*)', match, re.DOTALL)
+                    if param_match:
+                        param_name = extract_name(param_match.group(1))
+                        param_value = param_match.group(2).strip()
+                        
+                        # 去除首尾的换行符
+                        if param_value.startswith('\n'):
+                            param_value = param_value[1:]
+                        if param_value.endswith('\n'):
+                            param_value = param_value[:-1]
+                        
+                        # 获取参数类型并转换
+                        param_type = "string"
+                        if param_name in param_config:
+                            if isinstance(param_config[param_name], dict) and "type" in param_config[param_name]:
+                                param_type = param_config[param_name]["type"]
+                        
+                        param_dict[param_name] = convert_param_value(param_value, param_type)
+                
+                tool_calls.append({
+                    "name": function_name,
+                    "arguments": param_dict
+                })
+    
+    except Exception as e:
+        print(f"解析工具调用失败: {e}")
+        return []
+    
+    return tool_calls
+```
+
+**使用示例：**
+
+```python
+# 定义工具
+tools = [
+    {
+        "name": "get_weather",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "location": {"type": "string"},
+                "unit": {"type": "string"}
+            },
+            "required": ["location", "unit"]
+        }
+    }
+]
+
+# 模型输出
+model_output = """我来帮你查询天气。
+<minimax:tool_call>
+<invoke name="get_weather">
+<parameter name="location">San Francisco</parameter>
+<parameter name="unit">celsius</parameter>
+</invoke>
+</minimax:tool_call>"""
+
+# 解析工具调用
+tool_calls = parse_tool_calls(model_output, tools)
+
+# 输出结果
+for call in tool_calls:
+    print(f"调用函数: {call['name']}")
+    print(f"参数: {call['arguments']}")
+    # 输出: 调用函数: get_weather
+    #      参数: {'location': 'San Francisco', 'unit': 'celsius'}
+```
+
+### 执行函数调用
+
+解析完成后，您可以执行对应的函数并构建返回结果：
+
+```python
+def execute_function_call(function_name: str, arguments: dict):
+    """执行函数调用并返回结果"""
+    if function_name == "get_weather":
+        location = arguments.get("location", "未知位置")
+        unit = arguments.get("unit", "celsius")
+        # 构建函数执行结果
+        return {
+            "role": "tool", 
+            "content": [
+              {
+                "name": function_name,
+                "type": "text",
+                "text": json.dumps({
+                    "location": location, 
+                    "temperature": "25", 
+                    "unit": unit, 
+                    "weather": "晴朗"
+                }, ensure_ascii=False)
+              }
+            ] 
+          }
+    elif function_name == "search_web":
+        query_list = arguments.get("query_list", [])
+        query_tag = arguments.get("query_tag", [])
+        # 模拟搜索结果
+        return {
+            "role": "tool",
+            "content": [
+              {
+                "name": function_name,
+                "type": "text",
+                "text": f"搜索关键词: {query_list}, 分类: {query_tag}\n搜索结果: 相关信息已找到"
+              }
+            ]
+          }
+    
+    return None
+```
+
+### 将函数执行结果返回给模型
+
+成功解析函数调用后，您应将函数执行结果添加到对话历史中，以便模型在后续交互中能够访问和利用这些信息，拼接格式参考chat_template.jinja
+
+## 参考资料
+
+- [MiniMax-M2 模型仓库](https://github.com/MiniMaxAI/MiniMax-M2)
+- [vLLM 项目主页](https://github.com/vllm-project/vllm)
+- [OpenAI Python SDK](https://github.com/openai/openai-python)