[Supplements and upgrades]Improvement of X1 parsers (#4172)

* reasoning_parser

* reasoning_parser

* reasoning_parser

* reasoning_parser

* reasoning_parser

* reasoning_parser

* reasoning_parser

Author: AuferGachet

fastdeploy/entrypoints/openai/tool_parsers/ernie_x1_tool_parser.py

@@ -1,3 +1,4 @@
+"""
 # Copyright (c) 2025  PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"
@@ -11,6 +12,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+"""
 
 import json
 import re
@@ -97,37 +99,37 @@ def extract_tool_calls(self, model_output: str, request: ChatCompletionRequest)
             remaining_text = model_output
 
             while True:
-                # 查找下一个tool_call块
+                # Find the next <tool_call>
                 tool_call_pos = remaining_text.find("<tool_call>")
                 if tool_call_pos == -1:
                     break
 
-                # 提取tool_call开始位置后的内容
+                # Extract content after <tool_call>
                 tool_content_start = tool_call_pos + len("<tool_call>")
                 tool_content_end = remaining_text.find("</tool_call>", tool_content_start)
 
                 tool_json = ""
                 if tool_content_end == -1:
-                    # 处理未闭合的tool_call块（截断情况）
+                    # Processing unclosed tool_call block (truncated case)
                     tool_json = remaining_text[tool_content_start:].strip()
-                    remaining_text = ""  # 没有更多内容需要处理
+                    remaining_text = ""  # No more content to process
                 else:
-                    # 处理完整的tool_call块
+                    # Processing closed </tool_call> block
                     tool_json = remaining_text[tool_content_start:tool_content_end].strip()
                     remaining_text = remaining_text[tool_content_end + len("</tool_call>") :]
 
                 if not tool_json:
                     continue
 
-                # 处理JSON内容
+                # Process tool_json
                 tool_json = tool_json.strip()
                 if not tool_json.startswith("{"):
                     tool_json = "{" + tool_json
                 if not tool_json.endswith("}"):
                     tool_json = tool_json + "}"
 
                 try:
-                    # 首先尝试标准JSON解析
+                    # Parsing strategy: First try standard json.loads
                     try:
                         tool_data = json.loads(tool_json)
 
@@ -136,26 +138,26 @@ def extract_tool_calls(self, model_output: str, request: ChatCompletionRequest)
                                 {
                                     "name": tool_data["name"],
                                     "arguments": tool_data["arguments"],
-                                    "_is_complete": True,  # 明确标记为完整解析
+                                    "_is_complete": True,  # Mark as complete
                                 }
                             )
                             continue
                     except json.JSONDecodeError:
                         pass
 
-                    # 标准解析失败时尝试partial_json_parser
+                    # Try partial_json_parser when standard parsing fails
                     from partial_json_parser.core.options import Allow
 
                     try:
                         tool_data = {}
                         flags = Allow.ALL & ~Allow.STR
 
-                        # 解析name字段
+                        # Parse the name field
                         name_match = re.search(r'"name"\s*:\s*"([^"]*)"', tool_json)
                         if name_match:
                             tool_data["name"] = name_match.group(1)
 
-                        # 解析arguments字段
+                        # Parse the arguments field
                         args_match = re.search(r'"arguments"\s*:\s*(\{.*)', tool_json)
                         if args_match:
                             try:
@@ -168,7 +170,7 @@ def extract_tool_calls(self, model_output: str, request: ChatCompletionRequest)
                                 {
                                     "name": tool_data.get("name", ""),
                                     "arguments": tool_data.get("arguments", {}),
-                                    "_is_partial": True,  # 标记为部分解析
+                                    "_is_partial": True,  # Mark as partial
                                 }
                             )
                     except Exception as e:
@@ -183,18 +185,18 @@ def extract_tool_calls(self, model_output: str, request: ChatCompletionRequest)
                 return ExtractedToolCallInformation(tools_called=False, content=model_output)
 
             tool_calls = []
-            all_complete = True  # 初始设为True，只要有一个不完整就变为False
+            all_complete = True  # Initialize as all complete
 
             for tool_call in function_call_arr:
-                # 记录工具调用解析状态
+                # Set flags
                 is_complete = tool_call.get("_is_complete", False)
                 is_partial = tool_call.get("_is_partial", False)
 
-                # 只要有一个不完整就认为整体不完整
+                # If any tool call is incomplete or partial, mark all_complete as False
                 if not is_complete or is_partial:
                     all_complete = False
 
-                # 处理参数序列化
+                # Process arguments
                 tool_args = tool_call.get("arguments", {})
                 if not isinstance(tool_args, dict):
                     tool_args = {}
@@ -215,7 +217,7 @@ def extract_tool_calls(self, model_output: str, request: ChatCompletionRequest)
                     )
                 )
 
-            # 只有当所有工具调用都明确标记为complete时才返回tools_called=True
+            # Only return tools_called=True if all tool calls are complete
             return ExtractedToolCallInformation(
                 tools_called=all_complete, tool_calls=tool_calls if tool_calls else None, content=""
             )
@@ -237,16 +239,16 @@ def extract_tool_calls_streaming(
 
         if self.tool_call_start_token_id not in current_token_ids:
             return DeltaMessage(content=delta_text)
-        # 忽略空chunk
+        # Skip empty chunks
         if len(delta_text.strip()) == 0:
             return None
 
         try:
             delta = None
-            # 使用buffer累积delta_text内容
+            # Use buffer to accumulate delta_text content
             self.buffer += delta_text
 
-            # 处理增量中的新tool_call开始
+            # Process the buffer content
             if "<tool_call>" in delta_text:
                 self.current_tool_id = (
                     max(self.current_tool_id, 0) if self.current_tool_id == -1 else self.current_tool_id + 1
@@ -256,7 +258,7 @@ def extract_tool_calls_streaming(
                     self.streamed_args_for_tool.append("")
                 data_processor_logger.debug(f"New tool call started with ID: {self.current_tool_id}")
 
-            # 1. 尝试解析name字段
+            # 1. Try to parse the name field
             if not self.current_tool_name_sent and '"name"' in self.buffer:
                 name_match = re.search(r'"name"\s*:\s*"([^"]*)"', self.buffer)
                 if name_match:
@@ -272,32 +274,31 @@ def extract_tool_calls_streaming(
                                 )
                             ]
                         )
-                        # 删除已处理的name部分
+                        # Delete the processed name part from the buffer
                         self.buffer = self.buffer[name_match.end() :]
                         self.current_tool_name_sent = True
                         return delta
-            # 2. 尝试解析arguments字段
+            # 2. Processing arguments field
             if '"arguments"' in self.buffer:
                 args_match = re.search(r'"arguments"\s*:\s*(\{.*)', self.buffer)
                 if args_match:
                     args_content = args_match.group(1)
                     try:
-                        # 检查是否到达arguments结尾(括号完全匹配)
+                        # Check if arguments field is complete by bracket matching
                         if "}}" in args_content:
-                            # 逐个字符检查括号匹配状态
                             matched_pos = -1
                             for i, ch in enumerate(delta_text):
                                 if ch == "{":
                                     self.bracket_counts["total_l"] += 1
                                 elif ch == "}":
                                     self.bracket_counts["total_r"] += 1
 
-                                if self.bracket_counts["total_l"] == self.bracket_counts["total_r"]:  # 括号完全匹配
+                                if self.bracket_counts["total_l"] == self.bracket_counts["total_r"]:
                                     matched_pos = i
                                     break
 
                             if matched_pos >= 0:
-                                # 找到匹配点，清理buffer并返回
+                                # Clean up bracket counts for next tool call
                                 truncate_text = delta_text[: matched_pos + 1]
                                 delta = DeltaMessage(
                                     tool_calls=[
@@ -312,10 +313,10 @@ def extract_tool_calls_streaming(
                                 self.buffer = self.buffer[args_match.end() :]
                                 return delta
                             else:
-                                # 没有完全匹配，继续累积
+                                # No complete match yet
                                 return None
                         else:
-                            # 增量返回当前可解析的部分
+                            # Return partial arguments
                             for ch in delta_text:
                                 if ch == "{":
                                     self.bracket_counts["total_l"] += 1
@@ -337,7 +338,6 @@ def extract_tool_calls_streaming(
                 end_pos = self.buffer.find("</tool_call>")
                 self.buffer = self.buffer[end_pos + len("</tool_call>") :]
 
-                # 完成当前工具调用处理
                 self.streamed_args_for_tool.append("")
 
             return delta

fastdeploy/reasoning/ernie_x1_reasoning_parsers.py

@@ -1,19 +1,3 @@
-"""
-# Copyright (c) 2025  PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-
 from collections.abc import Sequence
 from typing import Tuple, Union
 
@@ -26,10 +10,10 @@ class ErnieX1ReasoningParser(ReasoningParser):
     """
     Reasoning parser for ernie_x1 model with stricter boundary checking.
 
-    This implementation follows the user's proposed approach:
-    1. For thinking content: waits for \n then checks for </think> tag
-    2. For response content: checks for <response> tag first, then waits for \n
-    3. Handles newlines in content more precisely
+    Unified rules:
+    - Do not strip newline before </think>
+    - Do not strip newline after <response>
+    - Do not strip newline before </response>
     """
 
     def __init__(self, tokenizer):
@@ -48,9 +32,6 @@ def __init__(self, tokenizer):
             raise RuntimeError("Could not find think end token id in tokenizer vocabulary")
         self.tool_call_start_token_id = self.vocab.get("<tool_call>")
 
-    def is_reasoning_end(self, input_ids: list[int]) -> bool:
-        return self.tool_call_start_token_id in input_ids
-
     def extract_reasoning_content_streaming(
         self,
         previous_text: str,
@@ -60,102 +41,63 @@ def extract_reasoning_content_streaming(
         current_token_ids: Sequence[int],
         delta_token_ids: Sequence[int],
     ) -> Union[DeltaMessage, None]:
-        """
-        根据用户需求实现的流式解析方法:
-        1. 初始内容都视为思考内容，返回delta_text,""
-        2. 当遇到\n时检查后续是否是</think>
-        3. 如果直接遇到</think>也结束思考
-        4. 思考结束后检查是<response>还是<tool_call>
-        5. 对于<response>内容，处理各种边界条件
-        """
+        # Ignore the single </think> token
         if len(delta_token_ids) == 1 and delta_token_ids[0] == self.think_end_token_id:
             return None
-        # 思考阶段处理
+
+        # --- Thinking stage handling ---
         if not previous_text.endswith(self.think_end_token) and self.think_end_token not in previous_text:
-            # 如果遇到\n，暂时不返回，等待下一个delta_text
-            if delta_text == "\n":
-                return None
-            # 如果前一个是\n且当前是</think>，结束思考
-            elif previous_text.endswith("\n") and delta_text.startswith(self.think_end_token):
-                return None
-            # 如果直接遇到</think>也结束思考
-            elif delta_text.startswith(self.think_end_token):
+            # If delta is </think>, stop thinking, do not return
+            if delta_text.startswith(self.think_end_token):
                 return None
-            # 否则继续返回思考内容
+            # Otherwise, return thinking content (keep \n as-is)
             return DeltaMessage(reasoning_content=delta_text)
 
-        # 思考结束后检查是tool_call还是response
+        # --- After thinking ends, check tool_call or response ---
         remaining_text = previous_text + delta_text
         after_think = remaining_text[remaining_text.find(self.think_end_token) + len(self.think_end_token) :]
-        after_think = after_think.lstrip("\n")  # 跳过think后的换行
+        after_think = after_think.lstrip("\n")
 
-        # 处理tool_call情况
+        # Handle tool_call case: skip it
         if after_think.startswith(self.tool_call_start_token):
             return None
 
-        # 处理response情况
-        if after_think.startswith(self.response_start_token):
-            # 遇到<response>标签时不立即返回
-            if delta_text == self.response_start_token:
+        # Handle response case
+        if after_think.startswith(self.response_start_token) and self.response_end_token not in after_think:
+            # Do not return when <response> tag itself appears
+            if delta_text == self.response_start_token or delta_text == self.response_end_token:
                 return None
-            # 遇到<response>后的换行符也不立即返回
-            elif delta_text == "\n" and previous_text.endswith(self.response_start_token):
-                return None
-            # 处理回复内容中的换行符
-            if delta_text == "\n":
-                return None
-            # 如果前一个是\n且当前是</response>，结束回复
-            elif previous_text.endswith("\n") and delta_text == self.response_end_token:
-                return None
-            # 如果直接遇到</response>也结束回复
-            elif delta_text == self.response_end_token:
-                return None
-            # 其他情况返回实际内容
-            else:
-                return DeltaMessage(content=delta_text)
+            return DeltaMessage(content=delta_text)
 
-        # 默认情况不返回内容
+        # Default case: return nothing
         return None
 
     def extract_reasoning_content(self, model_output: str, request: ChatCompletionRequest) -> Tuple[str, str]:
-        """
-        Batch version of the enhanced parser.
-        Modified to preserve newlines in both reasoning and response content,
-        only removing the single newline before closing tags.
-        """
         reasoning_content = ""
         response_content = ""
 
         think_end_pos = model_output.find(self.think_end_token)
         if think_end_pos != -1:
-            # Extract thinking content - only remove the last newline before </think>
             reasoning_content = model_output[:think_end_pos]
-            if think_end_pos > 0 and reasoning_content[-1] == "\n":
-                reasoning_content = reasoning_content[:-1]
 
             remaining = model_output[think_end_pos + len(self.think_end_token) :]
 
-            # Skip newlines after </think>
-            remaining = remaining.lstrip("\n")
+            # find <response> or <tool>
+            response_pos = remaining.find(self.response_start_token)
+            tool_pos = remaining.find(self.tool_call_start_token)
 
-            # Check for response or tool_call
-            if remaining.startswith(self.response_start_token):
-                response_pos = len(self.response_start_token)
-                remaining = remaining[response_pos:].lstrip("\n")
-                response_end_pos = remaining.find(self.response_end_token)
+            # <response> first
+            if response_pos != -1 and (tool_pos == -1 or response_pos < tool_pos):
+                # The content after the response_start position
+                remaining_response = remaining[response_pos + len(self.response_start_token) :]
+                response_end_pos = remaining_response.find(self.response_end_token)
                 if response_end_pos != -1:
-                    # Only strip the last newline before </response>, not all
-                    if response_end_pos > 0 and remaining[response_end_pos - 1] == "\n":
-                        response_content = remaining[: response_end_pos - 1]
-                    else:
-                        response_content = remaining[:response_end_pos]
+                    response_content = remaining_response[:response_end_pos]
                 else:
-                    # If no </response> found, return the rest as response content
-                    response_content = remaining
-            elif remaining.startswith(self.tool_call_start_token):
-                pass  # No response content
+                    response_content = remaining_response
+            # The content after the response_start position is tool_call
         else:
-            # No thinking content found, return the whole input as reasoning
             reasoning_content = model_output
             response_content = ""
+
         return reasoning_content, response_content